cleanup

Author: toidiu

h3i/src/client/async_client.rs

@@ -80,12 +80,8 @@ pub async fn connect(
     close_trigger_frames: Option<CloseTriggerFrames>,
 ) -> std::result::Result<BuildingConnectionSummary, ClientError> {
     let quic_settings = create_config(args);
-    let mut connection_params = ConnectionParams::new_client(
-        quic_settings,
-        None,
-        Hooks::default(),
-        false,
-    );
+    let mut connection_params =
+        ConnectionParams::new_client(quic_settings, None, Hooks::default());
 
     connection_params.session = args.session.clone();
 
@@ -431,9 +427,9 @@ impl ApplicationOverQuic for H3iDriver {
         &mut self, qconn: &mut QuicheConnection, _metrics: &M,
         _work_loop_result: &QuicResult<()>,
     ) {
-        let _ = self.record_tx.send(ConnectionRecord::Close(
-            ConnectionCloseDetails::new(qconn, false),
-        ));
+        let _ = self
+            .record_tx
+            .send(ConnectionRecord::Close(ConnectionCloseDetails::new(qconn)));
 
         let _ = self
             .record_tx

h3i/src/client/connection_summary.rs

@@ -394,8 +394,6 @@ pub struct ConnectionCloseDetails {
     pub timed_out: bool,
     /// Return the session from the underlying connection.
     pub session: Option<Vec<u8>>,
-    /// Early data was sent by the client.
-    pub early_data_sent: bool,
 }
 
 impl core::fmt::Debug for ConnectionCloseDetails {
@@ -410,14 +408,13 @@ impl core::fmt::Debug for ConnectionCloseDetails {
 }
 
 impl ConnectionCloseDetails {
-    pub fn new(qconn: &Connection, early_data_sent: bool) -> Self {
+    pub fn new(qconn: &Connection) -> Self {
         let session = qconn.session().map(|s| s.to_vec());
         Self {
             peer_error: qconn.peer_error().cloned(),
             local_error: qconn.local_error().cloned(),
             timed_out: qconn.is_timed_out(),
             session,
-            early_data_sent,
         }
     }
 

h3i/src/client/sync_client.rs

@@ -208,8 +208,10 @@ pub fn connect(
     let (write, send_info) = conn.send(&mut out).expect("initial send failed");
 
     let mut client = SyncClient::new(close_trigger_frames);
-    let early_data_sent = match early_actions {
-        Some(early_actions) if conn.is_in_early_data() => {
+    // Send early data if connection is_in_early_data (resumption with 0-RTT was
+    // successful) and if we have early_actions.
+    if conn.is_in_early_data() {
+        if let Some(early_actions) = early_actions {
             let mut early_action_iter = early_actions.iter();
             let mut wait_duration = None;
             let mut wait_instant = None;
@@ -223,10 +225,8 @@ pub fn connect(
                 &mut waiting_for,
                 client.stream_parsers_mut(),
             );
-            true
-        },
-        _ => false,
-    };
+        }
+    }
 
     while let Err(e) = socket.send_to(&out[..write], send_info.to) {
         if e.kind() == std::io::ErrorKind::WouldBlock {
@@ -478,7 +478,7 @@ pub fn connect(
         stream_map: client.streams,
         stats: Some(conn.stats()),
         path_stats: conn.path_stats().collect(),
-        conn_close_details: ConnectionCloseDetails::new(&conn, early_data_sent),
+        conn_close_details: ConnectionCloseDetails::new(&conn),
     })
 }
 

quiche/src/lib.rs

@@ -7129,55 +7129,14 @@ impl<F: BufFactory> Connection<F> {
         self.handshake.is_in_early_data()
     }
 
-    // #[rustfmt::skip]
-    /// https://commondatastorage.googleapis.com/chromium-boringssl-docs/ssl.h.html#ssl_early_data_reason_t
+    /// Returns the early data reason for the connection.
     ///
-    /// // The handshake has not progressed far enough for the 0-RTT status to
-    /// // be known.
-    /// ssl_early_data_unknown = 0,
+    /// This status can be useful for logging and debugging. See [BoringSSL]
+    /// documentation for a definition of the reasons.
     ///
-    /// // 0-RTT is disabled for this connection.
-    /// ssl_early_data_disabled = 1,
-    ///
-    /// // 0-RTT was accepted.
-    /// ssl_early_data_accepted = 2,
-    ///
-    /// // The negotiated protocol version does not support 0-RTT.
-    /// ssl_early_data_protocol_version = 3,
-    ///
-    /// // The peer declined to offer or accept 0-RTT for an unknown reason.
-    /// ssl_early_data_peer_declined = 4,
-    ///
-    /// // The client did not offer a session.
-    /// ssl_early_data_no_session_offered = 5,
-    ///
-    /// // The server declined to resume the session.
-    /// ssl_early_data_session_not_resumed = 6,
-    ///
-    /// // The session does not support 0-RTT.
-    /// ssl_early_data_unsupported_for_session = 7,
-    ///
-    /// // The server sent a HelloRetryRequest.
-    /// ssl_early_data_hello_retry_request = 8,
-    ///
-    /// // The negotiated ALPN protocol did not match the session.
-    /// ssl_early_data_alpn_mismatch = 9,
-    ///
-    /// // The connection negotiated Channel ID, which is incompatible with
-    /// // 0-RTT.
-    /// ssl_early_data_channel_id = 10,
-    ///
-    /// // Value 11 is reserved. (It has historically
-    /// |ssl_early_data_token_binding|.) // The client and server ticket age
-    /// were too far apart. ssl_early_data_ticket_age_skew = 12,
-    ///
-    /// // QUIC parameters differ between this connection and the original.
-    /// ssl_early_data_quic_parameter_mismatch = 13,
-    ///
-    /// // The application settings did not match the session.
-    /// ssl_early_data_alps_mismatch = 14,
+    /// [BoringSSL]: https://commondatastorage.googleapis.com/chromium-boringssl-docs/ssl.h.html#ssl_early_data_reason_t
     #[inline]
-    pub fn get_early_data_reason(&self) -> u32 {
+    pub fn early_data_reason(&self) -> u32 {
         self.handshake.early_reason()
     }
 

quiche/src/tls/boringssl.rs

@@ -276,7 +276,6 @@ impl Handshake {
     }
 
     pub fn early_reason(&self) -> u32 {
-        // unsafe { SSL_in_early_data(self.as_ptr()) == 1 }
         let reuse_reason_status =
             unsafe { SSL_get_early_data_reason(self.as_ptr()) };
         reuse_reason_status.0
@@ -352,7 +351,6 @@ extern "C" {
 
     fn SSL_in_early_data(ssl: *const SSL) -> c_int;
 
-    // enum ssl_early_data_reason_t SSL_get_early_data_reason(const SSL *ssl);
     fn SSL_get_early_data_reason(ssl: *const SSL) -> ssl_early_data_reason_t;
 
     fn SSL_SESSION_to_bytes(

tokio-quiche/examples/async_http3_server/main.rs

@@ -67,7 +67,6 @@ async fn main() {
                 kind: CertificateKind::X509,
             },
             Hooks::default(),
-            false,
         ),
         SimpleConnectionIdGenerator,
         DefaultMetrics,

tokio-quiche/src/quic/io/connection_stage.rs

@@ -122,6 +122,8 @@ impl ConnectionStage for Handshake {
         &mut self, qconn: &mut QuicheConnection,
         _ctx: &mut ConnectionStageContext<A>,
     ) -> ControlFlow<QuicResult<()>> {
+        // Transition to RunningApplication if we have 1-RTT keys (handshake is
+        // complete) or if we have 0-RTT keys (in early data).
         if qconn.is_established() || qconn.is_in_early_data() {
             ControlFlow::Break(Ok(()))
         } else {

tokio-quiche/src/quic/router/mod.rs

@@ -891,7 +891,6 @@ mod tests {
             quic_settings,
             tls_cert_settings,
             Hooks::default(),
-            false,
         );
         let config = Config::new(&params, SocketCapabilities::default()).unwrap();
 

tokio-quiche/src/settings/config.rs

@@ -203,7 +203,7 @@ fn make_quiche_config(
             track_unknown_transport_params,
         );
     }
-    if params.enable_early_data {
+    if params.settings.enable_early_data {
         config.enable_early_data();
     }
 

tokio-quiche/src/settings/mod.rs

@@ -55,8 +55,6 @@ pub struct ConnectionParams<'a> {
     pub hooks: Hooks,
     /// Set the session to attempt resumption.
     pub session: Option<Vec<u8>>,
-    /// Enables early data.
-    pub enable_early_data: bool,
 }
 
 impl core::fmt::Debug for ConnectionParams<'_> {
@@ -76,14 +74,12 @@ impl<'a> ConnectionParams<'a> {
     #[inline]
     pub fn new_server(
         settings: QuicSettings, tls_cert: TlsCertificatePaths<'a>, hooks: Hooks,
-        enable_early_data: bool,
     ) -> Self {
         Self {
             settings,
             tls_cert: Some(tls_cert),
             hooks,
             session: None,
-            enable_early_data,
         }
     }
 
@@ -92,14 +88,13 @@ impl<'a> ConnectionParams<'a> {
     #[inline]
     pub fn new_client(
         settings: QuicSettings, tls_cert: Option<TlsCertificatePaths<'a>>,
-        hooks: Hooks, enable_early_data: bool,
+        hooks: Hooks,
     ) -> Self {
         Self {
             settings,
             tls_cert,
             hooks,
             session: None,
-            enable_early_data,
         }
     }
 }