Return InvalidStreamState from stream_send() for collected streams

When a stream has been completed and garbage collected (for example
after the peer sends STOP_SENDING, the fin bit is received, and the
data is drained via stream_recv()), a subsequent stream_send() call
hits get_or_create() for an id that is in the collected set, which
returns Error::Done. That error was forwarded unchanged, so callers
saw Done (normally "no capacity") for a stream that no longer exists.

Map that case to Error::InvalidStreamState instead, matching the
behaviour of stream_recv() which already returns InvalidStreamState
for a non-existent stream. This lets applications distinguish a lack
of send capacity from an invalid stream id without an extra
stream_writable() check.

Fixes #1695

Author: schiemon

quiche/src/lib.rs

@@ -6025,6 +6025,10 @@ impl<F: BufFactory> Connection<F> {
                 return Err(Error::StreamLimit);
             },
 
+            // Stream already collected; mirror stream_recv()'s
+            // InvalidStreamState.
+            Err(Error::Done) => return Err(Error::InvalidStreamState(stream_id)),
+
             Err(e) => return Err(e),
         };
 

quiche/src/tests.rs

@@ -3472,6 +3472,38 @@ fn stop_sending_fin(
     assert_eq!(iter.next(), None);
 }
 
+#[rstest]
+/// Tests that stream_send() on a collected stream returns InvalidStreamState
+/// rather than Done (issue #1695).
+fn stream_send_after_stop_sending_and_fin(
+    #[values("cubic", "bbr2_gcongestion")] cc_algorithm_name: &str,
+) {
+    let mut pipe = test_utils::Pipe::new(cc_algorithm_name).unwrap();
+    assert_eq!(pipe.handshake(), Ok(()));
+
+    // Server opens a bidi stream and sends data with fin.
+    assert_eq!(pipe.server.stream_send(5, b"hello", true), Ok(5));
+
+    // Server also sends STOP_SENDING, indicating it will not read from the
+    // client on this stream.
+    assert_eq!(pipe.server.stream_shutdown(5, Shutdown::Read, 42), Ok(()));
+
+    // Exchange all packets: client receives the STOP_SENDING and STREAM(fin).
+    assert_eq!(pipe.advance(), Ok(()));
+
+    // Client reads the data. The stream is now complete on both sides (recv
+    // finished, send stopped), so quiche collects it.
+    let mut buf = [0; 64];
+    assert_eq!(pipe.client.stream_recv(5, &mut buf), Ok((5, true)));
+
+    // The stream has been collected. stream_send() must return
+    // InvalidStreamState, not Done.
+    assert_eq!(
+        pipe.client.stream_send(5, b"world", false),
+        Err(Error::InvalidStreamState(5)),
+    );
+}
+
 #[rstest]
 /// Tests that resetting a stream restores flow control for unsent data.
 fn stop_sending_unsent_tx_cap(
@@ -5541,7 +5573,10 @@ fn collect_streams(
     assert!(pipe.client.stream_finished(0));
     assert!(pipe.server.stream_finished(0));
 
-    assert_eq!(pipe.client.stream_send(0, b"", true), Err(Error::Done));
+    assert_eq!(
+        pipe.client.stream_send(0, b"", true),
+        Err(Error::InvalidStreamState(0))
+    );
 
     let frames = [frame::Frame::Stream {
         stream_id: 0,
@@ -11810,9 +11845,11 @@ fn stop_sending_stream_send_after_reset_stream_ack(
     assert_eq!(w.len(), 9);
     assert!(!w.any(|s| s == 0));
 
-    // If we called send before the client ACK of reset stream, it would
-    // have failed with StreamStopped.
-    assert_eq!(pipe.server.stream_send(0, b"world", true), Err(Error::Done),);
+    // Stream 0 has been collected; stream_send must return InvalidStreamState.
+    assert_eq!(
+        pipe.server.stream_send(0, b"world", true),
+        Err(Error::InvalidStreamState(0)),
+    );
 
     // Stream 0 is still not writable.
     let mut w = pipe.server.writable();

rustc-ice-2026-06-07T19:23:20.454584Z-51199.txt

@@ -0,0 +1,25 @@
+thread 'main' panicked at library/std/src/io/stdio.rs:1019:9:
+failed printing to stderr: Broken pipe (os error 32)
+stack backtrace:
+   0:        0x101a9a57c - <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt::hd9028bcf6e51ebaa
+   1:        0x101aee060 - core::fmt::write::h55bdf6c61e182108
+   2:        0x101a8fcd8 - std::io::Write::write_fmt::hda38b67d64b411f4
+   3:        0x101a9a3bc - std::sys_common::backtrace::print::h495b27ca64004324
+   4:        0x101a9d1bc - std::panicking::panic_hook_with_disk_dump::{{closure}}::hf57b42f9c3e59ef7
+   5:        0x101a9ce74 - std::panicking::panic_hook_with_disk_dump::h135d0abfa60c8e17
+   6:        0x109abaf90 - rustc_driver_impl[df94399f4d5d78c1]::install_ice_hook::{closure#0}
+   7:        0x101a9d9a4 - std::panicking::rust_panic_with_hook::ha2501c1cf653f30c
+   8:        0x101a9d774 - std::panicking::begin_panic_handler::{{closure}}::h40334808c318e5be
+   9:        0x101a9aa18 - std::sys_common::backtrace::__rust_end_short_backtrace::heebf5ae015c51044
+  10:        0x101a9d4e0 - _rust_begin_unwind
+  11:        0x101b1900c - core::panicking::panic_fmt::hb27f9126bf124657
+  12:        0x101a8e9e8 - std::io::stdio::_eprint::hae02168798538215
+  13:        0x1008816c0 - <rustfmt_nightly[6e674ee5e038b084]::config::Config>::from_toml_path
+  14:        0x100883198 - <rustfmt_nightly[6e674ee5e038b084]::config::Config>::from_resolved_toml_path
+  15:        0x100867aa0 - rustfmt_nightly[6e674ee5e038b084]::config::load_config::<rustfmt[a3b2e46fc0dbbe4f]::GetOptsOptions>
+  16:        0x10085d0ac - rustfmt[a3b2e46fc0dbbe4f]::execute
+  17:        0x10085b930 - rustfmt[a3b2e46fc0dbbe4f]::main
+  18:        0x100869494 - std[c2739d50c071c0d9]::sys_common::backtrace::__rust_begin_short_backtrace::<fn(), ()>
+  19:        0x10086c030 - std[c2739d50c071c0d9]::rt::lang_start::<()>::{closure#0}
+  20:        0x101a826f4 - std::rt::lang_start_internal::h16f195600b3e1cf0
+  21:        0x10085eaf0 - _main