diff --git a/quest/m1/quic/README.md b/quest/m1/quic/README.md index f20b9def8b4..13def531538 100644 --- a/quest/m1/quic/README.md +++ b/quest/m1/quic/README.md @@ -63,8 +63,9 @@ cache limits remain separate; bitrate pacing composes with this memory cap. ## Required - [Bound message assembly](/quest/m1/quic/receive-memory.md) - complete headers and frames return credit, and receiver priority cancellation restores progress -- [Reliable stream reset](/quest/m1/quic/reliable-reset.md) - `RESET_STREAM_AT`, - so a reset WebTransport stream still delivers its header +- [A reset group keeps its header](/quest/m1/quic/group-reset.md) - a lite + publisher resets a group with `RESET_STREAM_AT`, so its subscriber drops the + tail grace - [Hierarchical stream scheduling](/quest/m1/quic/scheduler.md) - strict subscription priority, fair buckets, and newest-first group order replace the lossy scalar; retransmits follow the same order diff --git a/quest/m1/quic/group-reset.md b/quest/m1/quic/group-reset.md new file mode 100644 index 00000000000..1b851760e6a --- /dev/null +++ b/quest/m1/quic/group-reset.md @@ -0,0 +1,64 @@ +# [M] A reset group keeps its header + +## Goal + +A moq-lite publisher on a native QUIC or WebTransport stack resets a group +stream with `RESET_STREAM_AT`, still delivering the group header, so the +subscriber can always tell which group the reset belongs to. A subscriber +that knows its publisher does this stops waiting out the tail grace for +groups whose reset lost the header (`rs/moq-net/src/tail.rs`, +`js/net/src/tail.ts`). Subscribers whose publisher cannot do it, such as a +browser, keep the grace. + +## Plan + +Split from the transport half, which landed in `moq-quic`, +`moq_tokio::quic::web`, and moq-uring's WebTransport adapter (#5690). There, +`SendStream::checkpoint()` marks the data written so far and +`Checkpoint::reset(code)` sends `RESET_STREAM_AT` with that offset as the +Reliable Size. A peer without the extension instead gets a plain +`RESET_STREAM` once it has acknowledged the data before the checkpoint, a round +trip later. The WebTransport adapters already keep their own stream header +this way. + +That fallback is weaker than it looks. An ACK only means the peer's QUIC stack +holds the bytes, not that its application read them, and RFC 9000 lets a +receiver discard unread data on `RESET_STREAM`. The WebTransport header +survives because receiving stacks parse it on arrival. A MoQ group header is +read by the application, so check whether Chrome hands it to JS when a plain +`RESET_STREAM` follows the ACK, and treat a peer without `reset_stream_at` as +unable to keep the header unless it does. + +- Give moq-net's `transport::poll::SendStream` a reset that keeps a + checkpoint, using `Checkpoint` rather than a byte count, so a size past the + written data cannot be asked for. Implement it in the moq-tokio and + moq-uring adapters. Backends that cannot do it (browser, qmux, iroh) report + that rather than silently sending a plain reset. +- The lite publisher checkpoints right after writing a group header and + resets the group from that checkpoint. +- QUIC negotiation alone cannot drop the grace. A peer's stack can advertise + `reset_stream_at` while its application never sends one, as a browser + publisher whose WebTransport API has no reliable reset. Dropping the grace + on negotiation would hang the tail. So the publisher declares it with a + MoQ-level signal, per session, since each relay hop re-serves groups on its + own streams. Open: the signal's shape (a SETUP parameter or a version + feature), and how it composes with SUBSCRIBE_DROP, which already names a + group reset before its header on lite-05 and later. Any wire change updates + `drafts/draft-lcurley-moq-lite.md`. +- Remove the grace for subscriptions on sessions that declare it, in Rust and + `@moq/net`. Datagram holes still wait out the grace. + +Test a group reset before any payload with and without the signal, both +directions between Rust and `@moq/net`, and through a relay hop. Cover it in +the Chrome wasm harness and the native interop matrix, which the transport +half did not reach. + +## Related + +- [SUBSCRIBE_DROP accounts for every group](/quest/m1/subscribe-drop.md) - a + DROP covers a reset whose header was lost; a reset that keeps its header acts + as a one-group drop +- [Per-stream ACK progress](/quest/m2/quic-ack-progress.md) - adds + `Checkpoint::acked()` to the same handle +- [qmux on the QUIC stream state machine](/quest/m2/quic-qmux.md) - qmux reuses + `moq-quic`'s reset state diff --git a/quest/m1/quic/reliable-reset.md b/quest/m1/quic/reliable-reset.md deleted file mode 100644 index 7f97964bf23..00000000000 --- a/quest/m1/quic/reliable-reset.md +++ /dev/null @@ -1,74 +0,0 @@ -# [L] Implement QUIC reliable stream reset - -## Goal - -`moq-quic` and moq-tokio's WebTransport adapter (`quic::web`) implement -[QUIC Stream Resets with Partial Delivery](https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/). -A reset WebTransport data stream reliably delivers enough prefix bytes for the -receiver to associate it with its session before surfacing the application -error. - -This supplies the missing transport feature tracked by -[Quinn#2676](https://github.com/quinn-rs/quinn/issues/2676). WebTransport over -HTTP/3 draft 16 requires `RESET_STREAM_AT` with a Reliable Size covering the -WebTransport stream header; ordinary `RESET_STREAM` is not compliant because -the receiver may discard that header and cannot attribute the reset. - -## Plan - -Implement the current reliable-reset draft in `moq-quic`: - -- advertise and validate the empty `reset_stream_at` transport parameter, - including remembered negotiation state for 0-RTT; -- encode, decode, acknowledge, lose, and retransmit `RESET_STREAM_AT` frames; -- retain and retransmit STREAM data below the smallest Reliable Size while - abandoning data above it; -- enforce Reliable Size, Final Size, flow-control, repeated-reset, FIN, and - STOP_SENDING state transitions and their specified connection errors; -- withhold the receive-side reset until the reliable prefix is deliverable, - while preserving the application error and final size. - -Expose a typed send-stream operation that takes an application error and -reliable prefix length. It must fail before mutating stream state when the -peer did not negotiate support or the requested sizes are invalid. Keep the -ordinary immediate reset operation for callers that need no reliable prefix. - -The WebTransport layer owns its framing offset. When it resets a data stream, -it adds the encoded stream type or signal value and session ID to the -application's reliable prefix, and always commits at least through that -header. Callers must not calculate or pass the hidden WebTransport header -length. Preserve WebTransport application error codes unchanged on send, -receive, and intermediary forwarding. - -qmux on this shared state machine is [qmux on the QUIC stream state -machine](/quest/m2/quic-qmux.md)'s (moved to m2 in the 2026-09-30 audit); -this quest is native QUIC and WebTransport only. - -Test negotiation on/off and 0-RTT, loss and reordering of both the frame and -prefix data, shrinking Reliable Size, reset after FIN, flow-control blocking, -STOP_SENDING, malformed sizes, and resource cleanup. Add an end-to-end -WebTransport regression that opens a stream, writes no application payload, -resets immediately, and proves the peer receives the session association and -error instead of timing out. Exercise it through the Chrome wasm harness and -the native interop matrix. - -Then use it in MoQ. A publisher that resets a group stream uses a Reliable -Size covering the group header, so the subscriber can always attribute the -reset to its group. Once reliable reset is negotiated, subscribers drop the -grace they wait for missing groups below a track's declared end -(`rs/moq-net/src/tail.rs`, `js/net/src/tail.ts`). Browsers keep the grace until -WebTransport exposes reliable reset. - -Track the unversioned draft during implementation. The planning baseline is -draft 10, with transport parameter `0x1d` and frame type `0x24`; do not freeze -provisional codepoints if the document changes before release. - -## Related - -- moq-net (`rs/moq-net/src/tail.rs`) and `@moq/net` (`js/net/src/tail.ts`) wait - a grace for a group whose reset lost its header until this lands -- The removed quiche backend was the one stack that had this, so it is the - known browser-compliance gap. -- [qmux on the QUIC stream state machine](/quest/m2/quic-qmux.md) - consumes - the same reset state without a parallel implementation -- [noq#809](https://github.com/n0-computer/noq/issues/809) - the RESET_STREAM_AT ask to n0 diff --git a/quest/m1/subscribe-drop.md b/quest/m1/subscribe-drop.md index fcc3a52e2cc..9c448855053 100644 --- a/quest/m1/subscribe-drop.md +++ b/quest/m1/subscribe-drop.md @@ -31,7 +31,7 @@ Decided: - lite-07 restores SUBSCRIBE_DROP and removes `Stream Count`. With every sequence accounted for, the count is redundant; one mechanism instead of two. A reset whose header may be lost is covered by a DROP. -- A reliable reset ([Reliable stream reset](/quest/m1/quic/reliable-reset.md)) +- A reliable reset ([A reset group keeps its header](/quest/m1/quic/group-reset.md)) that keeps the stream header acts as a one-group drop, an optimization over sending the DROP. - Publishers send SUBSCRIBE_DROP on lite-05 and lite-06 too: for every group diff --git a/quest/m2/quic-ack-progress.md b/quest/m2/quic-ack-progress.md index 1700926c416..ac73c222784 100644 --- a/quest/m2/quic-ack-progress.md +++ b/quest/m2/quic-ack-progress.md @@ -34,6 +34,10 @@ stream teardown: the accessor must not return a prefix that includes bytes the peer will never acknowledge, and a waiter for an offset beyond the final size must resolve with the reset instead of hanging. +Decided 2026-10-16 (maintainer, #5690): the waiter is `Checkpoint::acked()` +on the send-stream checkpoint that `RESET_STREAM_AT` already uses, so an +acknowledged offset is named the same way a reliable reset's is. + The `web-transport-moq` half of [the ACK hook](/quest/m2/quic-ack-hook.md) is in-tree too and can land in the same PR. diff --git a/quest/m2/quic-qmux.md b/quest/m2/quic-qmux.md index 1c07c86f9f9..5daecf88dfc 100644 --- a/quest/m2/quic-qmux.md +++ b/quest/m2/quic-qmux.md @@ -44,8 +44,8 @@ receive-offset accessor, frame-iterator access, and limited datagram helper visibility. Review each exposure as a reusable internal boundary rather than making the whole QUIC connection public. -`RESET_STREAM_AT` is a QUIC extension, not a qmux-specific frame. Once the -reliable-reset quest lands, make qmux drive that shared send and receive state +`RESET_STREAM_AT` is a QUIC extension, not a qmux-specific frame, and +`moq-quic` now implements it (#5690). Make qmux drive that shared send and receive state instead of retaining the prototype's local parsing and transitions. Because qmux runs over a reliable ordered transport, serialization acknowledges the committed prefix immediately, but the receiver must still delay the reset @@ -78,8 +78,6 @@ the fork plan the same day kept it there. ## Required -- [Reliable stream reset](/quest/m1/quic/reliable-reset.md) - qmux reuses the - extension's stream state rather than implementing reset locally - [Hierarchical stream scheduling](/quest/m1/quic/scheduler.md) - qmux must expose the same scheduling contract as native QUIC diff --git a/rs/moq-quic/README.md b/rs/moq-quic/README.md index 26c9b544068..703c5433541 100644 --- a/rs/moq-quic/README.md +++ b/rs/moq-quic/README.md @@ -66,6 +66,7 @@ Changes on top of the upstream commit, besides the renames: - `TransportConfig::handshake_idle_timeout` (default 10s, as msquic's `HandshakeIdleTimeoutMs`) governs the idle timer until the handshake completes, and the negotiated idle timeout takes over once established. A 2s idle timeout otherwise expires 3x the initial PTO in, just before the second Initial probe, leaving a client two flights. A server also drops an Initial left waiting for `accept` past it, and a deadline too far out to represent never fires instead of panicking. Also [moq-dev/noq#34](https://github.com/moq-dev/noq/pull/34), whose third change (the handshake idle timeout picks noq's idle-based PTO interval cap) has nothing to apply to here, since quinn's PTO backoff has no such cap. quinn's `handshake_timeout` test in its async layer expects the handshake to end at the idle timeout, so the driver's copy sets both timeouts. - **Instants on [moq-clock](../moq-clock)**: the crate's `Instant` is `moq_clock::Instant`, so one clock steps every timer, tokio's paused clock and the simulator included. qlog stamps events relative to `QlogConfig::start_time` on that clock rather than the streamer's own `std::time::Instant`. +- **`RESET_STREAM_AT`** ([draft-ietf-quic-reliable-stream-reset](https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/)): the `reset_stream_at` transport parameter is always advertised, `Checkpoint::reset` (from `SendStream::checkpoint`) keeps the data written before the checkpoint reliable, holding a plain `RESET_STREAM` until that data is acknowledged when the peer lacks the extension, and a received reset surfaces only once the reliable prefix has been read. Stopping a stream after it was reset no longer credits its unread data twice. - **Draining endpoint event**: `EndpointEvent::is_draining` fires once per connection when it stops being active, before the drained event, so the driver's `Endpoint::wait_all_draining` can end a shutdown without sitting out every closing period. Recheck the BBR3 changes when cherry-picking quinn#2481 updates, or if it merges. diff --git a/rs/moq-quic/src/config/transport.rs b/rs/moq-quic/src/config/transport.rs index 48e26c5b661..76ec78421d1 100644 --- a/rs/moq-quic/src/config/transport.rs +++ b/rs/moq-quic/src/config/transport.rs @@ -50,6 +50,8 @@ pub struct TransportConfig { pub(crate) allow_spin: bool, pub(crate) datagram_receive_buffer_size: Option, pub(crate) datagram_send_buffer_size: usize, + /// Advertise and accept RESET_STREAM_AT; only tests turn it off + pub(crate) reset_stream_at: bool, #[cfg(test)] pub(crate) deterministic_packet_numbers: bool, @@ -332,6 +334,13 @@ impl TransportConfig { self } + /// Whether to advertise support for receiving RESET_STREAM_AT + #[cfg(test)] + pub(crate) fn reset_stream_at(&mut self, enabled: bool) -> &mut Self { + self.reset_stream_at = enabled; + self + } + /// Whether to force every packet number to be used /// /// By default, packet numbers are occasionally skipped to ensure peers aren't ACKing packets @@ -419,6 +428,7 @@ impl Default for TransportConfig { allow_spin: true, datagram_receive_buffer_size: Some(STREAM_RWND as usize), datagram_send_buffer_size: 1024 * 1024, + reset_stream_at: true, #[cfg(test)] deterministic_packet_numbers: false, @@ -457,6 +467,7 @@ impl fmt::Debug for TransportConfig { allow_spin, datagram_receive_buffer_size, datagram_send_buffer_size, + reset_stream_at, #[cfg(test)] deterministic_packet_numbers: _, congestion_controller_factory: _, @@ -494,6 +505,7 @@ impl fmt::Debug for TransportConfig { .field("allow_spin", allow_spin) .field("datagram_receive_buffer_size", datagram_receive_buffer_size) .field("datagram_send_buffer_size", datagram_send_buffer_size) + .field("reset_stream_at", reset_stream_at) // congestion_controller_factory not debug .field("enable_segmentation_offload", enable_segmentation_offload); if cfg!(feature = "qlog") { diff --git a/rs/moq-quic/src/connection/assembler.rs b/rs/moq-quic/src/connection/assembler.rs index 8e6d385ec14..99c050b2216 100644 --- a/rs/moq-quic/src/connection/assembler.rs +++ b/rs/moq-quic/src/connection/assembler.rs @@ -232,6 +232,40 @@ impl Assembler { self.bytes_read } + /// Number of bytes before `end` the application has yet to read, received or not + pub(super) fn unread_before(&self, end: u64) -> u64 { + let State::Unordered { recvd } = &self.state else { + return end.saturating_sub(self.bytes_read); + }; + // Unordered reads leave holes, so count what was received and not yet handed out + let clip = |range: std::ops::Range| range.end.min(end).saturating_sub(range.start); + let received: u64 = recvd.iter().map(clip).sum(); + let buffered: u64 = self + .data + .iter() + .map(|buffer| clip(buffer.offset..buffer.end())) + .sum(); + end - received + buffered + } + + /// Discard buffered data at or past `end` + pub(super) fn truncate(&mut self, end: u64) { + let (mut buffered, mut allocated) = (self.buffered, self.allocated); + self.data.retain_mut(|buffer| { + if buffer.offset >= end { + buffered -= buffer.bytes.len(); + allocated -= buffer.allocation_size; + return false; + } + let excess = buffer.end().saturating_sub(end) as usize; + buffer.bytes.truncate(buffer.bytes.len() - excess); + buffered -= excess; + true + }); + self.buffered = buffered; + self.allocated = allocated; + } + /// Discard all buffered data pub(super) fn clear(&mut self) { self.data.clear(); @@ -937,6 +971,44 @@ mod test { assert_eq!(&got[..], b"abcdefghij"); } + #[test] + fn truncate_ordered() { + let mut x = Assembler::new(); + x.insert(0, Bytes::from_static(b"abc"), 3).unwrap(); + x.insert(2, Bytes::from_static(b"cdefg"), 5).unwrap(); + x.insert(6, Bytes::from_static(b"gh"), 2).unwrap(); + assert_eq!(next(&mut x, 2), Some(Bytes::from_static(b"ab"))); + assert_eq!(x.unread_before(5), 3); + x.truncate(5); + assert_sorted(&x); + assert_eq!(x.buffered, 4); + assert_eq!(next(&mut x, usize::MAX), Some(Bytes::from_static(b"cde"))); + assert_eq!(next(&mut x, usize::MAX), None); + assert_eq!(x.unread_before(5), 0); + assert_eq!(x.unread_before(9), 4); + } + + #[test] + fn truncate_unordered() { + let mut x = Assembler::new(); + x.ensure_ordering(false).unwrap(); + x.insert(4, Bytes::from_static(b"efgh"), 4).unwrap(); + x.insert(0, Bytes::from_static(b"a"), 1).unwrap(); + assert_eq!( + next_unordered(&mut x), + Chunk::new(0, Bytes::from_static(b"a")) + ); + // 1..4 was never received, and 4..6 is buffered + assert_eq!(x.unread_before(6), 5); + x.truncate(6); + assert_eq!( + next_unordered(&mut x), + Chunk::new(4, Bytes::from_static(b"ef")) + ); + assert_eq!(x.unread_before(6), 3); + assert_eq!(x.read(usize::MAX, false), None); + } + fn next_unordered(x: &mut Assembler) -> Chunk { x.read(usize::MAX, false).unwrap() } diff --git a/rs/moq-quic/src/connection/mod.rs b/rs/moq-quic/src/connection/mod.rs index 7580f622668..3425f00ba2b 100644 --- a/rs/moq-quic/src/connection/mod.rs +++ b/rs/moq-quic/src/connection/mod.rs @@ -99,8 +99,8 @@ pub use streams::StreamsState; #[cfg(not(fuzzing))] use streams::StreamsState; pub use streams::{ - Chunks, ClosedStream, Credit, FinishError, ReadError, ReadableError, RecvStream, SendStream, - ShouldTransmit, StreamEvent, Streams, WriteError, Written, + Checkpoint, Chunks, ClosedStream, Credit, FinishError, ReadError, ReadableError, RecvStream, + SendStream, ShouldTransmit, StreamEvent, Streams, WriteError, Written, }; mod timer; @@ -1781,13 +1781,20 @@ impl Connection { // Update state for confirmed delivery of frames if let Some(retransmits) = info.retransmits.get() { - for (id, _) in retransmits.reset_stream.iter() { - self.streams.reset_acked(*id); + for &(id, reliable_size) in retransmits.reset_stream.iter() { + self.streams.reset_acked(id, reliable_size); } } for frame in info.stream_frames { - self.streams.received_ack_of(frame); + let id = frame.id; + // A reset held for a peer without RESET_STREAM_AT goes out once it holds the data + if let Some(reliable_size) = self.streams.received_ack_of(frame) { + self.spaces[SpaceId::Data] + .pending + .reset_stream + .push((id, reliable_size)); + } } } @@ -3104,6 +3111,13 @@ impl Connection { self.streams.received_max_streams(dir, count)?; } Frame::ResetStream(frame) => { + if frame.reliable_size.is_some() && !self.config.reset_stream_at { + // We never advertised it, so it is an unknown frame type + let mut err = + TransportError::FRAME_ENCODING_ERROR("unsupported RESET_STREAM_AT"); + err.frame = Some(frame::FrameType::RESET_STREAM_AT); + return Err(err); + } if self.streams.received_reset(frame)?.should_transmit() { self.spaces[SpaceId::Data].pending.max_data = true; } @@ -3147,7 +3161,13 @@ impl Connection { "STOP_SENDING on unopened stream", )); } - self.streams.received_stop_sending(id, error_code); + if let Some(reliable_size) = self.streams.received_stop_sending(id, error_code) + { + self.spaces[SpaceId::Data] + .pending + .reset_stream + .push((id, reliable_size)); + } } Frame::RetireConnectionId { sequence } => { let allow_more_cids = self diff --git a/rs/moq-quic/src/connection/send_buffer.rs b/rs/moq-quic/src/connection/send_buffer.rs index a80cae5ce34..97efcde5c20 100644 --- a/rs/moq-quic/src/connection/send_buffer.rs +++ b/rs/moq-quic/src/connection/send_buffer.rs @@ -42,10 +42,13 @@ impl SendBuffer { /// Discard a range of acknowledged stream data pub(super) fn ack(&mut self, mut range: Range) { - // Clamp the range to data which is still tracked + // Clamp the range to data which is still tracked, which `truncate` may have cut short let base_offset = self.offset - self.unacked_len as u64; range.start = base_offset.max(range.start); - range.end = base_offset.max(range.end); + range.end = base_offset.max(range.end).min(self.offset); + if range.is_empty() { + return; + } self.acks.insert(range); @@ -159,17 +162,48 @@ impl SendBuffer { &[] } - /// Release abandoned data while preserving the final offset for RESET_STREAM - pub(super) fn discard(&mut self) { - *self = Self { - offset: self.offset, - unsent: self.offset, - ..Self::default() - }; + /// Abandon all data at or past `end`, which no longer needs to be sent or acknowledged + /// + /// The buffer then ends at `end`, so the caller tracks the stream's final size. + pub(super) fn truncate(&mut self, end: u64) { + if end >= self.offset { + return; + } + let base_offset = self.offset - self.unacked_len as u64; + let mut keep = end.saturating_sub(base_offset) as usize; + if keep == 0 { + // Every byte before `end` was acknowledged, so nothing is retained + *self = Self { + offset: end, + unsent: end, + ..Self::default() + }; + return; + } + let mut segments = 0; + for segment in self.unacked_segments.iter_mut() { + segments += 1; + if segment.len() >= keep { + segment.truncate(keep); + break; + } + keep -= segment.len(); + } + self.unacked_segments.truncate(segments); + self.unacked_len = (end - base_offset) as usize; + self.offset = end; + self.unsent = self.unsent.min(end); + self.acks.remove(end..u64::MAX); + self.retransmits.remove(end..u64::MAX); } /// Queue a range of sent but unacknowledged data to be retransmitted - pub(super) fn retransmit(&mut self, range: Range) { + pub(super) fn retransmit(&mut self, mut range: Range) { + // Data past a truncation is abandoned rather than lost + range.end = range.end.min(self.offset); + if range.is_empty() { + return; + } debug_assert!(range.end <= self.unsent, "unsent data can't be lost"); self.retransmits.insert(range); } @@ -397,6 +431,44 @@ mod tests { assert!(buf.acks.is_empty()); } + #[test] + fn truncate_keeps_prefix() { + let mut buf = SendBuffer::new(); + buf.write(Bytes::from_static(b"Hello, ")); + buf.write(Bytes::from_static(b"world!")); + assert_eq!(buf.poll_transmit(16), (0..8, true)); + buf.ack(0..2); + buf.retransmit(2..8); + + buf.truncate(9); + assert_eq!(aggregate_unacked(&buf), b"llo, wo"); + assert_eq!(buf.offset(), 9); + // The lost range is retransmitted, then the unsent byte before the truncation + assert_eq!(buf.poll_transmit(16), (2..8, true)); + assert_eq!(buf.poll_transmit(16), (8..9, true)); + assert!(!buf.has_unsent_data()); + + // Late acks and losses past the truncation are ignored + buf.ack(9..13); + buf.retransmit(9..13); + assert!(!buf.has_unsent_data()); + buf.ack(2..9); + assert!(buf.is_fully_acked()); + assert_eq!(buf.buffered(), 0); + } + + #[test] + fn truncate_acked_prefix() { + let mut buf = SendBuffer::new(); + buf.write(Bytes::from_static(b"Hello, world!")); + assert_eq!(buf.poll_transmit(16), (0..8, true)); + buf.ack(0..8); + buf.truncate(4); + assert!(buf.is_fully_acked()); + assert!(!buf.has_unsent_data()); + assert_eq!(buf.buffered(), 0); + } + fn aggregate_unacked(buf: &SendBuffer) -> Vec { let mut result = Vec::new(); for segment in buf.unacked_segments.iter() { diff --git a/rs/moq-quic/src/connection/spaces.rs b/rs/moq-quic/src/connection/spaces.rs index 97fb85de7ba..d9a3e61fda9 100644 --- a/rs/moq-quic/src/connection/spaces.rs +++ b/rs/moq-quic/src/connection/spaces.rs @@ -12,7 +12,7 @@ use tracing::trace; use super::assembler::Assembler; use super::sent_packets::SentPackets; use crate::{ - Dir, Duration, Instant, SocketAddr, StreamId, TransportError, VarInt, cid_queue::CidQueue, + Dir, Duration, Instant, SocketAddr, StreamId, TransportError, cid_queue::CidQueue, connection::StreamsState, crypto::Keys, frame, packet::SpaceId, range_set::ArrayRangeSet, shared::IssuedCid, }; @@ -326,7 +326,8 @@ pub struct Retransmits { pub(super) data_blocked: bool, pub(super) max_stream_id: [bool; 2], pub(super) streams_blocked: [bool; 2], - pub(super) reset_stream: Vec<(StreamId, VarInt)>, + /// Each reset stream with the Reliable Size it delivers when its reset frame was sent + pub(super) reset_stream: Vec<(StreamId, u64)>, pub(super) stop_sending: Vec, pub(super) max_stream_data: FxHashSet, pub(super) stream_data_blocked: FxHashSet, diff --git a/rs/moq-quic/src/connection/streams/mod.rs b/rs/moq-quic/src/connection/streams/mod.rs index b9ef4c3dec0..5148338b7d5 100644 --- a/rs/moq-quic/src/connection/streams/mod.rs +++ b/rs/moq-quic/src/connection/streams/mod.rs @@ -8,7 +8,11 @@ use thiserror::Error; use tracing::trace; use super::spaces::{Retransmits, ThinRetransmits}; -use crate::{Dir, StreamId, VarInt, connection::streams::state::get_or_insert_recv, frame}; +use crate::{ + Dir, StreamId, VarInt, + connection::{ConnectionTag, streams::state::get_or_insert_recv}, + frame, +}; mod recv; use recv::Recv; @@ -324,7 +328,31 @@ impl<'a> SendStream<'a> { /// # Panics /// - when applied to a receive stream pub fn reset(&mut self, error_code: VarInt) -> Result<(), ClosedStream> { + self.reset_to(error_code, 0) + } + + /// Mark the data written so far, so a later [`Checkpoint::reset`] still delivers it + /// + /// # Panics + /// - when applied to a receive stream + pub fn checkpoint(&self) -> Checkpoint { + let offset = match self.state.send.get(&self.id) { + Some(Some(stream)) => stream.offset(), + // Not written yet, or already closed, where the reset fails anyway + _ => 0, + }; + Checkpoint { + id: self.id, + tag: self.state.tag, + generation: self.state.generation, + offset, + } + } + + /// Reset the stream, still delivering its first `reliable_size` bytes + fn reset_to(&mut self, error_code: VarInt, reliable_size: u64) -> Result<(), ClosedStream> { let max_send_data = self.state.max_send_data(self.id); + let at = self.state.peer_reset_stream_at; let stream = self .state .send @@ -332,17 +360,27 @@ impl<'a> SendStream<'a> { .ok_or(ClosedStream { _private: () })? .get_or_insert_with(|| Send::new(max_send_data)); - if matches!(stream.state, SendState::ResetSent) { + if stream.is_reset() { // Redundant reset call return Err(ClosedStream { _private: () }); } + // A checkpoint names its stream's connection and generation, so it never runs past the data + debug_assert!(reliable_size <= stream.offset()); + // The peer that sent STOP_SENDING will not read the prefix + let reliable_size = match stream.stop_reason { + Some(_) => 0, + None => reliable_size, + }; // Restore the portion of the send window consumed by the data that we aren't about to // send. We leave flow control alone because the peer's responsible for issuing additional // credit based on the final offset communicated in the RESET_STREAM frame we send. - self.state.buffered_data -= stream.pending.buffered(); - stream.reset(); - self.pending.reset_stream.push((self.id, error_code)); + let buffered = stream.pending.buffered(); + let send = stream.reset(error_code, reliable_size, at); + self.state.buffered_data -= buffered - stream.pending.buffered(); + if let Some(reliable_size) = send { + self.pending.reset_stream.push((self.id, reliable_size)); + } // Don't reopen an already-closed stream we haven't forgotten yet Ok(()) @@ -380,6 +418,51 @@ impl<'a> SendStream<'a> { } } +/// The data written to a send stream up to some point, which a reset can still deliver +/// +/// Taken with [`SendStream::checkpoint`], and only valid on the connection it came from. +#[derive(Debug)] +pub struct Checkpoint { + id: StreamId, + tag: ConnectionTag, + generation: u64, + offset: u64, +} + +impl Checkpoint { + /// Abandon the stream, but still deliver everything written before the checkpoint + /// + /// Nothing past the checkpoint is sent or retransmitted. A peer that accepts RESET_STREAM_AT + /// gets it at once, and reads the data before the error. Otherwise the data keeps being + /// retransmitted, and a plain RESET_STREAM follows once the peer has acknowledged all of it, a + /// round trip later. An acknowledgment only means the peer's QUIC stack holds the data: + /// RFC 9000 lets it discard data its application has not read yet on RESET_STREAM, so this + /// only reliably delivers data the peer parses on arrival, like a WebTransport stream header. + /// A peer that asked us to stop sending gets the reset at once, without the data. + /// + /// Fails with [`ClosedStream`] if the stream was already reset or is gone, including one + /// rejected 0-RTT discarded, even if a new stream has since taken its id. + /// + /// # Panics + /// If the checkpoint came from another connection. + pub fn reset( + self, + conn: &mut crate::Connection, + error_code: VarInt, + ) -> Result<(), ClosedStream> { + let mut stream = conn.send_stream(self.id); + assert!( + self.tag == stream.state.tag, + "checkpoint used on another connection" + ); + // Rejected 0-RTT discarded the stream, and a new one may have its id + if self.generation != stream.state.generation { + return Err(ClosedStream { _private: () }); + } + stream.reset_to(error_code, self.offset) + } +} + /// A queue of streams with pending outgoing data, sorted by priority struct PendingStreamsQueue { streams: BinaryHeap, diff --git a/rs/moq-quic/src/connection/streams/recv.rs b/rs/moq-quic/src/connection/streams/recv.rs index 526b4343e37..984043dbc9c 100644 --- a/rs/moq-quic/src/connection/streams/recv.rs +++ b/rs/moq-quic/src/connection/streams/recv.rs @@ -46,7 +46,7 @@ impl Recv { /// Return value is `(number_of_new_bytes_ingested, stream_is_closed)` pub(super) fn ingest( &mut self, - frame: frame::Stream, + mut frame: frame::Stream, payload_len: usize, received: u64, max_data: u64, @@ -77,9 +77,16 @@ impl Recv { } self.end = self.end.max(end); + // A reset stream only still delivers the data below its Reliable Size + if let RecvState::ResetRecvd { reliable_size, .. } = self.state { + let len = reliable_size + .saturating_sub(frame.offset) + .min(frame.data.len() as u64); + frame.data.truncate(len as usize); + } // Don't bother storing data or releasing stream-level flow control credit if the stream's // already stopped - if !self.stopped { + if !self.stopped && !frame.data.is_empty() { self.assembler .insert(frame.offset, frame.data, payload_len) .map_err(|_| TransportError::INTERNAL_ERROR("too many gaps in stream buffer"))?; @@ -93,10 +100,16 @@ impl Recv { return Err(ClosedStream { _private: () }); } + // Issue flow control credit for unread data. A reset already credited everything but the + // data still owed below its Reliable Size. + let read_credits = match self.state { + RecvState::Recv { .. } => self.end - self.assembler.bytes_read(), + RecvState::ResetRecvd { reliable_size, .. } => { + self.assembler.unread_before(reliable_size) + } + }; self.stopped = true; self.assembler.clear(); - // Issue flow control credit for unread data - let read_credits = self.end - self.assembler.bytes_read(); // This may send a spurious STOP_SENDING if we've already received all data, but it's a bit // fiddly to distinguish that from the case where we've received a FIN but are missing some // data that the peer might still be trying to retransmit, in which case a STOP_SENDING is @@ -157,7 +170,10 @@ impl Recv { /// Whether data is still being accepted from the peer pub(super) fn is_receiving(&self) -> bool { - matches!(self.state, RecvState::Recv { .. }) + match self.state { + RecvState::Recv { .. } => true, + RecvState::ResetRecvd { reliable_size, .. } => reliable_size > 0, + } } fn final_offset(&self) -> Option { @@ -167,44 +183,72 @@ impl Recv { } } - /// Returns `false` iff the reset was redundant + /// Process a RESET_STREAM, or a RESET_STREAM_AT that still delivers `reliable_size` bytes + /// + /// Returns `None` iff the reset was redundant, otherwise the bytes newly counted against + /// connection flow control and the connection credit the abandoned data frees. pub(super) fn reset( &mut self, error_code: VarInt, final_offset: VarInt, + reliable_size: u64, received: u64, max_data: u64, - ) -> Result { + ) -> Result, TransportError> { + let final_offset = u64::from(final_offset); // Validate final_offset if let Some(offset) = self.final_offset() { - if offset != final_offset.into_inner() { + if offset != final_offset { return Err(TransportError::FINAL_SIZE_ERROR("inconsistent value")); } - } else if self.end > u64::from(final_offset) { + } else if self.end > final_offset { return Err(TransportError::FINAL_SIZE_ERROR( "lower than high water mark", )); } - self.credit_consumed_by(final_offset.into(), received, max_data)?; - - if matches!(self.state, RecvState::ResetRecvd { .. }) { - return Ok(false); - } + let new_bytes = self.credit_consumed_by(final_offset, received, max_data)?; + + // The data the application could still read before this reset + let owed = match self.state { + RecvState::ResetRecvd { + error_code: prev, + reliable_size: owed, + .. + } => { + if prev != error_code { + return Err(TransportError::STREAM_STATE_ERROR( + "reset error code changed", + )); + } + // A reordered, larger Reliable Size is ignored + if reliable_size >= owed { + return Ok(None); + } + owed + } + RecvState::Recv { .. } => final_offset, + }; + self.end = final_offset; self.state = RecvState::ResetRecvd { - size: final_offset.into(), + size: final_offset, error_code, + reliable_size, }; - // Nuke buffers so that future reads fail immediately, which ensures future reads don't - // issue flow control credit redundant to that already issued. We could instead special-case - // reset streams during read, but it's unclear if there's any benefit to retaining data for - // reset streams. - self.assembler.clear(); - Ok(true) + // Credit the abandoned data now, and drop what we buffered of it. Reads credit the rest. + let freed = + self.assembler.unread_before(owed) - self.assembler.unread_before(reliable_size); + self.assembler.truncate(reliable_size); + Ok(Some((new_bytes, freed))) } + /// The reset error code, once the data below the Reliable Size has been read pub(super) fn reset_code(&self) -> Option { match self.state { - RecvState::ResetRecvd { error_code, .. } => Some(error_code), + RecvState::ResetRecvd { + error_code, + reliable_size, + .. + } if self.assembler.unread_before(reliable_size) == 0 => Some(error_code), _ => None, } } @@ -305,8 +349,13 @@ impl<'a> Chunks<'a> { } match rs.state { + RecvState::ResetRecvd { reliable_size, .. } + if rs.assembler.unread_before(reliable_size) > 0 => + { + // The data below the Reliable Size is still in flight + Err(ReadError::Blocked) + } RecvState::ResetRecvd { error_code, .. } => { - debug_assert_eq!(self.read, 0, "reset streams have empty buffers"); let state = mem::replace(&mut self.state, ChunksState::Reset(error_code)); // At this point if we have `rs` self.state must be `ChunksState::Readable` let recv = match state { @@ -512,8 +561,15 @@ impl From for ReadableError { #[derive(Debug, Copy, Clone, Eq, PartialEq)] enum RecvState { - Recv { size: Option }, - ResetRecvd { size: u64, error_code: VarInt }, + Recv { + size: Option, + }, + /// Reset, once the data below `reliable_size` has been read + ResetRecvd { + size: u64, + error_code: VarInt, + reliable_size: u64, + }, } impl Default for RecvState { diff --git a/rs/moq-quic/src/connection/streams/send.rs b/rs/moq-quic/src/connection/streams/send.rs index 2e2c847fa2a..729e39e6811 100644 --- a/rs/moq-quic/src/connection/streams/send.rs +++ b/rs/moq-quic/src/connection/streams/send.rs @@ -1,7 +1,7 @@ use bytes::Bytes; use thiserror::Error; -use crate::{VarInt, connection::send_buffer::SendBuffer, frame}; +use crate::{StreamId, VarInt, connection::send_buffer::SendBuffer, frame}; #[derive(Debug)] pub(super) struct Send { @@ -37,7 +37,7 @@ impl Send { /// Whether the stream has been reset pub(super) fn is_reset(&self) -> bool { - matches!(self.state, SendState::ResetSent) + matches!(self.state, SendState::ResetSent { .. }) } pub(super) fn finish(&mut self) -> Result<(), FinishError> { @@ -89,13 +89,128 @@ impl Send { } /// Update stream state due to a reset sent by the local application - pub(super) fn reset(&mut self) { + /// + /// Data below `reliable_size` is still delivered; everything after it is abandoned. Returns + /// the Reliable Size of the reset to send now, or `None` while a peer without RESET_STREAM_AT + /// (`!at`) still has data below `reliable_size` to acknowledge, after which + /// [`take_held_reset`](Self::take_held_reset) releases it. + pub(super) fn reset( + &mut self, + error_code: VarInt, + reliable_size: u64, + at: bool, + ) -> Option { use SendState::*; - if let DataSent { .. } | Ready = self.state { - self.state = ResetSent; - self.pending.discard(); - self.fin_pending = false; + let (DataSent { .. } | Ready) = self.state else { + return None; + }; + debug_assert!(reliable_size <= self.pending.offset()); + let final_size = self.pending.offset(); + self.pending.truncate(reliable_size); + self.fin_pending = false; + let send = at || self.pending.is_fully_acked(); + self.state = ResetSent { + final_size, + reliable_size, + error_code, + held: !send, + acked: None, + }; + send.then_some(reliable_size) + } + + /// Release a held RESET_STREAM once all the data it holds for has been acknowledged, returning + /// its Reliable Size + pub(super) fn take_held_reset(&mut self) -> Option { + let SendState::ResetSent { + held, + reliable_size, + .. + } = &mut self.state + else { + return None; + }; + if !*held || !self.pending.is_fully_acked() { + return None; + } + *held = false; + Some(*reliable_size) + } + + /// The Reliable Size this stream's reset delivers, if it was reset + pub(super) fn reliable_size(&self) -> Option { + match self.state { + SendState::ResetSent { reliable_size, .. } => Some(reliable_size), + _ => None, + } + } + + /// Abandon the data a reset still delivers, returning the Reliable Size of 0 for the reset to + /// send now + /// + /// For a peer that sent STOP_SENDING, which will not read it. This releases a held + /// RESET_STREAM, and replaces a RESET_STREAM_AT whose data is still unacknowledged. + pub(super) fn abandon_reliable(&mut self) -> Option { + let SendState::ResetSent { + reliable_size, + held, + .. + } = &mut self.state + else { + return None; + }; + if self.pending.is_fully_acked() { + return None; } + *reliable_size = 0; + *held = false; + self.pending.truncate(0); + Some(0) + } + + /// The frame announcing this stream's reset, if it was reset + /// + /// It carries a Reliable Size only when the peer accepts RESET_STREAM_AT (`at`). + pub(super) fn reset_frame(&self, id: StreamId, at: bool) -> Option { + let SendState::ResetSent { + final_size, + reliable_size, + error_code, + .. + } = self.state + else { + return None; + }; + Some(frame::ResetStream { + id, + error_code, + final_offset: VarInt::try_from(final_size).expect("impossibly large offset"), + // A zero Reliable Size is a plain RESET_STREAM, which any peer accepts + reliable_size: (at && reliable_size > 0) + .then(|| VarInt::try_from(reliable_size).expect("impossibly large offset")), + }) + } + + /// Handle acknowledgement of a reset frame sent while the Reliable Size was `reliable_size` + /// + /// Returns whether the current reset and all data below its Reliable Size have been + /// acknowledged + pub(super) fn reset_acked(&mut self, reliable_size: u64) -> bool { + let SendState::ResetSent { acked, .. } = &mut self.state else { + return false; + }; + // Sizes only shrink, so the smallest one acknowledged is the latest + *acked = Some(acked.map_or(reliable_size, |acked| acked.min(reliable_size))); + self.is_reset_acked() && self.pending.is_fully_acked() + } + + /// Whether the peer acknowledged a reset carrying the current Reliable Size, rather than one + /// that STOP_SENDING has since shrunk + fn is_reset_acked(&self) -> bool { + matches!( + self.state, + SendState::ResetSent { reliable_size, acked, .. } if acked == Some(reliable_size) + ) } /// Handle STOP_SENDING @@ -111,7 +226,8 @@ impl Send { } } - /// Returns whether the stream has been finished and all data has been acknowledged by the peer + /// Returns whether the stream has been finished or reset, and all data it still owes the peer + /// has been acknowledged pub(super) fn ack(&mut self, frame: frame::StreamMeta) -> bool { self.pending.ack(frame.offsets); match &mut self.state { @@ -119,7 +235,8 @@ impl Send { *finish_acked |= frame.fin; *finish_acked && self.pending.is_fully_acked() } - _ => false, + SendState::ResetSent { .. } => self.is_reset_acked() && self.pending.is_fully_acked(), + SendState::Ready => false, } } @@ -289,8 +406,18 @@ pub(super) enum SendState { Ready, /// Stream was finished; now sending retransmits only DataSent { finish_acked: bool }, - /// Sent RESET - ResetSent, + /// Reset by the application, while data below `reliable_size` is still delivered + /// + /// The peer gets RESET_STREAM_AT, or, without it, a RESET_STREAM `held` until it has + /// acknowledged that data. + ResetSent { + final_size: u64, + reliable_size: u64, + error_code: VarInt, + held: bool, + /// The smallest Reliable Size an acknowledged reset frame carried + acked: Option, + }, } /// Reasons why attempting to finish a stream might fail diff --git a/rs/moq-quic/src/connection/streams/state.rs b/rs/moq-quic/src/connection/streams/state.rs index 56820451f1f..dfc8b4ce196 100644 --- a/rs/moq-quic/src/connection/streams/state.rs +++ b/rs/moq-quic/src/connection/streams/state.rs @@ -140,6 +140,11 @@ pub struct StreamsState { initial_max_stream_data_uni: VarInt, initial_max_stream_data_bidi_local: VarInt, initial_max_stream_data_bidi_remote: VarInt, + /// Whether the peer accepts RESET_STREAM_AT + pub(super) peer_reset_stream_at: bool, + /// Bumped when rejected 0-RTT discards our streams and their ids are opened again, so a + /// [`Checkpoint`](super::Checkpoint) from before cannot reach the new stream of the same id + pub(super) generation: u64, /// The shrink to be applied to local_max_data when receive_window is shrunk receive_window_shrink_debt: u64, @@ -194,6 +199,8 @@ impl StreamsState { initial_max_stream_data_uni: 0u32.into(), initial_max_stream_data_bidi_local: 0u32.into(), initial_max_stream_data_bidi_remote: 0u32.into(), + peer_reset_stream_at: false, + generation: 0, receive_window_shrink_debt: 0, streams_blocked: [false, false], data_blocked_limit: None, @@ -204,6 +211,7 @@ impl StreamsState { self.initial_max_stream_data_uni = params.initial_max_stream_data_uni; self.initial_max_stream_data_bidi_local = params.initial_max_stream_data_bidi_local; self.initial_max_stream_data_bidi_remote = params.initial_max_stream_data_bidi_remote; + self.peer_reset_stream_at = params.reset_stream_at; self.max[Dir::Bi as usize] = params.initial_max_streams_bidi.into(); self.max[Dir::Uni as usize] = params.initial_max_streams_uni.into(); self.received_max_data(params.initial_max_data); @@ -247,6 +255,7 @@ impl StreamsState { } } + self.generation += 1; self.pending.clear(); self.send_streams = 0; self.data_sent = 0; @@ -317,7 +326,13 @@ impl StreamsState { id, error_code, final_offset, + reliable_size, } = frame; + if reliable_size > Some(final_offset) { + return Err(TransportError::FRAME_ENCODING_ERROR( + "reliable size exceeds final size", + )); + } self.validate_receive_id(id).inspect_err(|_| { debug!("received illegal RESET_STREAM frame"); })?; @@ -334,77 +349,86 @@ impl StreamsState { }; // State transition - if !rs.reset( + let reliable_size = reliable_size.map_or(0, u64::from); + let Some((new_bytes, freed)) = rs.reset( error_code, final_offset, + reliable_size, self.data_recvd, self.local_max_data, - )? { + )? + else { // Redundant reset return Ok(ShouldTransmit(false)); - } - let bytes_read = rs.assembler.bytes_read(); - let stopped = rs.stopped; - let end = rs.end; - // Stopped streams have already returned read credits up to their highest offset. - let credited = if stopped { end } else { bytes_read }; - if stopped { - // Stopped streams should be disposed immediately on reset + }; + self.data_recvd = self.data_recvd.saturating_add(new_bytes); + let credit = if rs.stopped { + // Stopped streams should be disposed immediately on reset, and have already returned + // read credits up to their highest offset. let rs = self.recv.remove(&id).flatten().unwrap(); self.stream_recv_freed(id, rs); + new_bytes } else { self.events.push_back(StreamEvent::Readable { id }); - } + freed + }; // Update connection-level flow control - Ok(if credited != final_offset.into_inner() { - // credited is always <= end, so this won't underflow. - self.data_recvd = self - .data_recvd - .saturating_add(u64::from(final_offset) - end); - self.add_read_credits(u64::from(final_offset) - credited) - } else { - ShouldTransmit(false) + Ok(match credit { + 0 => ShouldTransmit(false), + credit => self.add_read_credits(credit), }) } /// Process incoming `STOP_SENDING` frame + /// + /// Returns the Reliable Size of 0 for a reset to send now, since the peer will not read the + /// data a reset still delivers. #[allow(unreachable_pub)] // fuzzing only - pub fn received_stop_sending(&mut self, id: StreamId, error_code: VarInt) { + pub fn received_stop_sending(&mut self, id: StreamId, error_code: VarInt) -> Option { self.insert_remote(id); let max_send_data = self.max_send_data(id); - let Some(stream_opt) = self.send.get_mut(&id) else { - return; - }; - let stream = stream_opt.get_or_insert_with(|| Send::new(max_send_data)); + let stream = self + .send + .get_mut(&id)? + .get_or_insert_with(|| Send::new(max_send_data)); if stream.try_stop(error_code) { self.events .push_back(StreamEvent::Stopped { id, error_code }); } + let buffered = stream.pending.buffered(); + let reset = stream.abandon_reliable(); + self.buffered_data -= buffered - stream.pending.buffered(); + reset } - pub(crate) fn reset_acked(&mut self, id: StreamId) { - match self.send.entry(id) { - hash_map::Entry::Vacant(_) => {} - hash_map::Entry::Occupied(e) => { - if let Some(SendState::ResetSent) = e.get().as_ref().map(|s| s.state) { - e.remove_entry(); - self.stream_freed(id, StreamHalf::Send); - } - } + /// Handle acknowledgement of a reset frame sent while the Reliable Size was `reliable_size` + pub(crate) fn reset_acked(&mut self, id: StreamId, reliable_size: u64) { + let hash_map::Entry::Occupied(mut e) = self.send.entry(id) else { + return; + }; + // A reliable reset lingers until the data below its Reliable Size is acknowledged too, and + // one since shrunk by STOP_SENDING until its replacement is + if e.get_mut() + .as_mut() + .is_some_and(|s| s.reset_acked(reliable_size)) + { + e.remove_entry(); + self.stream_freed(id, StreamHalf::Send); } } /// Whether any stream data is queued, regardless of control frames pub(crate) fn can_send_stream_data(&self) -> bool { - // Reset streams may linger in the pending stream list, but will never produce stream frames + // Reset streams may linger in the pending stream list, but only produce stream frames + // for data below their Reliable Size self.pending.iter().any(|stream| { self.send .get(&stream.id) .and_then(|s| s.as_ref()) - .is_some_and(|s| !s.is_reset()) + .is_some_and(|s| !s.is_reset() || s.is_pending()) }) } @@ -442,24 +466,25 @@ impl StreamsState { max_size: usize, ) { // RESET_STREAM + let at = self.peer_reset_stream_at; while buf.len() + frame::ResetStream::SIZE_BOUND < max_size { - let Some((id, error_code)) = pending.reset_stream.pop() else { + let Some((id, _)) = pending.reset_stream.pop() else { break; }; - let Some(stream) = self.send.get_mut(&id).and_then(|s| s.as_mut()) else { + let Some(stream) = self.send.get(&id).and_then(|s| s.as_ref()) else { continue; }; - trace!(stream = %id, "RESET_STREAM"); + let (Some(frame), Some(reliable_size)) = + (stream.reset_frame(id, at), stream.reliable_size()) + else { + continue; + }; + trace!(stream = %id, reliable_size = ?frame.reliable_size, "RESET_STREAM"); retransmits .get_or_create() .reset_stream - .push((id, error_code)); - frame::ResetStream { - id, - error_code, - final_offset: VarInt::try_from(stream.offset()).expect("impossibly large offset"), - } - .encode(buf); + .push((id, reliable_size)); + frame.encode(buf); stats.reset_stream += 1; } @@ -644,9 +669,9 @@ impl StreamsState { }; // Reset streams aren't removed from the pending list and still exist while the peer - // hasn't acknowledged the reset, but should not generate STREAM frames, so we need to - // check for them explicitly. - if stream.is_reset() { + // hasn't acknowledged the reset, but only generate STREAM frames for data below their + // Reliable Size, so we need to check for them explicitly. + if stream.is_reset() && !stream.is_pending() { continue; } @@ -691,9 +716,13 @@ impl StreamsState { stream_frames } - pub(crate) fn received_ack_of(&mut self, frame: frame::StreamMeta) { + /// Process the acknowledgement of stream data + /// + /// Returns the Reliable Size of a held reset to send now, once the peer holds all the data it + /// waited on. + pub(crate) fn received_ack_of(&mut self, frame: frame::StreamMeta) -> Option { let mut entry = match self.send.entry(frame.id) { - hash_map::Entry::Vacant(_) => return, + hash_map::Entry::Vacant(_) => return None, hash_map::Entry::Occupied(e) => e, }; @@ -702,25 +731,26 @@ impl StreamsState { // this closure should be unreachable. If we did somehow screw that up, // then we might hit an underflow below with unpredictable effects down // the line. Best to short-circuit. - return; + return None; }; - if stream.is_reset() { - // We account for outstanding data on reset streams at time of reset - return; - } let id = frame.id; let buffered = stream.pending.buffered(); let finished = stream.ack(frame); self.buffered_data -= buffered - stream.pending.buffered(); if !finished { // The stream is unfinished or may still need retransmits - return; + return stream.take_held_reset(); } + // A reset is not reported as finished, like one without a Reliable Size + let reset = stream.is_reset(); entry.remove_entry(); self.stream_freed(id, StreamHalf::Send); - self.events.push_back(StreamEvent::Finished { id }); + if !reset { + self.events.push_back(StreamEvent::Finished { id }); + } + None } pub(crate) fn retransmit(&mut self, frame: frame::StreamMeta) { @@ -728,14 +758,13 @@ impl StreamsState { // Loss of data on a closed stream is a noop return; }; - if stream.is_reset() { - return; - } - if !stream.is_pending() { + let was_pending = stream.is_pending(); + // The Reliable Size of a reset stream supersedes any FIN + stream.fin_pending |= frame.fin && !stream.is_reset(); + stream.pending.retransmit(frame.offsets); + if !was_pending && stream.is_pending() { self.pending.push_pending(frame.id, stream.priority); } - stream.fin_pending |= frame.fin; - stream.pending.retransmit(frame.offsets); } pub(crate) fn retransmit_all_for_0rtt(&mut self) { @@ -1224,8 +1253,8 @@ mod tests { "reset must release the abandoned allocation" ); assert_eq!( - send.offset(), - 24, + send.reset_frame(id, false).unwrap().final_offset, + VarInt(24), "RESET_STREAM must retain its final offset" ); assert_eq!(server.write_limit(), 24); @@ -1331,6 +1360,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: 4096u32.into(), + reliable_size: None, }) .unwrap(), ShouldTransmit(false) @@ -1382,6 +1412,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: 4096u32.into(), + reliable_size: None, }) .unwrap(), ShouldTransmit(false) @@ -1400,6 +1431,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: 4096u32.into(), + reliable_size: None, }) .unwrap(), ShouldTransmit(false) @@ -1411,6 +1443,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: 4096u32.into(), + reliable_size: None, }) .unwrap(), ShouldTransmit(false) @@ -1515,6 +1548,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: final_offset.into(), + reliable_size: None, }) .unwrap(), ShouldTransmit(false) @@ -1583,6 +1617,7 @@ mod tests { id: StreamId::new(Side::Server, Dir::Uni, 0), error_code: 0u32.into(), final_offset: VarInt::MAX, + reliable_size: None, }) .unwrap_err() .code, @@ -1986,7 +2021,7 @@ mod tests { stream.write(b"hello").unwrap(); stream.reset(0u32.into()).unwrap(); - assert_eq!(pending.reset_stream, &[(id, 0u32.into())]); + assert_eq!(pending.reset_stream, &[(id, 0)]); assert!(!server.can_send_stream_data()); } @@ -2150,6 +2185,7 @@ mod tests { id: StreamId::new(Side::Server, Dir::Uni, 126), error_code: 0u32.into(), final_offset: 0u32.into(), + reliable_size: None, }), Ok(ShouldTransmit(false)) ); @@ -2568,6 +2604,475 @@ mod tests { ); } + fn reset_at( + id: StreamId, + error_code: u32, + final_offset: u32, + reliable_size: Option, + ) -> frame::ResetStream { + frame::ResetStream { + id, + error_code: error_code.into(), + final_offset: final_offset.into(), + reliable_size: reliable_size.map(VarInt::from_u32), + } + } + + fn receive(state: &mut StreamsState, id: StreamId, data: std::ops::Range) { + let len = (data.end - data.start) as usize; + let _ = state + .received( + frame::Stream { + id, + offset: data.start, + fin: false, + data: Bytes::from(vec![0; len]), + }, + len, + ) + .unwrap(); + } + + /// Read everything readable, returning the byte count and how the read stopped + fn drain(state: &mut StreamsState, id: StreamId, ordered: bool) -> (u64, crate::ReadError) { + let mut pending = Retransmits::default(); + let mut recv = RecvStream { + id, + state, + pending: &mut pending, + }; + let mut chunks = recv.read(ordered).unwrap(); + let mut read = 0; + let err = loop { + match chunks.next(usize::MAX) { + Ok(Some(chunk)) => read += chunk.bytes.len() as u64, + Ok(None) => panic!("reset stream finished"), + Err(e) => break e, + } + }; + let _ = chunks.finalize(); + (read, err) + } + + #[test] + fn reset_at_credits_abandoned_data() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + receive(&mut client, id, 0..4); + + // Everything past the Reliable Size is credited at once + let _ = client + .received_reset(reset_at(id, 7, 100, Some(10))) + .unwrap(); + assert_eq!(client.data_recvd, 100); + assert_eq!(client.local_max_data - initial_max, 90); + + // Data past the Reliable Size is dropped without counting twice + receive(&mut client, id, 4..20); + assert_eq!(client.data_recvd, 100); + assert_eq!( + drain(&mut client, id, true), + (10, crate::ReadError::Reset(7u32.into())) + ); + assert_eq!(client.local_max_data - initial_max, 100); + } + + #[test] + fn reset_at_withholds_error_until_prefix_arrives() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + receive(&mut client, id, 4..20); + assert_eq!(drain(&mut client, id, true), (0, crate::ReadError::Blocked)); + receive(&mut client, id, 0..4); + assert_eq!( + drain(&mut client, id, true), + (10, crate::ReadError::Reset(7u32.into())) + ); + assert_eq!(client.local_max_data - initial_max, 20); + } + + #[test] + fn reset_at_unordered_reads() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + receive(&mut client, id, 5..10); + receive(&mut client, id, 0..2); + assert_eq!( + drain(&mut client, id, false), + (7, crate::ReadError::Blocked) + ); + + // Only 2..4 of the prefix is still owed, though bytes past it were already read + let _ = client.received_reset(reset_at(id, 7, 20, Some(4))).unwrap(); + assert_eq!(client.local_max_data - initial_max, 18); + assert_eq!( + drain(&mut client, id, false), + (0, crate::ReadError::Blocked) + ); + receive(&mut client, id, 2..4); + assert_eq!( + drain(&mut client, id, false), + (2, crate::ReadError::Reset(7u32.into())) + ); + assert_eq!(client.local_max_data - initial_max, 20); + } + + #[test] + fn reset_at_shrinks_reliable_size() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + let _ = client.received_reset(reset_at(id, 7, 20, Some(4))).unwrap(); + assert_eq!(client.local_max_data - initial_max, 16); + // A reordered, larger Reliable Size is ignored + assert_eq!( + client.received_reset(reset_at(id, 7, 20, Some(8))), + Ok(ShouldTransmit(false)) + ); + assert_eq!(client.local_max_data - initial_max, 16); + receive(&mut client, id, 0..20); + assert_eq!( + drain(&mut client, id, true), + (4, crate::ReadError::Reset(7u32.into())) + ); + assert_eq!(client.local_max_data - initial_max, 20); + } + + /// A RESET_STREAM after a RESET_STREAM_AT abandons the prefix too. + #[test] + fn reset_after_reset_at() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + receive(&mut client, id, 0..2); + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + let _ = client.received_reset(reset_at(id, 7, 20, None)).unwrap(); + assert_eq!( + drain(&mut client, id, true), + (0, crate::ReadError::Reset(7u32.into())) + ); + assert_eq!(client.local_max_data - initial_max, 20); + } + + #[test] + fn reset_at_error_code_change() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + assert_eq!( + client + .received_reset(reset_at(id, 8, 20, Some(4))) + .map_err(|e| e.code), + Err(TransportErrorCode::STREAM_STATE_ERROR) + ); + } + + #[test] + fn reset_at_final_size_change() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + assert_eq!( + client + .received_reset(reset_at(id, 7, 21, Some(4))) + .map_err(|e| e.code), + Err(TransportErrorCode::FINAL_SIZE_ERROR) + ); + let mut client = make(Side::Client); + let _ = client + .received_reset(reset_at(id, 7, 20, Some(10))) + .unwrap(); + assert_eq!( + client + .received( + frame::Stream { + id, + offset: 20, + fin: false, + data: Bytes::from_static(&[0]), + }, + 1, + ) + .map_err(|e| e.code), + Err(TransportErrorCode::FINAL_SIZE_ERROR) + ); + } + + /// Stopping a reset stream only credits what the reset still owed, rather than crediting the + /// unread data a second time. + #[test] + fn stop_after_reset_credits_once() { + for reliable_size in [None, Some(15)] { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let initial_max = client.local_max_data; + receive(&mut client, id, 0..10); + let _ = client + .received_reset(reset_at(id, 7, 20, reliable_size)) + .unwrap(); + let mut pending = Retransmits::default(); + RecvStream { + id, + state: &mut client, + pending: &mut pending, + } + .stop(0u32.into()) + .unwrap(); + assert_eq!(client.local_max_data - initial_max, 20, "{reliable_size:?}"); + } + } + + fn reset_at_server() -> StreamsState { + server_with_reset_stream_at(true) + } + + fn server_with_reset_stream_at(reset_stream_at: bool) -> StreamsState { + let mut server = make(Side::Server); + server.set_params(&TransportParameters { + initial_max_streams_uni: 1u32.into(), + initial_max_data: 42u32.into(), + initial_max_stream_data_uni: 42u32.into(), + reset_stream_at, + ..TransportParameters::default() + }); + server + } + + /// Without RESET_STREAM_AT the reset is held until the prefix is acknowledged, and only the + /// prefix keeps counting against the send window meanwhile. + #[test] + fn held_reset_waits_for_prefix_ack() { + let mut server = server_with_reset_stream_at(false); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + let mut buf = Vec::new(); + let sent = stream.state.write_stream_frames(&mut buf, 100, true); + stream.reset_to(7u32.into(), 4).unwrap(); + assert!(pending.reset_stream.is_empty()); + assert_eq!(server.buffered_data, 4); + + // The prefix is lost and resent, without what followed it + server.retransmit(sent[0].clone()); + buf.clear(); + let resent = server.write_stream_frames(&mut buf, 100, true); + assert_eq!(resent[0].offsets, 0..4); + assert_eq!(server.received_ack_of(resent[0].clone()), Some(4)); + assert_eq!(server.buffered_data, 0); + + // The plain RESET_STREAM still names the full final size + let send = server.send[&id].as_ref().unwrap(); + let frame = send.reset_frame(id, false).unwrap(); + assert_eq!(frame.reliable_size, None); + assert_eq!(frame.final_offset, VarInt(11)); + + // The stream goes once the reset is acknowledged + server.reset_acked(id, 4); + assert_eq!(server.send_streams, 0); + } + + /// A late acknowledgement of a RESET_STREAM_AT that STOP_SENDING has since shrunk leaves the + /// stream for its zero-sized replacement, which must still be retransmitted until acknowledged. + #[test] + fn stale_reset_ack_keeps_shrunk_reset() { + let mut server = reset_at_server(); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + stream.reset_to(7u32.into(), 4).unwrap(); + assert_eq!(pending.reset_stream, &[(id, 4)]); + assert_eq!(server.received_stop_sending(id, 9u32.into()), Some(0)); + + server.reset_acked(id, 4); + assert_eq!(server.send_streams, 1); + server.reset_acked(id, 0); + assert_eq!(server.send_streams, 0); + } + + /// A RESET_STREAM_AT acknowledged before STOP_SENDING shrinks it no longer counts, so a late + /// acknowledgement of its prefix leaves the stream for the zero-sized replacement. + #[test] + fn acked_reset_shrunk_waits_for_replacement() { + let mut server = reset_at_server(); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + let mut buf = Vec::new(); + let sent = stream.state.write_stream_frames(&mut buf, 100, true); + stream.reset_to(7u32.into(), 4).unwrap(); + + server.reset_acked(id, 4); + assert_eq!(server.received_stop_sending(id, 9u32.into()), Some(0)); + assert_eq!(server.received_ack_of(sent[0].clone()), None); + assert_eq!(server.send_streams, 1); + server.reset_acked(id, 0); + assert_eq!(server.send_streams, 0); + } + + /// A Reliable Size past the Final Size is a FRAME_ENCODING_ERROR. + #[test] + fn reset_at_beyond_final_size() { + let mut client = make(Side::Client); + let id = StreamId::new(Side::Server, Dir::Uni, 0); + let err = client + .received_reset(reset_at(id, 7, 9, Some(10))) + .unwrap_err(); + assert_eq!(err.code, TransportErrorCode::FRAME_ENCODING_ERROR); + } + + /// A peer that asks us to stop sending will not read the prefix a reset still delivers, so + /// a held RESET_STREAM goes at once and a RESET_STREAM_AT is replaced by a zero-sized reset. + #[test] + fn stop_sending_abandons_reliable_prefix() { + for reset_stream_at in [false, true] { + let mut server = server_with_reset_stream_at(reset_stream_at); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + stream.reset_to(7u32.into(), 4).unwrap(); + assert_eq!(pending.reset_stream.is_empty(), !reset_stream_at); + + assert_eq!(server.received_stop_sending(id, 9u32.into()), Some(0)); + assert_eq!(server.buffered_data, 0); + assert!(!server.can_send_stream_data()); + let send = server.send[&id].as_ref().unwrap(); + assert!(send.pending.is_fully_acked()); + let frame = send.reset_frame(id, reset_stream_at).unwrap(); + assert_eq!(frame.reliable_size, None); + assert_eq!(frame.final_offset, VarInt(11)); + // Abandoned once, so a repeated STOP_SENDING sends nothing more + assert_eq!(server.received_stop_sending(id, 9u32.into()), None); + } + } + + #[test] + fn reset_at_retains_prefix_until_acked() { + let mut server = reset_at_server(); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + let mut buf = Vec::new(); + let sent = stream.state.write_stream_frames(&mut buf, 100, true); + assert_eq!(sent[0].offsets, 0..11); + stream.reset_to(7u32.into(), 4).unwrap(); + assert_eq!(server.buffered_data, 4); + + // Only the lost prefix is retransmitted, without the FIN of a stream that was never finished + server.retransmit(sent[0].clone()); + buf.clear(); + let resent = server.write_stream_frames(&mut buf, 100, true); + assert_eq!(resent.len(), 1); + assert_eq!(resent[0].offsets, 0..4); + assert!(!resent[0].fin); + assert!(!server.can_send_stream_data()); + + // The stream lingers until both the reset and the prefix are acknowledged + server.reset_acked(id, 4); + assert_eq!(server.send_streams, 1); + server.received_ack_of(resent[0].clone()); + assert_eq!(server.send_streams, 0); + assert_eq!(server.buffered_data, 0); + assert_eq!(server.poll(), None); + } + + #[test] + fn reset_at_after_stop_sending_drops_prefix() { + let mut server = reset_at_server(); + let (mut pending, state) = (Retransmits::default(), ConnState::Established); + let id = Streams { + state: &mut server, + conn_state: &state, + } + .open(Dir::Uni) + .unwrap(); + let mut stream = SendStream { + id, + state: &mut server, + pending: &mut pending, + conn_state: &state, + }; + stream.write(b"hello world").unwrap(); + stream.state.received_stop_sending(id, 9u32.into()); + stream.reset_to(7u32.into(), 4).unwrap(); + + let send = server.send[&id].as_ref().unwrap(); + let frame = send.reset_frame(id, true).unwrap(); + assert_eq!(frame.reliable_size, None); + assert_eq!(frame.final_offset, VarInt(11)); + assert!(send.pending.is_fully_acked()); + assert_eq!(server.buffered_data, 0); + } + /// How a held stream ends in [`held_credit_returns_once`]. #[derive(Debug, Clone, Copy)] enum End { @@ -2597,6 +3102,7 @@ mod tests { id, error_code: 0u32.into(), final_offset: final_offset.into(), + reliable_size: None, }) .unwrap(); } diff --git a/rs/moq-quic/src/frame.rs b/rs/moq-quic/src/frame.rs index 8d14d7ae3f8..7e164ee2729 100644 --- a/rs/moq-quic/src/frame.rs +++ b/rs/moq-quic/src/frame.rs @@ -130,6 +130,8 @@ frame_types! { CONNECTION_CLOSE = 0x1c, APPLICATION_CLOSE = 0x1d, HANDSHAKE_DONE = 0x1e, + // https://datatracker.ietf.org/doc/html/draft-ietf-quic-reliable-stream-reset#section-4 + RESET_STREAM_AT = 0x24, // ACK Frequency ACK_FREQUENCY = 0xaf, IMMEDIATE_ACK = 0x1f, @@ -171,7 +173,7 @@ impl Frame { use Frame::*; match self { Padding => FrameType::PADDING, - ResetStream(_) => FrameType::RESET_STREAM, + ResetStream(x) => x.ty(), Close(self::Close::Connection(_)) => FrameType::CONNECTION_CLOSE, Close(self::Close::Application(_)) => FrameType::APPLICATION_CLOSE, MaxData(_) => FrameType::MAX_DATA, @@ -581,6 +583,13 @@ impl Iter { id: self.bytes.get()?, error_code: self.bytes.get()?, final_offset: self.bytes.get()?, + reliable_size: None, + }), + FrameType::RESET_STREAM_AT => Frame::ResetStream(ResetStream { + id: self.bytes.get()?, + error_code: self.bytes.get()?, + final_offset: self.bytes.get()?, + reliable_size: Some(self.bytes.get()?), }), FrameType::CONNECTION_CLOSE => Frame::Close(Close::Connection(ConnectionClose { error_code: self.bytes.get()?, @@ -832,18 +841,30 @@ pub struct ResetStream { pub(crate) id: StreamId, pub(crate) error_code: VarInt, pub(crate) final_offset: VarInt, + /// The prefix the sender still delivers, set for RESET_STREAM_AT and absent for RESET_STREAM + pub(crate) reliable_size: Option, } impl FrameStruct for ResetStream { - const SIZE_BOUND: usize = 1 + 8 + 8 + 8; + const SIZE_BOUND: usize = 1 + 8 + 8 + 8 + 8; } impl ResetStream { + fn ty(&self) -> FrameType { + match self.reliable_size { + Some(_) => FrameType::RESET_STREAM_AT, + None => FrameType::RESET_STREAM, + } + } + pub(crate) fn encode(&self, out: &mut W) { - out.write(FrameType::RESET_STREAM); // 1 byte + out.write(self.ty()); // 1 byte out.write(self.id); // <= 8 bytes out.write(self.error_code); // <= 8 bytes out.write(self.final_offset); // <= 8 bytes + if let Some(reliable_size) = self.reliable_size { + out.write(reliable_size); // <= 8 bytes + } } } @@ -997,6 +1018,28 @@ mod test { } } + #[test] + fn reset_stream_at_coding() { + for reliable_size in [None, Some(VarInt(0)), Some(VarInt(3))] { + let mut buf = Vec::new(); + ResetStream { + id: StreamId(2), + error_code: VarInt(7), + final_offset: VarInt(9), + reliable_size, + } + .encode(&mut buf); + assert!(buf.len() <= ResetStream::SIZE_BOUND); + let frames = frames(buf); + assert_eq!(frames.len(), 1); + assert_matches!( + &frames[0], + Frame::ResetStream(ResetStream { id: StreamId(2), error_code: VarInt(7), final_offset: VarInt(9), reliable_size: r }) + if *r == reliable_size + ); + } + } + #[test] fn immediate_ack_coding() { let mut buf = Vec::new(); diff --git a/rs/moq-quic/src/lib.rs b/rs/moq-quic/src/lib.rs index 78a1d34c52e..7ceb2ad916b 100644 --- a/rs/moq-quic/src/lib.rs +++ b/rs/moq-quic/src/lib.rs @@ -44,10 +44,10 @@ pub use bloom_token_log::BloomTokenLog; mod connection; pub use crate::connection::{ - Chunk, Chunks, ClosedStream, Connection, ConnectionError, ConnectionStats, Credit, CreditStats, - Datagrams, Event, FinishError, FrameStats, PathStats, ReadError, ReadableError, RecvStream, - RttEstimator, SendDatagramError, SendStream, ShouldTransmit, StreamEvent, Streams, UdpStats, - WriteError, Written, + Checkpoint, Chunk, Chunks, ClosedStream, Connection, ConnectionError, ConnectionStats, Credit, + CreditStats, Datagrams, Event, FinishError, FrameStats, PathStats, ReadError, ReadableError, + RecvStream, RttEstimator, SendDatagramError, SendStream, ShouldTransmit, StreamEvent, Streams, + UdpStats, WriteError, Written, }; #[cfg(feature = "qlog")] pub use connection::qlog::QlogStream; diff --git a/rs/moq-quic/src/range_set/btree_range_set.rs b/rs/moq-quic/src/range_set/btree_range_set.rs index d8a853fa5f6..5beb4d34772 100644 --- a/rs/moq-quic/src/range_set/btree_range_set.rs +++ b/rs/moq-quic/src/range_set/btree_range_set.rs @@ -100,8 +100,7 @@ impl RangeSet { .map(|(&x, &y)| (x, y)) } - #[cfg(test)] - pub(super) fn remove(&mut self, x: Range) -> bool { + pub(crate) fn remove(&mut self, x: Range) -> bool { if x.is_empty() { return false; } diff --git a/rs/moq-quic/src/tests/mod.rs b/rs/moq-quic/src/tests/mod.rs index 60ff3f285ee..6cc4f307f4d 100644 --- a/rs/moq-quic/src/tests/mod.rs +++ b/rs/moq-quic/src/tests/mod.rs @@ -42,6 +42,7 @@ use crate::{ mod util; use util::*; +mod reset_stream_at; mod token; #[cfg(all(target_family = "wasm", target_os = "unknown"))] diff --git a/rs/moq-quic/src/tests/reset_stream_at.rs b/rs/moq-quic/src/tests/reset_stream_at.rs new file mode 100644 index 00000000000..8e1ef9a27bb --- /dev/null +++ b/rs/moq-quic/src/tests/reset_stream_at.rs @@ -0,0 +1,651 @@ +//! Tests for RESET_STREAM_AT, which resets a stream but still delivers its prefix + +use super::*; + +const ERROR: VarInt = VarInt(42); +const MSG: &[u8] = b"header and payload"; +const RELIABLE: usize = 6; + +/// A pair whose server does or does not advertise `reset_stream_at` +fn pair(server_reset_stream_at: bool) -> Pair { + let mut config = server_config(); + let mut transport = cubic_transport(); + transport.reset_stream_at(server_reset_stream_at); + config.transport = Arc::new(transport); + Pair::new(Default::default(), config) +} + +/// Read a server stream until it ends, returning the bytes and how it ended +fn read(pair: &mut Pair, ch: ConnectionHandle, s: StreamId) -> (Vec, Result<(), ReadError>) { + let mut recv = pair.server_recv(ch, s); + let mut chunks = recv.read(true).unwrap(); + let mut data = Vec::new(); + let end = loop { + match chunks.next(usize::MAX) { + Ok(Some(chunk)) => data.extend_from_slice(&chunk.bytes), + Ok(None) => break Ok(()), + Err(e) => break Err(e), + } + }; + let _ = chunks.finalize(); + (data, end) +} + +/// Accept the client's next unidirectional stream on the server +fn accept(pair: &mut Pair, ch: ConnectionHandle) -> StreamId { + pair.server_streams(ch).accept(Dir::Uni).unwrap() +} + +/// Write `MSG` to a client stream, with a checkpoint after its first `RELIABLE` bytes +fn write(pair: &mut Pair, ch: ConnectionHandle, s: StreamId) -> Checkpoint { + pair.client_send(ch, s).write(&MSG[..RELIABLE]).unwrap(); + let checkpoint = pair.client_send(ch, s).checkpoint(); + pair.client_send(ch, s).write(&MSG[RELIABLE..]).unwrap(); + checkpoint +} + +/// Reset a client stream, still delivering what was written before `checkpoint` +fn reset( + pair: &mut Pair, + ch: ConnectionHandle, + checkpoint: Checkpoint, +) -> Result<(), ClosedStream> { + checkpoint.reset(pair.client_conn_mut(ch), ERROR) +} + +/// Drive the pair to idle while the server reads stream `s` as its data arrives, returning the +/// bytes read and how the stream ended +/// +/// A plain RESET_STREAM lets the receiver discard data it has not read yet, so only an +/// application that keeps reading sees the prefix a peer without RESET_STREAM_AT is sent. +fn drive_reading( + pair: &mut Pair, + ch: ConnectionHandle, + s: StreamId, +) -> (Vec, Result<(), ReadError>) { + let mut accepted = false; + let mut data = Vec::new(); + loop { + let busy = pair.step(); + accepted = accepted || pair.server_streams(ch).accept(Dir::Uni) == Some(s); + if accepted { + let (read, end) = read(pair, ch, s); + data.extend(read); + if end != Err(ReadError::Blocked) { + return (data, end); + } + } + if !busy { + return (data, Err(ReadError::Blocked)); + } + } +} + +/// How many RESET_STREAM or RESET_STREAM_AT frames the client has sent +fn resets_sent(pair: &mut Pair, ch: ConnectionHandle) -> u64 { + pair.client_conn_mut(ch).stats().frame_tx.reset_stream +} + +/// Transmit the client's pending packets and drop them +fn lose_client_packets(pair: &mut Pair) { + pair.client.drive(pair.time, pair.server.addr); + assert!(!pair.client.outbound.is_empty()); + pair.client.outbound.clear(); +} + +/// A peer that stops reading gets a zero-sized reset, and the prefix it will not read is never +/// retransmitted. +fn stop_sending_abandons_prefix(reset_stream_at: bool) { + let _guard = subscribe(); + let mut pair = pair(reset_stream_at); + let (client_ch, server_ch) = pair.connect(); + + // The server learns of the stream from its first byte + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + pair.client_send(client_ch, s).write(&MSG[..1]).unwrap(); + pair.drive(); + assert_eq!(accept(&mut pair, server_ch), s); + + // The rest of the prefix is lost, and so is any reset sent for it + pair.client_send(client_ch, s) + .write(&MSG[1..RELIABLE]) + .unwrap(); + let checkpoint = pair.client_send(client_ch, s).checkpoint(); + pair.client_send(client_ch, s) + .write(&MSG[RELIABLE..]) + .unwrap(); + lose_client_packets(&mut pair); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.client.drive(pair.time, pair.server.addr); + pair.client.outbound.clear(); + let resets = resets_sent(&mut pair, client_ch); + + pair.server_recv(server_ch, s).stop(VarInt(7)).unwrap(); + let streams = pair.client_conn_mut(client_ch).stats().frame_tx.stream; + pair.drive(); + + assert_eq!( + pair.client_conn_mut(client_ch).stats().frame_tx.stream, + streams + ); + assert!(resets_sent(&mut pair, client_ch) > resets); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +#[test] +fn stop_sending_abandons_prefix_supported() { + stop_sending_abandons_prefix(true); +} + +#[test] +fn stop_sending_abandons_prefix_unsupported() { + stop_sending_abandons_prefix(false); +} + +#[test] +fn delivers_prefix_before_error() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + // Both halves let go of the stream once the prefix and the reset are through + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); + assert!(matches!( + pair.server_recv(server_ch, s).read(true), + Err(ReadableError::ClosedStream) + )); +} + +/// A stream reset before any of its prefix was sent, as a WebTransport stream that only wrote its +/// header, still reaches the peer. +#[test] +fn delivers_unsent_prefix() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + pair.client_send(client_ch, s) + .write(&MSG[..RELIABLE]) + .unwrap(); + let checkpoint = pair.client_send(client_ch, s).checkpoint(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); +} + +#[test] +fn retransmits_lost_prefix() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + lose_client_packets(&mut pair); + reset(&mut pair, client_ch, checkpoint).unwrap(); + + // The reset arrives first, and withholds the error until the prefix is retransmitted + pair.drive_client(); + pair.drive_server(); + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (Vec::new(), Err(ReadError::Blocked)) + ); + assert_matches!( + pair.server_conn_mut(server_ch) + .recv_stream(s) + .received_reset(), + Ok(None) + ); + + pair.drive(); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +#[test] +fn retransmits_lost_reset() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + pair.drive(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + lose_client_packets(&mut pair); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +/// Once the prefix has been read, the reset is observable without another read. +#[test] +fn received_reset_after_prefix() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_matches!( + pair.server_conn_mut(server_ch) + .recv_stream(s) + .received_reset(), + Ok(None) + ); + let mut recv = pair.server_recv(server_ch, s); + let mut chunks = recv.read(true).unwrap(); + assert_matches!(chunks.next(RELIABLE), Ok(Some(chunk)) if chunk.bytes == MSG[..RELIABLE]); + let _ = chunks.finalize(); + assert_matches!( + pair.server_conn_mut(server_ch) + .recv_stream(s) + .received_reset(), + Ok(Some(ERROR)) + ); +} + +#[test] +fn after_finish() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, server_ch) = pair.connect(); + + for reliable in [RELIABLE, MSG.len()] { + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let mut checkpoint = write(&mut pair, client_ch, s); + if reliable == MSG.len() { + checkpoint = pair.client_send(client_ch, s).checkpoint(); + } + pair.client_send(client_ch, s).finish().unwrap(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..reliable].to_vec(), Err(ReadError::Reset(ERROR))) + ); + } + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +/// The Final Size never exceeds the flow control the writes were held to. +#[test] +fn flow_control_blocked() { + let _guard = subscribe(); + let mut config = server_config(); + let mut transport = cubic_transport(); + transport.stream_receive_window(10u32.into()); + config.transport = Arc::new(transport); + let mut pair = Pair::new(Default::default(), config); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + pair.client_send(client_ch, s) + .write(&MSG[..RELIABLE]) + .unwrap(); + let checkpoint = pair.client_send(client_ch, s).checkpoint(); + assert_eq!( + pair.client_send(client_ch, s).write(&MSG[RELIABLE..]), + Ok(10 - RELIABLE) + ); + assert_eq!( + pair.client_send(client_ch, s).write(MSG), + Err(WriteError::Blocked) + ); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + assert!(!pair.server_conn_mut(server_ch).is_closed()); +} + +/// Without RESET_STREAM_AT, the plain RESET_STREAM waits until the peer has acknowledged the data +/// before the checkpoint, so the peer reads that data before the error. +#[test] +fn unsupported_holds_reset_until_acked() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + reset(&mut pair, client_ch, checkpoint).unwrap(); + + // The first flight carries only the data before the checkpoint + pair.drive_client(); + assert_eq!(resets_sent(&mut pair, client_ch), 0); + assert_eq!( + drive_reading(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + assert_eq!(resets_sent(&mut pair, client_ch), 1); + pair.drive(); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +#[test] +fn unsupported_retransmits_lost_prefix() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + lose_client_packets(&mut pair); + reset(&mut pair, client_ch, checkpoint).unwrap(); + + assert_eq!( + drive_reading(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + assert_eq!(resets_sent(&mut pair, client_ch), 1); + pair.drive(); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); +} + +/// Data the peer already acknowledged needs no wait. +#[test] +fn unsupported_resets_at_once_when_acked() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + pair.drive(); + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG.to_vec(), Err(ReadError::Blocked)) + ); + + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive_client(); + assert_eq!(resets_sent(&mut pair, client_ch), 1); + pair.drive(); + assert_eq!( + read(&mut pair, server_ch, s), + (Vec::new(), Err(ReadError::Reset(ERROR))) + ); +} + +/// A finished stream reset while its reset is held ends in the reset, never as finished. +#[test] +fn unsupported_after_finish() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + pair.client_send(client_ch, s).finish().unwrap(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + assert_eq!( + pair.client_send(client_ch, s).finish(), + Err(FinishError::ClosedStream) + ); + assert_eq!( + pair.client_send(client_ch, s).write(MSG), + Err(WriteError::ClosedStream) + ); + + assert_eq!( + drive_reading(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + pair.drive(); + assert_eq!(pair.client_streams(client_ch).send_streams(), 0); + while let Some(event) = pair.client_conn_mut(client_ch).poll() { + assert!(!matches!( + event, + Event::Stream(StreamEvent::Finished { .. }) + )); + } +} + +#[test] +fn unsupported_repeated_reset_is_closed() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, _) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + let again = pair.client_send(client_ch, s).checkpoint(); + lose_client_packets(&mut pair); + reset(&mut pair, client_ch, checkpoint).unwrap(); + assert_eq!( + reset(&mut pair, client_ch, again), + Err(ClosedStream::default()) + ); + assert!(pair.client_send(client_ch, s).reset(ERROR).is_err()); +} + +/// A connection closed while a reset is held closes cleanly, without sending it. +#[test] +fn unsupported_close_while_held() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + lose_client_packets(&mut pair); + reset(&mut pair, client_ch, checkpoint).unwrap(); + let now = pair.time; + pair.client_conn_mut(client_ch) + .close(now, VarInt(0), Bytes::new()); + pair.drive(); + + assert_eq!(resets_sent(&mut pair, client_ch), 0); + assert!(pair.client_conn_mut(client_ch).is_closed()); + assert!(pair.server_conn_mut(server_ch).is_closed()); +} + +/// The data abandoned past the checkpoint still counts against connection flow control until +/// the peer learns the final size, and then returns. +#[test] +fn unsupported_returns_flow_control() { + let _guard = subscribe(); + let mut config = server_config(); + let mut transport = cubic_transport(); + transport.reset_stream_at(false); + transport.receive_window((MSG.len() as u32).into()); + config.transport = Arc::new(transport); + let mut pair = Pair::new(Default::default(), config); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + reset(&mut pair, client_ch, checkpoint).unwrap(); + let next = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + assert_eq!( + pair.client_send(client_ch, next).write(MSG), + Err(WriteError::Blocked) + ); + + assert_eq!( + drive_reading(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); + pair.drive(); + assert_eq!(pair.client_send(client_ch, next).write(MSG), Ok(MSG.len())); +} + +/// A zero Reliable Size is a plain RESET_STREAM, which needs no negotiation. +#[test] +fn unsupported_allows_zero() { + let _guard = subscribe(); + let mut pair = pair(false); + let (client_ch, server_ch) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = pair.client_send(client_ch, s).checkpoint(); + pair.client_send(client_ch, s).write(MSG).unwrap(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (Vec::new(), Err(ReadError::Reset(ERROR))) + ); +} + +#[test] +fn repeated_reset_is_closed() { + let _guard = subscribe(); + let mut pair = pair(true); + let (client_ch, _) = pair.connect(); + + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + let again = pair.client_send(client_ch, s).checkpoint(); + reset(&mut pair, client_ch, checkpoint).unwrap(); + assert_eq!( + reset(&mut pair, client_ch, again), + Err(ClosedStream::default()) + ); + assert!(pair.client_send(client_ch, s).reset(ERROR).is_err()); +} + +/// A checkpoint taken in 0-RTT that the server rejects names a discarded stream, so it stays +/// closed even once the same stream id is opened again. +#[test] +fn zero_rtt_rejected_checkpoint_is_closed() { + let _guard = subscribe(); + let server_config = ServerConfig::with_crypto(Arc::new(server_crypto_with_alpn(vec![ + "foo".into(), + "bar".into(), + ]))); + let mut pair = Pair::new(Arc::new(EndpointConfig::default()), server_config); + let mut client_crypto = Arc::new(client_crypto_with_alpn(vec!["foo".into()])); + + let client_ch = pair.begin_connect(ClientConfig::new(client_crypto.clone())); + pair.drive(); + pair.server.assert_accept(); + let now = pair.time; + pair.client_conn_mut(client_ch) + .close(now, VarInt(0), Bytes::new()); + pair.drive(); + pair.client.connections.clear(); + pair.server.connections.clear(); + + // A changed ALPN makes the server reject the resumed session's 0-RTT + let this = Arc::get_mut(&mut client_crypto).expect("QuicClientConfig is shared"); + let inner = Arc::get_mut(&mut this.inner).expect("QuicClientConfig.inner is shared"); + inner.alpn_protocols = vec!["bar".into()]; + let client_ch = pair.begin_connect(ClientConfig::new(client_crypto)); + assert!(pair.client_conn_mut(client_ch).has_0rtt()); + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + pair.drive(); + assert!(!pair.client_conn_mut(client_ch).accepted_0rtt()); + + let reopened = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + assert_eq!(reopened, s); + pair.client_send(client_ch, reopened).write(MSG).unwrap(); + assert_eq!( + reset(&mut pair, client_ch, checkpoint), + Err(ClosedStream::default()) + ); + pair.client_send(client_ch, reopened).finish().unwrap(); + pair.drive(); + + let server_ch = pair.server.assert_accept(); + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!(read(&mut pair, server_ch, s), (MSG.to_vec(), Ok(()))); +} + +/// A checkpoint from another connection panics, even where that connection has a stream of the +/// same id holding at least as much data. +#[test] +#[should_panic(expected = "checkpoint used on another connection")] +fn checkpoint_from_another_connection() { + let _guard = subscribe(); + let mut first = pair(true); + let (first_ch, _) = first.connect(); + let mut second = pair(true); + let (second_ch, _) = second.connect(); + + let s = first.client_streams(first_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut first, first_ch, s); + let other = second.client_streams(second_ch).open(Dir::Uni).unwrap(); + assert_eq!(other, s); + second.client_send(second_ch, other).write(MSG).unwrap(); + let _ = reset(&mut second, second_ch, checkpoint); +} + +/// A client remembers the server's support for 0-RTT, and may use it there. +#[test] +fn zero_rtt() { + let _guard = subscribe(); + let mut pair = pair(true); + pair.server.handle_incoming = Box::new(validate_incoming); + let config = client_config(); + + let client_ch = pair.begin_connect(config.clone()); + pair.drive(); + pair.server.assert_accept(); + pair.client + .connections + .get_mut(&client_ch) + .unwrap() + .close(pair.time, VarInt(0), [][..].into()); + pair.drive(); + + pair.client.addr = SocketAddr::new( + Ipv6Addr::LOCALHOST.into(), + CLIENT_PORTS.lock().unwrap().next().unwrap(), + ); + let client_ch = pair.begin_connect(config); + assert!(pair.client_conn_mut(client_ch).has_0rtt()); + let s = pair.client_streams(client_ch).open(Dir::Uni).unwrap(); + let checkpoint = write(&mut pair, client_ch, s); + reset(&mut pair, client_ch, checkpoint).unwrap(); + pair.drive(); + + assert!(pair.client_conn_mut(client_ch).accepted_0rtt()); + let server_ch = pair.server.assert_accept(); + assert_eq!(accept(&mut pair, server_ch), s); + assert_eq!( + read(&mut pair, server_ch, s), + (MSG[..RELIABLE].to_vec(), Err(ReadError::Reset(ERROR))) + ); +} diff --git a/rs/moq-quic/src/transport_parameters.rs b/rs/moq-quic/src/transport_parameters.rs index f0ef37cdbdc..e5cc67b0006 100644 --- a/rs/moq-quic/src/transport_parameters.rs +++ b/rs/moq-quic/src/transport_parameters.rs @@ -89,6 +89,9 @@ macro_rules! make_struct { /// Frequency pub(crate) min_ack_delay: Option, + /// The endpoint accepts RESET_STREAM_AT frames + pub(crate) reset_stream_at: bool, + // Server-only /// The value of the Destination Connection ID field from the first Initial packet sent /// by the client @@ -126,6 +129,7 @@ macro_rules! make_struct { initial_src_cid: None, grease_quic_bit: false, min_ack_delay: None, + reset_stream_at: false, original_dst_cid: None, retry_src_cid: None, @@ -174,6 +178,7 @@ impl TransportParameters { min_ack_delay: Some( VarInt::from_u64(u64::try_from(TIMER_GRANULARITY.as_micros()).unwrap()).unwrap(), ), + reset_stream_at: config.reset_stream_at, grease_transport_parameter: Some(ReservedTransportParameter::random(rng)), write_order: Some({ let mut order = std::array::from_fn(|i| i as u8); @@ -196,6 +201,7 @@ impl TransportParameters { || cached.initial_max_streams_uni > self.initial_max_streams_uni || cached.max_datagram_frame_size > self.max_datagram_frame_size || cached.grease_quic_bit && !self.grease_quic_bit + || cached.reset_stream_at && !self.reset_stream_at { return Err(TransportError::PROTOCOL_VIOLATION( "0-RTT accepted with incompatible transport parameters", @@ -381,6 +387,12 @@ impl TransportParameters { w.write(x); } } + TransportParameterId::ResetStreamAt => { + if self.reset_stream_at { + w.write_var(id as u64); + w.write_var(0); + } + } id => { macro_rules! write_params { {$($(#[$doc:meta])* $name:ident ($id:ident) = $default:expr,)*} => { @@ -486,6 +498,12 @@ impl TransportParameters { } params.min_ack_delay = Some(r.get()?); } + TransportParameterId::ResetStreamAt => { + if len != 0 || params.reset_stream_at { + return Err(Error::Malformed); + } + params.reset_stream_at = true; + } _ => { macro_rules! parse { {$($(#[$doc:meta])* $name:ident ($id:ident) = $default:expr,)*} => { @@ -641,6 +659,9 @@ pub(crate) enum TransportParameterId { InitialSourceConnectionId = 0x0F, RetrySourceConnectionId = 0x10, + // https://datatracker.ietf.org/doc/html/draft-ietf-quic-reliable-stream-reset#section-3 + ResetStreamAt = 0x1D, + // Smallest possible ID of reserved transport parameter https://datatracker.ietf.org/doc/html/rfc9000#section-22.3 ReservedTransportParameter = 0x1B, @@ -656,7 +677,7 @@ pub(crate) enum TransportParameterId { impl TransportParameterId { /// Array with all supported transport parameter IDs - const SUPPORTED: [Self; 21] = [ + const SUPPORTED: [Self; 22] = [ Self::MaxIdleTimeout, Self::MaxUdpPayloadSize, Self::InitialMaxData, @@ -678,6 +699,7 @@ impl TransportParameterId { Self::RetrySourceConnectionId, Self::GreaseQuicBit, Self::MinAckDelayDraft07, + Self::ResetStreamAt, ]; } @@ -717,6 +739,7 @@ impl TryFrom for TransportParameterId { id if Self::RetrySourceConnectionId == id => Self::RetrySourceConnectionId, id if Self::GreaseQuicBit == id => Self::GreaseQuicBit, id if Self::MinAckDelayDraft07 == id => Self::MinAckDelayDraft07, + id if Self::ResetStreamAt == id => Self::ResetStreamAt, _ => return Err(()), }; Ok(param) @@ -758,6 +781,7 @@ mod test { }), grease_quic_bit: true, min_ack_delay: Some(2_000u32.into()), + reset_stream_at: true, ..TransportParameters::default() }; params.write(&mut buf); @@ -946,6 +970,10 @@ mod test { min_ack_delay: Some(2_000u32.into()), ..TransportParameters::default() }, + TransportParameters { + reset_stream_at: true, + ..TransportParameters::default() + }, ]; for params in cases { let mut once = Vec::new(); @@ -978,4 +1006,29 @@ mod test { high_limit.validate_resumption_from(&low_limit).unwrap(); low_limit.validate_resumption_from(&high_limit).unwrap_err(); } + + /// A non-empty `reset_stream_at` is a TRANSPORT_PARAMETER_ERROR. + #[test] + fn read_reset_stream_at_with_value() { + let mut buf = Vec::new(); + buf.write_var(TransportParameterId::ResetStreamAt as u64); + buf.write_var(1); + buf.write_var(0); + assert_eq!( + TransportParameters::read(Side::Client, &mut buf.as_slice()), + Err(Error::Malformed) + ); + } + + /// A server that accepts 0-RTT must keep RESET_STREAM_AT enabled. + #[test] + fn resumption_keeps_reset_stream_at() { + let enabled = TransportParameters { + reset_stream_at: true, + ..TransportParameters::default() + }; + let disabled = TransportParameters::default(); + enabled.validate_resumption_from(&disabled).unwrap(); + disabled.validate_resumption_from(&enabled).unwrap_err(); + } } diff --git a/rs/moq-tokio/src/quic/driver/mod.rs b/rs/moq-tokio/src/quic/driver/mod.rs index 2a927ce4c8e..7a8b6a68cf1 100644 --- a/rs/moq-tokio/src/quic/driver/mod.rs +++ b/rs/moq-tokio/src/quic/driver/mod.rs @@ -78,7 +78,7 @@ pub use crate::quic::driver::recv_stream::{ #[cfg(test)] pub(crate) use crate::quic::driver::runtime::wrap_udp_socket; pub use crate::quic::driver::runtime::{AsyncUdpSocket, UdpSender}; -pub use crate::quic::driver::send_stream::{SendStream, StoppedError, WriteError}; +pub use crate::quic::driver::send_stream::{Checkpoint, SendStream, StoppedError, WriteError}; #[cfg(test)] mod tests; diff --git a/rs/moq-tokio/src/quic/driver/send_stream.rs b/rs/moq-tokio/src/quic/driver/send_stream.rs index 812f2d4c12c..7701d6817d2 100644 --- a/rs/moq-tokio/src/quic/driver/send_stream.rs +++ b/rs/moq-tokio/src/quic/driver/send_stream.rs @@ -214,6 +214,17 @@ impl SendStream { Ok(()) } + /// Mark the data written so far, so a later [`Checkpoint::reset()`] still delivers it. + pub fn checkpoint(&self) -> Checkpoint { + let mut conn = self.conn.state.lock("SendStream::checkpoint"); + let inner = conn.inner.send_stream(self.stream).checkpoint(); + Checkpoint { + conn: self.conn.clone(), + inner, + is_0rtt: self.is_0rtt, + } + } + /// Set the priority of the send stream /// /// Every send stream has an initial priority of 0. Locally buffered data from streams with @@ -333,6 +344,34 @@ impl tokio::io::AsyncWrite for SendStream { } } +/// The data written to a [`SendStream`] up to some point, which a reset can still deliver +/// +/// Taken with [`SendStream::checkpoint()`]. It keeps the connection open, like the stream does. +#[derive(Debug)] +pub struct Checkpoint { + conn: ConnectionRef, + inner: moq_quic::Checkpoint, + is_0rtt: bool, +} + +impl Checkpoint { + /// Close the send stream immediately, but still deliver everything written before the checkpoint. + /// + /// Like [`SendStream::reset()`], except the data before the checkpoint still reaches the peer. + /// A peer that accepts RESET_STREAM_AT reads it before the error. Otherwise the reset waits a + /// round trip until the peer acknowledges the data, and the peer's application may never read + /// it: see [`moq_quic::Checkpoint::reset`]. + pub fn reset(self, error_code: VarInt) -> Result<(), ClosedStream> { + let mut conn = self.conn.state.lock("Checkpoint::reset"); + if self.is_0rtt && conn.check_0rtt().is_err() { + return Ok(()); + } + self.inner.reset(&mut conn.inner, error_code)?; + conn.wake(); + Ok(()) + } +} + impl Drop for SendStream { fn drop(&mut self) { let mut conn = self.conn.state.lock("SendStream::drop"); diff --git a/rs/moq-tokio/src/quic/web/send.rs b/rs/moq-tokio/src/quic/web/send.rs index 7f877185274..a6c040a045f 100644 --- a/rs/moq-tokio/src/quic/web/send.rs +++ b/rs/moq-tokio/src/quic/web/send.rs @@ -17,11 +17,17 @@ use crate::quic::web::{CloseReason, ClosedStream, SessionError, WriteError}; pub struct SendStream { stream: crate::quic::driver::SendStream, close: Arc, + /// Taken after the WebTransport header this side wrote first, which a reset must still deliver. + header: Option, } impl SendStream { - pub(crate) fn new(stream: crate::quic::driver::SendStream, close: Arc) -> Self { - Self { stream, close } + pub(crate) fn new( + stream: crate::quic::driver::SendStream, + close: Arc, + header: Option, + ) -> Self { + Self { stream, close, header } } /// Decode the peer's stop code, and report a session error as the session's close reason. @@ -41,9 +47,15 @@ impl SendStream { /// Abruptly reset the stream with the provided error code. See [`crate::quic::driver::SendStream::reset`]. /// This is a u32 with WebTransport because we share the error space with HTTP/3. /// A raw QUIC session sends the code as is. + /// + /// The WebTransport header still reaches the peer, so it can tell which session the reset + /// belongs to. pub fn reset(&mut self, code: u32) -> Result<(), ClosedStream> { let code = self.close.encode_stream_code(code); - self.stream.reset(code).map_err(Into::into) + match self.header.take() { + Some(header) => header.reset(code).map_err(Into::into), + None => self.stream.reset(code).map_err(Into::into), + } } /// Wait until the stream has been stopped and return the error code. See diff --git a/rs/moq-tokio/src/quic/web/session.rs b/rs/moq-tokio/src/quic/web/session.rs index 38e01d66847..c84ecfc0305 100644 --- a/rs/moq-tokio/src/quic/web/session.rs +++ b/rs/moq-tokio/src/quic/web/session.rs @@ -255,7 +255,7 @@ impl Session { } else { let (send, recv) = self.conn.accept_bi().await.map_err(|e| self.map_error(e))?; Ok(( - SendStream::new(send, self.close.clone()), + SendStream::new(send, self.close.clone(), None), RecvStream::new(recv, self.close.clone()), )) } @@ -276,7 +276,8 @@ impl Session { // Reset the stream priority back to the default of 0. send.set_priority(0).ok(); - Ok(SendStream::new(send, self.close.clone())) + let header = send.checkpoint(); + Ok(SendStream::new(send, self.close.clone(), Some(header))) } /// Open a new bidirectional stream. See [`crate::quic::driver::Connection::open_bi`]. @@ -294,8 +295,9 @@ impl Session { // Reset the stream priority back to the default of 0. send.set_priority(0).ok(); + let header = send.checkpoint(); Ok(( - SendStream::new(send, self.close.clone()), + SendStream::new(send, self.close.clone(), Some(header)), RecvStream::new(recv, self.close.clone()), )) } @@ -887,7 +889,8 @@ impl SessionAccept { if let Some((send, recv)) = res { // Wrap the streams in our own types for correct error codes. - let send = SendStream::new(send, self.close.clone()); + // The peer opened it, so this half carries no header. + let send = SendStream::new(send, self.close.clone(), None); let recv = RecvStream::new(recv, self.close.clone()); return Poll::Ready(Ok((send, recv))); } @@ -1294,6 +1297,35 @@ mod tests { assert_reset(err); } + /// A stream reset before any payload still delivers its header, so the peer attributes the + /// reset to the session instead of dropping a stream it cannot place. + #[tokio::test] + async fn reset_delivers_header() { + let (client_conn, server_conn, _endpoints) = pair().await; + let (client, server) = tokio::join!( + Session::connect(client_conn, url::Url::parse("https://localhost/").unwrap()), + async { crate::quic::web::Request::accept(server_conn).await.unwrap().ok().await }, + ); + let (client, server) = (client.unwrap(), server.unwrap()); + + client.open_uni().await.unwrap().reset(7).unwrap(); + let (mut send, _recv) = client.open_bi().await.unwrap(); + send.reset(8).unwrap(); + + let read = async { + let mut uni = server.accept_uni().await.unwrap(); + let (_send, mut bi) = server.accept_bi().await.unwrap(); + ( + uni.read_chunk(usize::MAX).await.unwrap_err(), + bi.read_chunk(usize::MAX).await.unwrap_err(), + ) + }; + // Without the header the server never surfaces the streams, so bound the wait. + let (uni, bi) = tokio::time::timeout(Duration::from_secs(10), read).await.unwrap(); + assert!(matches!(uni, crate::quic::web::ReadError::Reset(7)), "{uni:?}"); + assert!(matches!(bi, crate::quic::web::ReadError::Reset(8)), "{bi:?}"); + } + /// A stream that names another session is still reported as `UnknownSession`. #[tokio::test] async fn uni_other_session() { diff --git a/rs/moq-uring/src/quic/driver/stream.rs b/rs/moq-uring/src/quic/driver/stream.rs index 1be7b4e6a99..d6150c51159 100644 --- a/rs/moq-uring/src/quic/driver/stream.rs +++ b/rs/moq-uring/src/quic/driver/stream.rs @@ -8,7 +8,7 @@ use std::task::{Context, Poll}; use bytes::{Buf, Bytes, BytesMut}; -use moq_quic::{StreamId, VarInt}; +use moq_quic::{Checkpoint, StreamId, VarInt}; use super::super::Error; use super::{End, Shared}; @@ -51,38 +51,26 @@ impl SendStream { self.fin || self.reset } - /// Queue as much of `buf` as moq-quic will take right now, without parking. - /// Best-effort, for the close path where nobody is left to poll. - pub(crate) fn try_write(&mut self, buf: &[u8]) -> usize { - if self.fin || self.reset { - return 0; - } - let n = self - .shared - .conn - .borrow_mut() - .send_stream(self.id) - .write(buf) - .unwrap_or(0); - if n > 0 { - self.shared.kick(); - } - n + /// Mark the data written so far, for a later [`reset_code`](Self::reset_code) to deliver. + pub(crate) fn checkpoint(&self) -> Checkpoint { + self.shared.conn.borrow_mut().send_stream(self.id).checkpoint() } /// [`reset`](web_transport_trait::poll::SendStream::reset) with a - /// full-width code, for the WebTransport HTTP/3 error mapping. - pub(crate) fn reset_code(&mut self, code: u64) { + /// full-width code, for the WebTransport HTTP/3 error mapping, that still + /// delivers the data before `checkpoint`, one this stream took. + pub(crate) fn reset_code(&mut self, code: u64, checkpoint: Option) { if self.reset { return; } + let code = VarInt::from_u64(code).unwrap_or(VarInt::MAX); + let mut conn = self.shared.conn.borrow_mut(); // Err means the stream is already gone, which is what we wanted. - let _ = self - .shared - .conn - .borrow_mut() - .send_stream(self.id) - .reset(VarInt::from_u64(code).unwrap_or(VarInt::MAX)); + let _ = match checkpoint { + Some(checkpoint) => checkpoint.reset(&mut conn, code), + None => conn.send_stream(self.id).reset(code), + }; + drop(conn); self.reset = true; self.shared.kick(); } @@ -146,7 +134,7 @@ impl web_transport_trait::poll::SendStream for SendStream { } fn reset(&mut self, code: u32) { - self.reset_code(u64::from(code)); + self.reset_code(u64::from(code), None); } fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll> { diff --git a/rs/moq-uring/src/quic/web.rs b/rs/moq-uring/src/quic/web.rs index 192592f9b21..b6854e5b715 100644 --- a/rs/moq-uring/src/quic/web.rs +++ b/rs/moq-uring/src/quic/web.rs @@ -436,6 +436,10 @@ pub struct Session { /// What [`protocol`](web_transport_trait::poll::Session::protocol) /// reports: the selected subprotocol in web mode, the ALPN in raw mode. protocol: Option, + /// Streams opened but still writing their WebTransport header, handed out + /// only once it is all written, so a reset always delivers it. + opening_uni: Option<(SendStream, Bytes)>, + opening_bi: Option<(SendStream, RecvStream, Bytes)>, } impl Session { @@ -447,6 +451,8 @@ impl Session { conn, web: None, protocol, + opening_uni: None, + opening_bi: None, } } @@ -512,6 +518,8 @@ impl Session { conn, web: Some(web), protocol, + opening_uni: None, + opening_bi: None, } } @@ -530,6 +538,8 @@ impl Clone for Session { conn: self.conn.clone(), web: self.web.clone(), protocol: self.protocol.clone(), + opening_uni: None, + opening_bi: None, } } } @@ -583,12 +593,7 @@ impl web_transport_trait::poll::Session for Session { let Some(web) = self.web.clone() else { let (send, recv) = ready!(web_transport_trait::poll::Session::poll_accept_bi(&mut self.conn, cx))?; return Poll::Ready(Ok(( - SendStream { - inner: send, - prefix: Bytes::new(), - finishing: false, - web: false, - }, + SendStream::new(send, false), RecvStream { inner: recv, web: false, @@ -598,15 +603,7 @@ impl web_transport_trait::poll::Session for Session { loop { if let Some((send, recv)) = web.state.borrow_mut().ready_bi.pop_front() { - return Poll::Ready(Ok(( - SendStream { - inner: send, - prefix: Bytes::new(), - finishing: false, - web: true, - }, - RecvStream { inner: recv, web: true }, - ))); + return Poll::Ready(Ok((SendStream::new(send, true), RecvStream { inner: recv, web: true }))); } loop { @@ -624,36 +621,33 @@ impl web_transport_trait::poll::Session for Session { } fn poll_open_uni(&mut self, cx: &mut Context<'_>) -> Poll> { - let inner = ready!(web_transport_trait::poll::Session::poll_open_uni(&mut self.conn, cx)) - .map_err(|err| self.map_err(err))?; - let prefix = self.web.as_ref().map(|web| web.header_uni.clone()).unwrap_or_default(); - Poll::Ready(Ok(SendStream { - inner, - prefix, - finishing: false, - web: self.web.is_some(), - })) + if self.opening_uni.is_none() { + let inner = ready!(web_transport_trait::poll::Session::poll_open_uni(&mut self.conn, cx)) + .map_err(|err| self.map_err(err))?; + let header = self.web.as_ref().map(|web| web.header_uni.clone()).unwrap_or_default(); + self.opening_uni = Some((SendStream::new(inner, self.web.is_some()), header)); + } + let (send, header) = self.opening_uni.as_mut().expect("opening"); + let result = ready!(send.poll_header(cx, header)); + let (send, _) = self.opening_uni.take().expect("opening"); + Poll::Ready(result.map(|()| send)) } fn poll_open_bi( &mut self, cx: &mut Context<'_>, ) -> Poll> { - let (send, recv) = ready!(web_transport_trait::poll::Session::poll_open_bi(&mut self.conn, cx)) - .map_err(|err| self.map_err(err))?; - let prefix = self.web.as_ref().map(|web| web.header_bi.clone()).unwrap_or_default(); - Poll::Ready(Ok(( - SendStream { - inner: send, - prefix, - finishing: false, - web: self.web.is_some(), - }, - RecvStream { - inner: recv, - web: self.web.is_some(), - }, - ))) + if self.opening_bi.is_none() { + let (send, recv) = ready!(web_transport_trait::poll::Session::poll_open_bi(&mut self.conn, cx)) + .map_err(|err| self.map_err(err))?; + let web = self.web.is_some(); + let header = self.web.as_ref().map(|web| web.header_bi.clone()).unwrap_or_default(); + self.opening_bi = Some((SendStream::new(send, web), RecvStream { inner: recv, web }, header)); + } + let (send, _, header) = self.opening_bi.as_mut().expect("opening"); + let result = ready!(send.poll_header(cx, header)); + let (send, recv, _) = self.opening_bi.take().expect("opening"); + Poll::Ready(result.map(|()| (send, recv))) } fn poll_send_datagram(&mut self, cx: &mut Context<'_>, payload: &[u8]) -> Poll> { @@ -801,52 +795,63 @@ impl web_transport_trait::poll::Session for Session { /// An outgoing stream, WebTransport-framed when its session is. /// -/// [`finish`](web_transport_trait::poll::SendStream::finish) can leave the -/// WebTransport header owed, when the connection has no flow-control credit -/// for it. The FIN then goes out on a later -/// [`poll_closed`](web_transport_trait::poll::SendStream::poll_closed), or on -/// `Drop` if credit has returned by then. Dropping immediately after -/// finishing, with no poll in between, leaves no moment for it to return and -/// cancels the stream instead, so pair the two when a clean end matters. +/// A web stream we opened is handed out with its header already written, so a +/// reset still delivers the header and the peer can tell which session the +/// reset belongs to. pub struct SendStream { inner: super::SendStream, - /// Header bytes still owed to the wire before any payload. - prefix: Bytes, - /// [`finish`](web_transport_trait::poll::SendStream::finish) ran with the - /// header still owed, so [`poll_closed`](web_transport_trait::poll::SendStream::poll_closed) - /// writes the rest and finishes then. - finishing: bool, + /// The end of the WebTransport header on a stream we opened, for a reset + /// to deliver. + header: Option, web: bool, } impl SendStream { + fn new(inner: super::SendStream, web: bool) -> Self { + Self { + inner, + header: None, + web, + } + } + fn map(&self, err: Error) -> Error { match self.web { true => unmap_err(err), false => unmap_legacy(err), } } -} - -impl web_transport_trait::poll::SendStream for SendStream { - type Error = Error; - fn poll_write(&mut self, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { - // The FIN is owed the moment the header lands, so there is no room - // left for a payload; the inner stream refuses a post-FIN write the - // same way. - if self.finishing { - return Poll::Ready(Err(Error::Quic("stream already finished".to_string()))); + /// Write the WebTransport header of a stream we opened, checkpointing it + /// once it is all written. + fn poll_header(&mut self, cx: &mut Context<'_>, header: &mut Bytes) -> Poll> { + if !self.web { + return Poll::Ready(Ok(())); } - while !self.prefix.is_empty() { + while !header.is_empty() { let n = ready!(web_transport_trait::poll::SendStream::poll_write( &mut self.inner, cx, - &self.prefix + header )) .map_err(|err| self.map(err))?; - self.prefix.advance(n); + header.advance(n); } + self.header = Some(self.inner.checkpoint()); + Poll::Ready(Ok(())) + } + + /// Reset a WebTransport stream, still delivering the header of one we + /// opened. + fn reset_web(&mut self, code: u64) { + self.inner.reset_code(code, self.header.take()); + } +} + +impl web_transport_trait::poll::SendStream for SendStream { + type Error = Error; + + fn poll_write(&mut self, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { match web_transport_trait::poll::SendStream::poll_write(&mut self.inner, cx, buf) { Poll::Ready(Err(err)) => Poll::Ready(Err(self.map(err))), other => other, @@ -854,17 +859,6 @@ impl web_transport_trait::poll::SendStream for SendStream { } fn poll_write_buf(&mut self, cx: &mut Context<'_>, buf: &mut B) -> Poll> { - if self.finishing { - return Poll::Ready(Err(Error::Quic("stream already finished".to_string()))); - } - while !self.prefix.is_empty() { - ready!(web_transport_trait::poll::SendStream::poll_write_buf( - &mut self.inner, - cx, - &mut self.prefix - )) - .map_err(|err| self.map(err))?; - } match web_transport_trait::poll::SendStream::poll_write_buf(&mut self.inner, cx, buf) { Poll::Ready(Err(err)) => Poll::Ready(Err(self.map(err))), other => other, @@ -876,49 +870,17 @@ impl web_transport_trait::poll::SendStream for SendStream { } fn finish(&mut self) -> Result<(), Self::Error> { - // A stream finished before any write still owes its header, or the - // peer sees an unframed (and thus invalid) stream. - if !self.prefix.is_empty() { - let n = self.inner.try_write(&self.prefix); - self.prefix.advance(n); - if !self.prefix.is_empty() { - // Zero capacity here is ordinary flow control, which clears - // once the peer reads. Reporting it terminally would have the - // caller drop (and so reset) a stream that is finishing - // cleanly, so the FIN becomes this stream's debt: `poll_closed` - // writes the rest, and `Drop` pays what it can if nobody polls. - self.finishing = true; - return Ok(()); - } - } web_transport_trait::poll::SendStream::finish(&mut self.inner).map_err(|err| self.map(err)) } fn reset(&mut self, code: u32) { match self.web { - true => self.inner.reset_code(proto::error_to_http3(code)), + true => self.reset_web(proto::error_to_http3(code)), false => web_transport_trait::poll::SendStream::reset(&mut self.inner, code), } } fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll> { - // `finish` left the header owed, so finishing is still this call's job. - while self.finishing { - match ready!(web_transport_trait::poll::SendStream::poll_write( - &mut self.inner, - cx, - &self.prefix - )) { - Ok(n) => self.prefix.advance(n), - Err(err) => return Poll::Ready(Err(self.map(err))), - } - if self.prefix.is_empty() { - self.finishing = false; - if let Err(err) = web_transport_trait::poll::SendStream::finish(&mut self.inner) { - return Poll::Ready(Err(self.map(err))); - } - } - } match web_transport_trait::poll::SendStream::poll_closed(&mut self.inner, cx) { Poll::Ready(Err(err)) => Poll::Ready(Err(self.map(err))), other => other, @@ -928,23 +890,12 @@ impl web_transport_trait::poll::SendStream for SendStream { impl Drop for SendStream { fn drop(&mut self) { - // `finish` returned `Ok` with the header still owed, so the FIN is - // this stream's debt rather than the caller's. Pay it if the credit - // has since arrived, instead of letting a stream the caller finished - // cleanly go out as a cancellation. - if self.finishing { - let n = self.inner.try_write(&self.prefix); - self.prefix.advance(n); - if self.prefix.is_empty() { - let _ = web_transport_trait::poll::SendStream::finish(&mut self.inner); - } - } // The inner `Drop` resets with a raw 0, which reads to a browser as an // HTTP/3 stream error rather than the WebTransport cancellation that // dropping a stream means. moq cancels subscriptions by dropping, so // this is the ordinary path. if self.web && !self.inner.ended() { - self.inner.reset_code(proto::error_to_http3(0)); + self.reset_web(proto::error_to_http3(0)); } } } diff --git a/rs/moq-uring/tests/support.rs b/rs/moq-uring/tests/support.rs index 30ad51588a7..baa5cc2559d 100644 --- a/rs/moq-uring/tests/support.rs +++ b/rs/moq-uring/tests/support.rs @@ -3,7 +3,7 @@ #![cfg(target_os = "linux")] #![allow(dead_code)] -/// A self-signed localhost certificate on disk. +/// A self-signed certificate on disk for `localhost` and `127.0.0.1`. pub struct Certs { pub dir: tempfile::TempDir, pub cert: std::path::PathBuf, @@ -11,7 +11,7 @@ pub struct Certs { } pub fn certs() -> anyhow::Result { - let signed = rcgen::generate_simple_self_signed(vec!["localhost".into()])?; + let signed = rcgen::generate_simple_self_signed(vec!["localhost".into(), "127.0.0.1".into()])?; let dir = tempfile::tempdir()?; let cert = dir.path().join("cert.pem"); let key = dir.path().join("key.pem"); diff --git a/rs/moq-uring/tests/web.rs b/rs/moq-uring/tests/web.rs index ffdd71de508..7627bda6a24 100644 --- a/rs/moq-uring/tests/web.rs +++ b/rs/moq-uring/tests/web.rs @@ -587,6 +587,155 @@ async fn read_more(recv: &mut quic::RecvStream, out: &mut Vec) { out.extend_from_slice(&buf[..n]); } +/// A stream reset before any payload still delivers its WebTransport header, +/// so the peer attributes the reset to the session rather than dropping a +/// stream it cannot place: uring to tokio, and back. +#[test] +fn a_reset_stream_keeps_its_header() { + let Some(mut worker) = worker() else { return }; + let handle = worker.handle(); + let certs = support::certs().expect("certificates"); + let endpoint = h3_endpoint(&handle, &certs); + let addr = endpoint.local_addr(); + + let client = tokio_client(format!("https://{addr}/"), |session| { + Box::pin(async move { + let mut recv = session.accept_uni().await.expect("accept_uni"); + let err = recv.read_chunk(usize::MAX).await.expect_err("the server reset it"); + assert!(matches!(err, moq_tokio::quic::web::ReadError::Reset(7)), "got {err:?}"); + + session.open_uni().await.expect("open_uni").reset(8).expect("reset"); + session.closed().await; + }) + }); + + worker + .block_on(async move { + let conn = endpoint.accept().await.expect("accept"); + let request = quic::web::Request::accept(conn).await.expect("handshake"); + let mut session = request + .respond(quic::web::Response::default().with_protocol(PROTO)) + .await + .expect("respond"); + + // Reset before any payload. + let mut send = std::future::poll_fn(|cx| session.poll_open_uni(cx)) + .await + .expect("open_uni"); + send.reset(7); + + let mut recv = within( + &handle, + "the client's reset stream", + std::future::poll_fn(|cx| session.poll_accept_uni(cx)), + ) + .await + .expect("accept_uni"); + let mut buf = [0u8; 16]; + let err = std::future::poll_fn(|cx| recv.poll_read(cx, &mut buf)) + .await + .expect_err("the client reset it"); + assert!(matches!(err, quic::Error::Reset(8)), "got {err:?}"); + + session.close(CLOSE_CODE, CLOSE_REASON); + std::future::poll_fn(|cx| session.poll_closed(cx)).await; + }) + .expect("worker"); + + client.join().expect("client thread"); +} + +/// A stream opened with no connection credit left still delivers its header +/// when reset, rather than a plain reset of a stream the peer cannot place. +#[test] +fn a_reset_stream_keeps_its_header_without_credit() { + use std::task::Poll; + + let Some(mut worker) = worker() else { return }; + let handle = worker.handle(); + let certs = support::certs().expect("certificates"); + let endpoint = h3_endpoint(&handle, &certs); + let addr = endpoint.local_addr(); + let cert = std::fs::read(&certs.cert).expect("certificate"); + + let client = std::thread::spawn(move || { + let _ = rustls::crypto::aws_lc_rs::default_provider().install_default(); + let rt = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .expect("tokio runtime"); + rt.block_on(async move { + use moq_tokio::quic::driver; + use rustls::pki_types::{CertificateDer, pem::PemObject as _}; + + let mut roots = rustls::RootCertStore::empty(); + roots + .add(CertificateDer::from_pem_slice(&cert).expect("pem")) + .expect("root"); + let mut crypto = rustls::ClientConfig::builder() + .with_root_certificates(roots) + .with_no_client_auth(); + crypto.alpn_protocols = vec![b"h3".to_vec()]; + let mut config = driver::ClientConfig::new(std::sync::Arc::new( + driver::crypto::rustls::QuicClientConfig::try_from(crypto).expect("quic crypto"), + )); + // Little enough connection credit for the server to run out of + let mut transport = driver::TransportConfig::default(); + transport.receive_window(driver::VarInt::from_u32(16 * 1024)); + config.transport_config(std::sync::Arc::new(transport)); + let endpoint = driver::Endpoint::client("127.0.0.1:0".parse().unwrap()).expect("endpoint"); + let client = moq_tokio::quic::web::Client::new(endpoint, config); + + let request = + moq_tokio::quic::web::proto::ConnectRequest::new(url::Url::parse(&format!("https://{addr}/")).unwrap()) + .with_protocol(PROTO); + let session = client.connect(request).await.expect("connect"); + + // Reading the filler returns the credit the reset stream waits on. + let mut filler = session.accept_uni().await.expect("accept_uni"); + read_all(&mut filler).await; + + let accept = tokio::time::timeout(std::time::Duration::from_secs(5), session.accept_uni()); + let mut recv = accept.await.expect("the reset stream arrives").expect("accept_uni"); + let err = recv.read_chunk(usize::MAX).await.expect_err("the server reset it"); + assert!(matches!(err, moq_tokio::quic::web::ReadError::Reset(7)), "got {err:?}"); + // Only now, so the close cannot overtake the reset stream. + session.close(CLOSE_CODE, CLOSE_REASON.as_bytes()); + session.closed().await; + }); + }); + + worker + .block_on(async move { + let conn = endpoint.accept().await.expect("accept"); + let request = quic::web::Request::accept(conn).await.expect("handshake"); + let mut session = request + .respond(quic::web::Response::default().with_protocol(PROTO)) + .await + .expect("respond"); + + // Spend all of the connection credit on a filler stream. + let mut filler = std::future::poll_fn(|cx| session.poll_open_uni(cx)) + .await + .expect("open_uni"); + let chunk = [0u8; 1024]; + while let Poll::Ready(n) = std::future::poll_fn(|cx| Poll::Ready(filler.poll_write(cx, &chunk))).await { + n.expect("write"); + } + filler.finish().expect("finish"); + + let mut send = std::future::poll_fn(|cx| session.poll_open_uni(cx)) + .await + .expect("open_uni"); + send.reset(7); + + std::future::poll_fn(|cx| session.poll_closed(cx)).await; + }) + .expect("worker"); + + client.join().expect("client thread"); +} + /// Closing a session and dropping it on the spot still delivers the close /// capsule, with the HTTP/3 critical streams open underneath it. ///