Start sending path abandon

This changes the open_path function to no longer return the
PATH_ABANDON frame, but instead put it on the pending data.  And adds
functionality to send it in poll_transmit.

Author: flub

quinn-proto/src/connection/mod.rs

@@ -24,9 +24,7 @@ use crate::{
     config::{ServerConfig, TransportConfig},
     congestion::Controller,
     crypto::{self, KeyPair, Keys, PacketKey},
-    frame::{
-        self, Close, Datagram, FrameStruct, NewToken, ObservedAddr, PathAbandon, PathAvailable,
-    },
+    frame::{self, Close, Datagram, FrameStruct, NewToken, ObservedAddr, PathAvailable},
     packet::{
         FixedLengthConnectionIdParser, Header, InitialHeader, InitialPacket, LongType, Packet,
         PacketNumber, PartialDecode, SpaceId,
@@ -581,14 +579,11 @@ impl Connection {
             //   This allows us to safely consume the path_id due to the failed attempt, otherwise
             //   we would need to keep track of holes in the range and revert the
             //   max_path_id_in_use
-
-            return Some((
-                None,
-                vec![Frame::PathAbandon(PathAbandon {
-                    path_id,
-                    error_code: TransportErrorCode::NO_CID_AVAILABLE,
-                })],
-            ));
+            self.spaces[SpaceId::Data]
+                .pending
+                .path_abandon
+                .push((path_id, TransportErrorCode::NO_CID_AVAILABLE));
+            return None;
         };
 
         let mut path = PathData::new(remote, self.allow_mtud, None, now, &self.config);
@@ -4087,6 +4082,23 @@ impl Connection {
             }
         }
 
+        // PATH_ABANDON
+        while !path_exclusive_only
+            && space_id == SpaceId::Data
+            && frame::PathAbandon::SIZE_BOUND <= buf.remaining_mut()
+        {
+            let Some((path_id, error_code)) = space.pending.path_abandon.pop() else {
+                break;
+            };
+            frame::PathAbandon {
+                path_id,
+                error_code,
+            }
+            .encode(buf);
+            // TODO(flub): frame stats?
+        }
+
+        // RESET_STREAM, STOP_SENDING, MAX_DATA, MAX_STREAM_DATA, MAX_STREAMS
         if space_id == SpaceId::Data {
             self.streams.write_control_frames(
                 buf,

quinn-proto/src/connection/spaces.rs

@@ -11,8 +11,9 @@ use tracing::{error, trace};
 
 use super::{PathId, assembler::Assembler};
 use crate::{
-    Dir, Duration, Instant, SocketAddr, StreamId, TransportError, VarInt, connection::StreamsState,
-    crypto::Keys, frame, packet::SpaceId, range_set::ArrayRangeSet, shared::IssuedCid,
+    Dir, Duration, Instant, SocketAddr, StreamId, TransportError, TransportErrorCode, VarInt,
+    connection::StreamsState, crypto::Keys, frame, packet::SpaceId, range_set::ArrayRangeSet,
+    shared::IssuedCid,
 };
 
 pub(super) struct PacketSpace {
@@ -517,6 +518,8 @@ pub struct Retransmits {
     /// something. However, due to the architecture of Quinn, it is considerably simpler to not do
     /// that; consider what such a change would mean for implementing `BitOrAssign` on Self.
     pub(super) new_tokens: Vec<SocketAddr>,
+    /// Paths which need to be abandoned
+    pub(super) path_abandon: Vec<(PathId, TransportErrorCode)>,
 }
 
 impl Retransmits {
@@ -536,6 +539,7 @@ impl Retransmits {
             && !self.handshake_done
             && !self.observed_addr
             && self.new_tokens.is_empty()
+            && self.path_abandon.is_empty()
     }
 }
 
@@ -559,6 +563,7 @@ impl ::std::ops::BitOrAssign for Retransmits {
         self.handshake_done |= rhs.handshake_done;
         self.observed_addr |= rhs.observed_addr;
         self.new_tokens.extend_from_slice(&rhs.new_tokens);
+        self.path_abandon.extend_from_slice(&rhs.path_abandon)
     }
 }
 

quinn-proto/src/frame.rs

@@ -1288,8 +1288,9 @@ pub(crate) struct PathAbandon {
     pub(crate) error_code: TransportErrorCode,
 }
 
-#[allow(dead_code)] // TODO(flub)
 impl PathAbandon {
+    pub(crate) const SIZE_BOUND: usize = VarInt(FrameType::PATH_ABANDON.0).size() + 8 + 8;
+
     // TODO(@divma): docs
     pub(crate) fn encode<W: BufMut>(&self, buf: &mut W) {
         buf.write(FrameType::PATH_ABANDON);