fix: preserve transporterror knowledge

Author: dignifiedquire

quinn-proto/src/connection/mod.rs

@@ -1211,7 +1211,8 @@ impl Connection {
                     let max_frame_size = builder.frame_space_remaining();
                     match self.state.as_type() {
                         StateType::Closed => {
-                            let reason = &self.state.as_closed().expect("checked");
+                            let reason: Close =
+                                self.state.as_closed().expect("checked").clone().into();
                             if space_id == SpaceId::Data || reason.is_transport_layer() {
                                 reason.encode(&mut builder.frame_space_mut(), max_frame_size)
                             } else {

quinn-proto/src/connection/state.rs

@@ -1,7 +1,9 @@
 use bytes::Bytes;
 
 use crate::frame::Close;
-use crate::{ConnectionError, TransportErrorCode};
+use crate::{
+    ApplicationClose, ConnectionClose, ConnectionError, TransportError, TransportErrorCode,
+};
 
 #[allow(unreachable_pub)] // fuzzing only
 #[derive(Debug, Clone)]
@@ -27,7 +29,7 @@ impl State {
         }
     }
 
-    pub(super) fn as_closed(&self) -> Option<&Close> {
+    pub(super) fn as_closed(&self) -> Option<&CloseReason> {
         if let InnerState::Closed {
             ref remote_reason, ..
         } = self.inner
@@ -118,7 +120,7 @@ impl State {
         }
     }
 
-    pub(super) fn move_to_closed<R: Into<Close>>(&mut self, reason: R) {
+    pub(super) fn move_to_closed<R: Into<CloseReason>>(&mut self, reason: R) {
         assert!(
             matches!(
                 self.inner,
@@ -134,7 +136,7 @@ impl State {
         };
     }
 
-    pub(super) fn move_to_closed_local<R: Into<Close>>(&mut self, reason: R) {
+    pub(super) fn move_to_closed_local<R: Into<CloseReason>>(&mut self, reason: R) {
         assert!(
             matches!(
                 self.inner,
@@ -225,13 +227,65 @@ pub(super) enum StateType {
     Drained,
 }
 
+#[derive(Debug, Clone)]
+pub(super) enum CloseReason {
+    TransportError(TransportError),
+    Connection(ConnectionClose),
+    Application(ApplicationClose),
+}
+
+impl From<TransportError> for CloseReason {
+    fn from(x: TransportError) -> Self {
+        Self::TransportError(x)
+    }
+}
+impl From<ConnectionClose> for CloseReason {
+    fn from(x: ConnectionClose) -> Self {
+        Self::Connection(x)
+    }
+}
+impl From<ApplicationClose> for CloseReason {
+    fn from(x: ApplicationClose) -> Self {
+        Self::Application(x)
+    }
+}
+
+impl From<Close> for CloseReason {
+    fn from(value: Close) -> Self {
+        match value {
+            Close::Application(reason) => Self::Application(reason),
+            Close::Connection(reason) => Self::Connection(reason),
+        }
+    }
+}
+
+impl From<CloseReason> for ConnectionError {
+    fn from(value: CloseReason) -> Self {
+        match value {
+            CloseReason::TransportError(err) => Self::TransportError(err),
+            CloseReason::Connection(reason) => Self::ConnectionClosed(reason),
+            CloseReason::Application(reason) => Self::ApplicationClosed(reason),
+        }
+    }
+}
+
+impl From<CloseReason> for Close {
+    fn from(value: CloseReason) -> Self {
+        match value {
+            CloseReason::TransportError(err) => Self::Connection(err.into()),
+            CloseReason::Connection(reason) => Self::Connection(reason),
+            CloseReason::Application(reason) => Self::Application(reason),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 enum InnerState {
     Handshake(Handshake),
     Established,
     Closed {
         /// The reason the remote closed the connection, or the reason we are sending to the remote.
-        remote_reason: Close,
+        remote_reason: CloseReason,
         /// Set to true if we closed the connection locally
         is_local: bool,
         /// Did we read this as error already?

quinn-proto/src/tests/mod.rs

@@ -438,11 +438,9 @@ fn reject_self_signed_server_cert() {
 
     pair.drive();
 
-    assert_matches!(
-        pair.client_conn_mut(client_ch).poll(),
-        Some(Event::ConnectionLost { reason: ConnectionError::ConnectionClosed(ref reason)})
-        if reason.error_code == TransportErrorCode::crypto(AlertDescription::UnknownCA.into())
-    );
+    assert_matches!(pair.client_conn_mut(client_ch).poll(),
+                    Some(Event::ConnectionLost { reason: ConnectionError::TransportError(ref error)})
+                    if error.code == TransportErrorCode::crypto(AlertDescription::UnknownCA.into()));
 }
 
 #[test]
@@ -499,8 +497,8 @@ fn reject_missing_client_cert() {
         Some(Event::HandshakeDataReady)
     );
     assert_matches!(pair.server_conn_mut(server_ch).poll(),
-                    Some(Event::ConnectionLost { reason: ConnectionError::ConnectionClosed(ref close)})
-                    if close.error_code == TransportErrorCode::crypto(AlertDescription::CertificateRequired.into()));
+                    Some(Event::ConnectionLost { reason: ConnectionError::TransportError(ref error)})
+                    if error.code == TransportErrorCode::crypto(AlertDescription::CertificateRequired.into()));
 }
 
 #[test]