feat(quinn-proto): export min_initial_size

Signed-off-by: loongtao.zhang <[email protected]>

Author: cathaysia

quinn-proto/src/config/mod.rs

@@ -18,8 +18,9 @@ use crate::NoneTokenLog;
 #[cfg(any(feature = "rustls-aws-lc-rs", feature = "rustls-ring"))]
 use crate::crypto::rustls::{QuicServerConfig, configured_provider};
 use crate::{
-    DEFAULT_SUPPORTED_VERSIONS, Duration, MAX_CID_SIZE, RandomConnectionIdGenerator, SystemTime,
-    TokenLog, TokenMemoryCache, TokenStore, VarInt, VarIntBoundsExceeded,
+    DEFAULT_SUPPORTED_VERSIONS, Duration, MAX_CID_SIZE, MIN_INITIAL_SIZE,
+    RandomConnectionIdGenerator, SystemTime, TokenLog, TokenMemoryCache, TokenStore, VarInt,
+    VarIntBoundsExceeded,
     cid_generator::{ConnectionIdGenerator, HashedConnectionIdGenerator},
     crypto::{self, HandshakeTokenKey, HmacKey},
     shared::ConnectionId,
@@ -48,6 +49,7 @@ pub struct EndpointConfig {
     pub(crate) min_reset_interval: Duration,
     /// Optional seed to be used internally for random number generation
     pub(crate) rng_seed: Option<[u8; 32]>,
+    pub(crate) min_initial_size: u16,
 }
 
 impl EndpointConfig {
@@ -63,6 +65,7 @@ impl EndpointConfig {
             grease_quic_bit: true,
             min_reset_interval: Duration::from_millis(20),
             rng_seed: None,
+            min_initial_size: MIN_INITIAL_SIZE,
         }
     }
 
@@ -159,6 +162,51 @@ impl EndpointConfig {
         self.rng_seed = seed;
         self
     }
+
+    /// Sets the minimum size of the very first Initial flight (handshake packets).
+    ///
+    /// If the first Initial packet is smaller than this value, Quinn will pad it
+    /// up to this size.
+    ///
+    /// <div class="warning">
+    ///
+    /// According to the QUIC specification (RFC 9000), the Initial packet MUST be
+    /// at least **1200 bytes**. Setting this value lower than 1200 can make the
+    /// connection fail when communicating with other QUIC implementations.
+    ///
+    /// Setting this value too large may cause the Initial packet to exceed the
+    /// path MTU, resulting in **handshake failure due to fragmentation loss**.
+    ///
+    /// </div>
+    ///
+    /// ## Safety
+    ///
+    /// Only use this when:
+    /// - You fully control **both endpoints**, and
+    /// - You know the **actual path MTU**, and intentionally violate QUIC
+    ///   interoperability requirements.
+    ///
+    /// ## Relationship to [`TransportConfig::min_mtu`]
+    ///
+    /// - `min_initial_size` affects **only the Initial flight** (handshake packets).
+    ///   It does *not* influence MTU probing or later packet sizes.
+    ///
+    /// - `TransportConfig::min_mtu` defines the **minimum allowed MTU** for normal
+    ///   data transmission **after the handshake**. It participates in MTU
+    ///   discovery (PMTUD/PLPMTUD) and controls how aggressively Quinn may lower MTU.
+    ///
+    /// | Setting                          | Affects                     | Used for                        |
+    /// |----------------------------------|-----------------------------|----------------------------------|
+    /// | `min_initial_size` (this fn)     | Initial packets only        | Faster handshake / experiments   |
+    /// | `TransportConfig::min_mtu`       | Packets after handshake     | MTU discovery & connection stability |
+    ///
+    /// Do **not** confuse the two:
+    /// `min_initial_size` increases handshake packet size,
+    /// while `min_mtu` constrains runtime MTU lowering.
+    pub unsafe fn min_initial_size(&mut self, value: u16) -> &mut Self {
+        self.min_initial_size = value;
+        self
+    }
 }
 
 impl fmt::Debug for EndpointConfig {

quinn-proto/src/connection/mod.rs

@@ -16,8 +16,8 @@ use tracing::{debug, error, trace, trace_span, warn};
 
 use crate::{
     Dir, Duration, EndpointConfig, Frame, INITIAL_MTU, Instant, MAX_CID_SIZE, MAX_STREAM_COUNT,
-    MIN_INITIAL_SIZE, Side, StreamId, TIMER_GRANULARITY, TokenStore, Transmit, TransportError,
-    TransportErrorCode, VarInt,
+    Side, StreamId, TIMER_GRANULARITY, TokenStore, Transmit, TransportError, TransportErrorCode,
+    VarInt,
     cid_generator::ConnectionIdGenerator,
     cid_queue::CidQueue,
     coding::BufMutExt,
@@ -634,7 +634,7 @@ impl Connection {
                 // Finish current packet
                 if let Some(mut builder) = builder_storage.take() {
                     if pad_datagram {
-                        builder.pad_to(MIN_INITIAL_SIZE);
+                        builder.pad_to(self.endpoint_config.min_initial_size);
                     }
 
                     if num_datagrams > 1 || pad_datagram_to_mtu {
@@ -857,7 +857,7 @@ impl Connection {
                     buf.write(frame::FrameType::PATH_RESPONSE);
                     buf.write(token);
                     self.stats.frame_tx.path_response += 1;
-                    builder.pad_to(MIN_INITIAL_SIZE);
+                    builder.pad_to(self.endpoint_config.min_initial_size);
                     builder.finish_and_track(
                         now,
                         self,
@@ -912,7 +912,7 @@ impl Connection {
         // Finish the last packet
         if let Some(mut builder) = builder_storage {
             if pad_datagram {
-                builder.pad_to(MIN_INITIAL_SIZE);
+                builder.pad_to(self.endpoint_config.min_initial_size);
             }
 
             // If this datagram is a loss probe and `segment_size` is larger than `INITIAL_MTU`,
@@ -1026,7 +1026,7 @@ impl Connection {
             SpaceId::Data,
             "PATH_CHALLENGE queued without 1-RTT keys"
         );
-        buf.reserve(MIN_INITIAL_SIZE as usize);
+        buf.reserve(self.endpoint_config.min_initial_size as usize);
 
         let buf_capacity = buf.capacity();
 
@@ -1054,7 +1054,7 @@ impl Connection {
         // to at least the smallest allowed maximum datagram size of 1200 bytes,
         // unless the anti-amplification limit for the path does not permit
         // sending a datagram of this size
-        builder.pad_to(MIN_INITIAL_SIZE);
+        builder.pad_to(self.endpoint_config.min_initial_size);
 
         builder.finish(self, now, buf);
         self.stats.udp_tx.on_sent(1, buf.len());

quinn-proto/src/endpoint.rs

@@ -15,8 +15,8 @@ use thiserror::Error;
 use tracing::{debug, error, trace, warn};
 
 use crate::{
-    Duration, INITIAL_MTU, Instant, MAX_CID_SIZE, MIN_INITIAL_SIZE, RESET_TOKEN_SIZE, ResetToken,
-    Side, Transmit, TransportConfig, TransportError,
+    Duration, INITIAL_MTU, Instant, MAX_CID_SIZE, RESET_TOKEN_SIZE, ResetToken, Side, Transmit,
+    TransportConfig, TransportError,
     cid_generator::ConnectionIdGenerator,
     coding::BufMutExt,
     config::{ClientConfig, EndpointConfig, ServerConfig},
@@ -430,7 +430,7 @@ impl Endpoint {
                 .map(DatagramEvent::Response);
         };
 
-        if datagram_len < MIN_INITIAL_SIZE as usize {
+        if datagram_len < self.config.min_initial_size as usize {
             debug!("ignoring short initial for connection {}", dst_cid);
             return None;
         }