reduce diff by a lot

Author: divagant-martian

quinn-proto/src/connection/mod.rs

@@ -4306,19 +4306,44 @@ impl Connection {
                         .get_mut(&path_id)
                         .expect("payload is processed only after the path becomes known");
 
-                    use paths::OnPathResponseReceived::*;
-                    match path.data.on_path_response_received(now, response.0, remote) {
-                        OnPath { was_open } => {
-                            use PathTimer::*;
-                            let qlog = self.qlog.with_time(now);
-
-                            self.timers
-                                .stop(Timer::PerPath(path_id, PathValidation), qlog.clone());
-                            self.timers
-                                .stop(Timer::PerPath(path_id, PathOpen), qlog.clone());
-                            if !was_open {
-                                self.events
-                                    .push_back(Event::Path(PathEvent::Opened { id: path_id }));
+                    match path.data.challenges_sent.get(&response.0) {
+                        // Response to an on-path PathChallenge
+                        Some(info) if info.remote == remote && path.data.remote == remote => {
+                            let sent_instant = info.sent_instant;
+                            // TODO(@divma): reset timers using the remaining off-path challenges
+                            self.timers.stop(
+                                Timer::PerPath(path_id, PathTimer::PathValidation),
+                                self.qlog.with_time(now),
+                            );
+                            self.timers.stop(
+                                Timer::PerPath(path_id, PathTimer::PathChallengeLost),
+                                self.qlog.with_time(now),
+                            );
+                            if !path.data.validated {
+                                trace!("new path validated");
+                            }
+                            self.timers.stop(
+                                Timer::PerPath(path_id, PathTimer::PathOpen),
+                                self.qlog.with_time(now),
+                            );
+                            // Clear any other on-path sent challenge.
+                            path.data
+                                .challenges_sent
+                                .retain(|_token, info| info.remote != remote);
+                            path.data.send_new_challenge = false;
+                            path.data.validated = true;
+
+                            // This RTT can only be used for the initial RTT, not as a normal
+                            // sample: https://www.rfc-editor.org/rfc/rfc9002#section-6.2.2-2.
+                            let rtt = now.saturating_duration_since(sent_instant);
+                            path.data.rtt.reset_initial_rtt(rtt);
+
+                            self.events
+                                .push_back(Event::Path(PathEvent::Opened { id: path_id }));
+                            // mark the path as open from the application perspective now that Opened
+                            // event has been queued
+                            if !std::mem::replace(&mut path.data.open, true) {
+                                trace!("path opened");
                                 if let Some(observed) = path.data.last_observed_addr_report.as_ref()
                                 {
                                     self.events.push_back(Event::Path(PathEvent::ObservedAddr {
@@ -4331,44 +4356,20 @@ impl Connection {
                                 prev.challenges_sent.clear();
                                 prev.send_new_challenge = false;
                             }
-
-                            match path.data.earliest_expiring_challenge() {
-                                Some(new_expire_time) => {
-                                    let expires = new_expire_time
-                                        + self.ack_frequency.max_ack_delay_for_pto();
-                                    self.timers.set(
-                                        Timer::PerPath(path_id, PathChallengeLost),
-                                        expires,
-                                        qlog,
-                                    )
-                                }
-                                None => self
-                                    .timers
-                                    .stop(Timer::PerPath(path_id, PathChallengeLost), qlog),
-                            }
                         }
-                        OffPath => {
+                        // Response to an off-path PathChallenge
+                        Some(info) if info.remote == remote => {
                             debug!("Response to off-path PathChallenge!");
-                            match path.data.earliest_expiring_challenge() {
-                                Some(new_expire_time) => {
-                                    let expires = new_expire_time
-                                        + self.ack_frequency.max_ack_delay_for_pto();
-                                    self.timers.set(
-                                        Timer::PerPath(path_id, PathTimer::PathChallengeLost),
-                                        expires,
-                                        self.qlog.with_time(now),
-                                    )
-                                }
-                                None => self.timers.stop(
-                                    Timer::PerPath(path_id, PathTimer::PathChallengeLost),
-                                    self.qlog.with_time(now),
-                                ),
-                            }
+                            path.data
+                                .challenges_sent
+                                .retain(|_token, info| info.remote != remote);
                         }
-                        Unknown => debug!(%response, "ignoring invalid PATH_RESPONSE"),
-                        Invalid { expected } => {
-                            debug!(%response, from=%remote, %expected, "ignoring invalid PATH_RESPONSE")
+                        // Response to a PathChallenge we recognize, but from an invalid remote
+                        Some(info) => {
+                            debug!(%response, from=%remote, expected=%info.remote, "ignoring invalid PATH_RESPONSE")
                         }
+                        // Response to an unknown PathChallenge
+                        None => debug!(%response, "ignoring invalid PATH_RESPONSE"),
                     }
                 }
                 Frame::MaxData(bytes) => {

quinn-proto/src/connection/paths.rs

@@ -375,64 +375,6 @@ impl PathData {
         }
     }
 
-    /// The earliest time at which a sent challenge is considered lost.
-    pub(super) fn earliest_expiring_challenge(&self) -> Option<Instant> {
-        if self.challenges_sent.is_empty() {
-            return None;
-        }
-        let pto = self.rtt.pto_base();
-        self.challenges_sent
-            .values()
-            .map(|info| info.sent_instant)
-            .min()
-            .map(|sent_instant| sent_instant + pto)
-    }
-
-    /// Handle a receiving a PATH_RESPONSE.
-    pub(super) fn on_path_response_received(
-        &mut self,
-        now: Instant,
-        token: u64,
-        remote: SocketAddr,
-    ) -> OnPathResponseReceived {
-        match self.challenges_sent.get(&token) {
-            // Response to an on-path PathChallenge
-            Some(info) if info.remote == remote && self.remote == remote => {
-                let sent_instant = info.sent_instant;
-                if !std::mem::replace(&mut self.validated, true) {
-                    trace!("new path validated");
-                }
-                // Clear any other on-path sent challenge.
-                self.challenges_sent
-                    .retain(|_token, info| info.remote != remote);
-
-                self.send_new_challenge = false;
-
-                // This RTT can only be used for the initial RTT, not as a normal
-                // sample: https://www.rfc-editor.org/rfc/rfc9002#section-6.2.2-2.
-                let rtt = now.saturating_duration_since(sent_instant);
-                self.rtt.reset_initial_rtt(rtt);
-
-                // mark the path as open from the application perspective now that Opened
-                // event has been queued
-                let was_open = std::mem::replace(&mut self.open, true);
-                OnPathResponseReceived::OnPath { was_open }
-            }
-            // Response to an off-path PathChallenge
-            Some(info) if info.remote == remote => {
-                self.challenges_sent
-                    .retain(|_token, info| info.remote != remote);
-                OnPathResponseReceived::OffPath
-            }
-            // Response to a PathChallenge we recognize, but from an invalid remote
-            Some(info) => OnPathResponseReceived::Invalid {
-                expected: info.remote,
-            },
-            // Response to an unknown PathChallenge
-            None => OnPathResponseReceived::Unknown,
-        }
-    }
-
     #[cfg(feature = "qlog")]
     pub(super) fn qlog_recovery_metrics(
         &mut self,
@@ -517,20 +459,6 @@ impl PathData {
     }
 }
 
-pub(super) enum OnPathResponseReceived {
-    /// This response validates the path on it's current remote address.
-    OnPath { was_open: bool },
-    /// This response is valid, but it's for a remote other than the path's current remote address.
-    OffPath,
-    /// The received token is unknown.
-    Unknown,
-    /// The response is invalid.
-    Invalid {
-        /// The remote that was expected for this token
-        expected: SocketAddr,
-    },
-}
-
 /// Congestion metrics as described in [`recovery_metrics_updated`].
 ///
 /// [`recovery_metrics_updated`]: https://datatracker.ietf.org/doc/html/draft-ietf-quic-qlog-quic-events.html#name-recovery_metrics_updated

quinn-proto/src/connection/qlog.rs

@@ -369,7 +369,6 @@ impl QlogSink {
 }
 
 /// A [`QlogSink`] with a `now` timestamp.
-#[derive(Clone)]
 pub(super) struct QlogSinkWithTime<'a> {
     #[cfg(feature = "qlog")]
     sink: &'a QlogSink,