add new frames and their tests

Author: divagant-martian

quinn-proto/src/cid_queue.rs

@@ -139,6 +139,7 @@ mod tests {
 
     fn cid(sequence: u64, retire_prior_to: u64) -> NewConnectionId {
         NewConnectionId {
+            path_id: None,
             sequence,
             id: ConnectionId::new(&[0xAB; 8]),
             reset_token: ResetToken::from([0xCD; crate::RESET_TOKEN_SIZE]),

quinn-proto/src/connection/mod.rs

@@ -1373,6 +1373,7 @@ impl Connection {
         space: SpaceId,
         ack: frame::Ack,
     ) -> Result<(), TransportError> {
+        // TODO(@divma): check path id
         if ack.largest >= self.spaces[space].next_packet_number {
             return Err(TransportError::PROTOCOL_VIOLATION("unsent packet acked"));
         }
@@ -2788,7 +2789,11 @@ impl Connection {
                     }
                     self.streams.received_stop_sending(id, error_code);
                 }
-                Frame::RetireConnectionId { sequence } => {
+                Frame::RetireConnectionId(frame::RetireConnectionId {
+                    path_id: _,
+                    sequence,
+                }) => {
+                    // TODO(@divma): use path id
                     let allow_more_cids = self
                         .local_cid_state
                         .on_cid_retirement(sequence, self.peer_params.issue_cids_limit())?;
@@ -2942,6 +2947,18 @@ impl Connection {
                         migration_observed_addr = Some(observed)
                     }
                 }
+                Frame::PathAbandon(_) => {
+                    // TODO(@divma): jump ship?
+                }
+                Frame::PathAvailable(_) => {
+                    // TODO(@divma): do stuff
+                }
+                Frame::MaxPathId(_) => {
+                    // TODO(@divma): do stuff
+                }
+                Frame::PathsBlocked(_) => {
+                    // TODO(@divma): do stuff
+                }
             }
         }
 
@@ -3304,6 +3321,7 @@ impl Connection {
         }
 
         // NEW_CONNECTION_ID
+        // TODO(@divma): need to change this; add a decent size fn
         while buf.len() + 44 < max_size {
             let issued = match space.pending.new_cids.pop() {
                 Some(x) => x,
@@ -3315,6 +3333,7 @@ impl Connection {
                 "NEW_CONNECTION_ID"
             );
             frame::NewConnectionId {
+                path_id: None, // TODO(@divma): multipath!
                 sequence: issued.sequence,
                 retire_prior_to: self.local_cid_state.retire_prior_to(),
                 id: issued.id,
@@ -3326,15 +3345,19 @@ impl Connection {
         }
 
         // RETIRE_CONNECTION_ID
+        // TODO(@divma): buf size bounds are now wrong
         while buf.len() + frame::RETIRE_CONNECTION_ID_SIZE_BOUND < max_size {
-            let seq = match space.pending.retire_cids.pop() {
+            let sequence = match space.pending.retire_cids.pop() {
                 Some(x) => x,
                 None => break,
             };
-            trace!(sequence = seq, "RETIRE_CONNECTION_ID");
-            buf.write(frame::FrameType::RETIRE_CONNECTION_ID);
-            buf.write_var(seq);
-            sent.retransmits.get_or_create().retire_cids.push(seq);
+            trace!(sequence, "RETIRE_CONNECTION_ID");
+            frame::RetireConnectionId {
+                path_id: None, // TODO(@divma): multipath!
+                sequence,
+            }
+            .write(buf);
+            sent.retransmits.get_or_create().retire_cids.push(sequence);
             self.stats.frame_tx.retire_connection_id += 1;
         }
 
@@ -3401,7 +3424,8 @@ impl Connection {
             delay_micros
         );
 
-        frame::Ack::encode(delay as _, space.pending_acks.ranges(), ecn, buf);
+        // TODO(@divma): connect here when path management is ready
+        frame::Ack::encode(None, delay as _, space.pending_acks.ranges(), ecn, buf);
         stats.frame_tx.acks += 1;
     }
 
@@ -3441,6 +3465,7 @@ impl Connection {
         trace!("negotiated max idle timeout {:?}", self.idle_timeout);
         if let Some(ref info) = params.preferred_address {
             self.rem_cids.insert(frame::NewConnectionId {
+                path_id: None, // TODO(@divma): use
                 sequence: 1,
                 id: info.connection_id,
                 reset_token: info.stateless_reset_token,

quinn-proto/src/connection/stats.rs

@@ -54,13 +54,18 @@ pub struct FrameStats {
     pub stop_sending: u64,
     pub stream: u64,
     pub observed_addr: u64,
+    pub path_abandon: u64,
+    pub path_available: u64,
+    pub max_path_id: u64,
+    pub paths_blocked: u64,
 }
 
 impl FrameStats {
     pub(crate) fn record(&mut self, frame: &Frame) {
         match frame {
             Frame::Padding => {}
             Frame::Ping => self.ping += 1,
+            // TODO(@divma): path acks independently?
             Frame::Ack(_) => self.acks += 1,
             Frame::ResetStream(_) => self.reset_stream += 1,
             Frame::StopSending(_) => self.stop_sending += 1,
@@ -87,6 +92,7 @@ impl FrameStats {
                 }
             }
             Frame::NewConnectionId(_) => self.new_connection_id += 1,
+            // TODO(@divma): split stats?
             Frame::RetireConnectionId { .. } => self.retire_connection_id += 1,
             Frame::PathChallenge(_) => self.path_challenge += 1,
             Frame::PathResponse(_) => self.path_response += 1,
@@ -95,6 +101,11 @@ impl FrameStats {
             Frame::ImmediateAck => self.immediate_ack += 1,
             Frame::HandshakeDone => self.handshake_done = self.handshake_done.saturating_add(1),
             Frame::ObservedAddr(_) => self.observed_addr += 1,
+            Frame::PathAbandon(_) => self.path_abandon = self.path_abandon.saturating_add(1),
+            // TODO(@divma): split stats?
+            Frame::PathAvailable(_) => self.path_available = self.path_available.saturating_add(1),
+            Frame::MaxPathId(_) => self.max_path_id = self.max_path_id.saturating_add(1),
+            Frame::PathsBlocked(_) => self.paths_blocked = self.paths_blocked.saturating_add(1),
         }
     }
 }