Add lifetime to CID to avoid future change on CID generator trait that breaks compatibility

Author: Wenjie Li

quinn-proto/src/cid_generator.rs

@@ -1,17 +1,21 @@
+use std::time::Duration;
+
 use rand::RngCore;
 
 use crate::shared::ConnectionId;
 use crate::MAX_CID_SIZE;
 
 /// Generates connection IDs for incoming connections
 pub trait ConnectionIdGenerator: Send {
-    /// Generates a new CID
+    /// Generates a new CID with finite lifetime
     ///
     /// Connection IDs MUST NOT contain any information that can be used by
     /// an external observer (that is, one that does not cooperate with the
     /// issuer) to correlate them with other connection IDs for the same
     /// connection.
-    fn generate_cid(&mut self) -> ConnectionId;
+    ///
+    /// Connection IDs will be proactively retired if lifetime is given (under development).
+    fn generate_cid(&mut self) -> (ConnectionId, Option<Duration>);
     /// Returns the length of a CID for cononections created by this generator
     fn cid_len(&self) -> usize;
 }
@@ -20,25 +24,38 @@ pub trait ConnectionIdGenerator: Send {
 #[derive(Debug, Clone, Copy)]
 pub struct RandomConnectionIdGenerator {
     cid_len: usize,
+    lifetime: Option<Duration>,
 }
 impl Default for RandomConnectionIdGenerator {
     fn default() -> Self {
-        Self { cid_len: 8 }
+        Self {
+            cid_len: 8,
+            lifetime: None,
+        }
     }
 }
 impl RandomConnectionIdGenerator {
     /// Initialize Random CID generator with a fixed CID length (which must be less or equal to MAX_CID_SIZE)
     pub fn new(cid_len: usize) -> Self {
         debug_assert!(cid_len <= MAX_CID_SIZE);
-        Self { cid_len }
+        Self {
+            cid_len,
+            ..RandomConnectionIdGenerator::default()
+        }
+    }
+
+    /// Set the lifetime of CIDs created by this generator
+    pub fn set_lifetime(&mut self, d: Duration) -> &mut Self {
+        self.lifetime = Some(d);
+        self
     }
 }
 impl ConnectionIdGenerator for RandomConnectionIdGenerator {
-    fn generate_cid(&mut self) -> ConnectionId {
+    fn generate_cid(&mut self) -> (ConnectionId, Option<Duration>) {
         let mut bytes_arr = [0; MAX_CID_SIZE];
         rand::thread_rng().fill_bytes(&mut bytes_arr[..self.cid_len]);
 
-        ConnectionId::new(&bytes_arr[..self.cid_len])
+        (ConnectionId::new(&bytes_arr[..self.cid_len]), self.lifetime)
     }
 
     /// Provide the length of dst_cid in short header packet

quinn-proto/src/endpoint.rs

@@ -345,7 +345,7 @@ where
         if self.is_full() {
             return Err(ConnectError::TooManyConnections);
         }
-        let remote_id = RandomConnectionIdGenerator::new(MAX_CID_SIZE).generate_cid();
+        let (remote_id, _) = RandomConnectionIdGenerator::new(MAX_CID_SIZE).generate_cid();
         trace!(initial_dcid = %remote_id);
         let (ch, conn) = self.add_connection(
             remote_id,
@@ -363,7 +363,7 @@ where
     fn send_new_identifiers(&mut self, ch: ConnectionHandle, num: u64) -> ConnectionEvent {
         let mut ids = vec![];
         for _ in 0..num {
-            let id = self.new_cid();
+            let (id, _) = self.new_cid();
             self.connection_ids.insert(id, ch);
             let meta = &mut self.connections[ch];
             meta.cids_issued += 1;
@@ -378,11 +378,11 @@ where
         ConnectionEvent(ConnectionEventInner::NewIdentifiers(ids))
     }
 
-    fn new_cid(&mut self) -> ConnectionId {
+    fn new_cid(&mut self) -> (ConnectionId, Option<Duration>) {
         loop {
-            let cid = self.local_cid_generator.generate_cid();
+            let (cid, lifetime) = self.local_cid_generator.generate_cid();
             if !self.connection_ids.contains_key(&cid) {
-                break cid;
+                break (cid, lifetime);
             }
             assert!(self.local_cid_generator.cid_len() > 0);
         }
@@ -396,7 +396,7 @@ where
         opts: ConnectionOpts<S>,
         now: Instant,
     ) -> Result<(ConnectionHandle, Connection<S>), ConnectError> {
-        let loc_cid = self.new_cid();
+        let (loc_cid, _) = self.new_cid();
         let (server_config, tls, transport_config) = match opts {
             ConnectionOpts::Client {
                 config,
@@ -509,7 +509,7 @@ where
         }
 
         // Local CID used for stateless packets
-        let temp_loc_cid = self.new_cid();
+        let (temp_loc_cid, _) = self.new_cid();
         let server_config = self.server_config.as_ref().unwrap();
 
         if self.incoming_handshakes == server_config.accept_buffer as usize

quinn-proto/src/token.rs

@@ -153,9 +153,11 @@ mod test {
         rand::thread_rng().fill_bytes(&mut key);
         let key = <hmac::Key as HmacKey>::new(&key).unwrap();
         let addr = SocketAddr::new(Ipv6Addr::LOCALHOST.into(), 4433);
-        let retry_src_cid = RandomConnectionIdGenerator::new(MAX_CID_SIZE).generate_cid();
+        let (retry_src_cid, _) = RandomConnectionIdGenerator::new(MAX_CID_SIZE).generate_cid();
         let token = RetryToken {
-            orig_dst_cid: RandomConnectionIdGenerator::new(MAX_CID_SIZE).generate_cid(),
+            orig_dst_cid: RandomConnectionIdGenerator::new(MAX_CID_SIZE)
+                .generate_cid()
+                .0,
             issued: UNIX_EPOCH + Duration::new(42, 0), // Fractional seconds would be lost
         };
         let encoded = token.encode(&key, &addr, &retry_src_cid);