lib: support idle timeout reconfiguration

Author: LPardue

quiche/include/quiche.h

@@ -333,6 +333,10 @@ void quiche_conn_set_qlog_fd(quiche_conn *conn, int fd, const char *log_title,
 // Configures the given session for resumption.
 int quiche_conn_set_session(quiche_conn *conn, const uint8_t *buf, size_t buf_len);
 
+// Sets the `max_idle_timeout` transport parameter, in milliseconds, default is
+// no timeout.
+int quiche_conn_set_max_idle_timeout(quiche_conn *conn, uint64_t v);
+
 typedef struct {
     // The remote address the packet was received from.
     struct sockaddr *from;

quiche/src/ffi.rs

@@ -725,6 +725,17 @@ pub extern fn quiche_conn_set_session(
     }
 }
 
+#[no_mangle]
+pub extern fn quiche_conn_set_max_idle_timeout(
+    conn: &mut Connection, v: u64,
+) -> c_int {
+    match conn.set_max_idle_timeout(v) {
+        Ok(()) => 0,
+
+        Err(e) => e.to_c() as c_int,
+    }
+}
+
 #[repr(C)]
 pub struct RecvInfo<'a> {
     from: &'a sockaddr,

quiche/src/lib.rs

@@ -2198,6 +2198,19 @@ impl Connection {
         Ok(())
     }
 
+    /// Sets the `max_idle_timeout` transport parameter, in milliseconds.
+    ///
+    /// This must only be called immediately after creating a connection, that
+    /// is, before any packet is sent or received.
+    ///
+    /// The default value is infinite, that is, no timeout is used unless
+    /// already configured when creating the connection.
+    pub fn set_max_idle_timeout(&mut self, v: u64) -> Result<()> {
+        self.local_transport_params.max_idle_timeout = v;
+
+        self.encode_transport_params()
+    }
+
     /// Processes QUIC packets received from the peer.
     ///
     /// On success the number of bytes processed from the input buffer is
@@ -9228,6 +9241,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn change_idle_timeout() {
+        let mut config = Config::new(0x1).unwrap();
+        config
+            .set_application_protos(&[b"proto1", b"proto2"])
+            .unwrap();
+        config.set_max_idle_timeout(999999);
+        config.verify_peer(false);
+
+        let mut pipe = testing::Pipe::with_client_config(&mut config).unwrap();
+        assert_eq!(pipe.client.local_transport_params.max_idle_timeout, 999999);
+        assert_eq!(pipe.client.peer_transport_params.max_idle_timeout, 0);
+        assert_eq!(pipe.server.local_transport_params.max_idle_timeout, 0);
+        assert_eq!(pipe.server.peer_transport_params.max_idle_timeout, 0);
+
+        pipe.client.set_max_idle_timeout(456000).unwrap();
+        pipe.server.set_max_idle_timeout(234000).unwrap();
+        assert_eq!(pipe.client.local_transport_params.max_idle_timeout, 456000);
+        assert_eq!(pipe.client.peer_transport_params.max_idle_timeout, 0);
+        assert_eq!(pipe.server.local_transport_params.max_idle_timeout, 234000);
+        assert_eq!(pipe.server.peer_transport_params.max_idle_timeout, 0);
+
+        assert_eq!(pipe.handshake(), Ok(()));
+
+        assert_eq!(
+            pipe.client.idle_timeout(),
+            Some(time::Duration::from_millis(234000))
+        );
+        assert_eq!(
+            pipe.server.idle_timeout(),
+            Some(time::Duration::from_millis(234000))
+        );
+    }
+
     #[test]
     fn handshake() {
         let mut pipe = testing::Pipe::new().unwrap();