Use PLPMTUD in bench, perf and examples

Sponsored by Stormshield

bench/src/lib.rs

@@ -142,6 +142,8 @@ pub fn transport_config(opt: &Opt) -> quinn::TransportConfig {
     // High stream windows are chosen because the amount of concurrent streams
     // is configurable as a parameter.
     let mut config = quinn::TransportConfig::default();
+    #[cfg(any(windows, os = "linux"))]
+    config.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
     config.max_concurrent_uni_streams(opt.max_streams.try_into().unwrap());
     config.initial_max_udp_payload_size(opt.initial_mtu);
     config

perf/src/bin/perf_client.rs

@@ -129,6 +129,8 @@ async fn run(opt: Opt) -> Result<()> {
     }
 
     let mut transport = quinn::TransportConfig::default();
+    #[cfg(any(windows, os = "linux"))]
+    transport.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
     transport.initial_max_udp_payload_size(opt.initial_max_udp_payload_size);
 
     let mut cfg = if opt.no_protection {

perf/src/bin/perf_server.rs

@@ -88,6 +88,8 @@ async fn run(opt: Opt) -> Result<()> {
     }
 
     let mut transport = quinn::TransportConfig::default();
+    #[cfg(any(windows, os = "linux"))]
+    transport.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
     transport.initial_max_udp_payload_size(opt.initial_max_udp_payload_size);
 
     let mut server_config = if opt.no_protection {

quinn/benches/bench.rs

@@ -74,23 +74,28 @@ struct Context {
 }
 
 impl Context {
-    #[allow(clippy::field_reassign_with_default)] // https://github.com/rust-lang/rust-clippy/issues/6527
     fn new() -> Self {
         let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
         let key = rustls::PrivateKey(cert.serialize_private_key_der());
         let cert = rustls::Certificate(cert.serialize_der().unwrap());
 
         let mut server_config =
             quinn::ServerConfig::with_single_cert(vec![cert.clone()], key).unwrap();
-        Arc::get_mut(&mut server_config.transport)
-            .unwrap()
-            .max_concurrent_uni_streams(1024_u16.into());
+        let transport_config = Arc::get_mut(&mut server_config.transport).unwrap();
+        transport_config.max_concurrent_uni_streams(1024_u16.into());
+        enable_plpmtud_if_supported(transport_config);
 
         let mut roots = rustls::RootCertStore::empty();
         roots.add(&cert).unwrap();
+
+        let mut client_config = quinn::ClientConfig::with_root_certificates(roots);
+        let mut transport_config = quinn::TransportConfig::default();
+        enable_plpmtud_if_supported(&mut transport_config);
+        client_config.transport_config(Arc::new(transport_config));
+
         Self {
             server_config,
-            client_config: quinn::ClientConfig::with_root_certificates(roots),
+            client_config,
         }
     }
 
@@ -153,6 +158,14 @@ impl Context {
     }
 }
 
+#[cfg(any(windows, os = "linux"))]
+fn enable_plpmtud_if_supported(transport_config: &mut quinn::TransportConfig) {
+    transport_config.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
+}
+
+#[cfg(not(any(windows, os = "linux")))]
+fn enable_plpmtud_if_supported(_transport_config: &mut quinn::TransportConfig) {}
+
 fn rt() -> Runtime {
     Builder::new_current_thread().enable_all().build().unwrap()
 }

quinn/examples/client.rs

@@ -95,8 +95,11 @@ async fn run(options: Opt) -> Result<()> {
         client_crypto.key_log = Arc::new(rustls::KeyLogFile::new());
     }
 
+    let mut client_config = quinn::ClientConfig::new(Arc::new(client_crypto));
+    common::enable_plpmtud_if_supported(&mut client_config);
+
     let mut endpoint = quinn::Endpoint::client("[::]:0".parse().unwrap())?;
-    endpoint.set_default_client_config(quinn::ClientConfig::new(Arc::new(client_crypto)));
+    endpoint.set_default_client_config(client_config);
 
     let request = format!("GET {}\r\n", url.path());
     let start = Instant::now();

quinn/examples/common/mod.rs

@@ -45,11 +45,25 @@ fn configure_client(server_certs: &[&[u8]]) -> Result<ClientConfig, Box<dyn Erro
         certs.add(&rustls::Certificate(cert.to_vec()))?;
     }
 
-    Ok(ClientConfig::with_root_certificates(certs))
+    let mut client_config = ClientConfig::with_root_certificates(certs);
+    enable_plpmtud_if_supported(&mut client_config);
+
+    Ok(client_config)
+}
+
+/// Enables PLPMTUD if supported by the operating system
+#[cfg(any(windows, os = "linux"))]
+pub fn enable_plpmtud_if_supported(client_config: &mut ClientConfig) {
+    let mut transport_config = quinn::TransportConfig::default();
+    transport_config.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
+    client_config.transport_config(Arc::new(transport_config));
 }
 
+/// Enables PLPMTUD if supported by the operating system
+#[cfg(not(any(windows, os = "linux")))]
+pub fn enable_plpmtud_if_supported(_client_config: &mut ClientConfig) {}
+
 /// Returns default server configuration along with its certificate.
-#[allow(clippy::field_reassign_with_default)] // https://github.com/rust-lang/rust-clippy/issues/6527
 fn configure_server() -> Result<(ServerConfig, Vec<u8>), Box<dyn Error>> {
     let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
     let cert_der = cert.serialize_der().unwrap();
@@ -58,9 +72,10 @@ fn configure_server() -> Result<(ServerConfig, Vec<u8>), Box<dyn Error>> {
     let cert_chain = vec![rustls::Certificate(cert_der.clone())];
 
     let mut server_config = ServerConfig::with_single_cert(cert_chain, priv_key)?;
-    Arc::get_mut(&mut server_config.transport)
-        .unwrap()
-        .max_concurrent_uni_streams(0_u8.into());
+    let transport_config = Arc::get_mut(&mut server_config.transport).unwrap();
+    transport_config.max_concurrent_uni_streams(0_u8.into());
+    #[cfg(any(windows, os = "linux"))]
+    transport_config.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
 
     Ok((server_config, cert_der))
 }

quinn/examples/insecure_connection.rs

@@ -31,7 +31,8 @@ async fn run_server(addr: SocketAddr) {
 }
 
 async fn run_client(server_addr: SocketAddr) -> Result<(), Box<dyn Error>> {
-    let client_cfg = configure_client();
+    let mut client_cfg = configure_client();
+    common::enable_plpmtud_if_supported(&mut client_cfg);
     let mut endpoint = Endpoint::client("127.0.0.1:0".parse().unwrap())?;
     endpoint.set_default_client_config(client_cfg);
 

quinn/examples/server.rs

@@ -131,9 +131,10 @@ async fn run(options: Opt) -> Result<()> {
     }
 
     let mut server_config = quinn::ServerConfig::with_crypto(Arc::new(server_crypto));
-    Arc::get_mut(&mut server_config.transport)
-        .unwrap()
-        .max_concurrent_uni_streams(0_u8.into());
+    let transport_config = Arc::get_mut(&mut server_config.transport).unwrap();
+    transport_config.max_concurrent_uni_streams(0_u8.into());
+    #[cfg(any(windows, os = "linux"))]
+    transport_config.plpmtud_config(Some(quinn::PlpmtudConfig::default()));
     if options.stateless_retry {
         server_config.use_retry(true);
     }

quinn/src/lib.rs

@@ -60,8 +60,8 @@ mod work_limiter;
 
 pub use proto::{
     congestion, crypto, ApplicationClose, Chunk, ClientConfig, ConfigError, ConnectError,
-    ConnectionClose, ConnectionError, EndpointConfig, IdleTimeout, ServerConfig, StreamId,
-    Transmit, TransportConfig, VarInt,
+    ConnectionClose, ConnectionError, EndpointConfig, IdleTimeout, PlpmtudConfig, ServerConfig,
+    StreamId, Transmit, TransportConfig, VarInt,
 };
 pub use udp;