From c6df99534b35c08e2c0f18f581696df95b93f663 Mon Sep 17 00:00:00 2001
From: Traian <53470229+ImperiaL-24@users.noreply.github.com>
Date: Sun, 10 Nov 2024 15:03:58 +0200
Subject: [PATCH 1/2] fix(http1): is_timeout works on HeaderTimeout

---
 src/error.rs    | 10 ++++++++++
 tests/server.rs | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/error.rs b/src/error.rs
index 9ad4c0e5b3..98ea7a779c 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -240,6 +240,16 @@ impl Error {
 
     /// Returns true if the error was caused by a timeout.
     pub fn is_timeout(&self) -> bool {
+        #[cfg(any(
+            all(feature = "http1", feature = "server"),
+            feature = "ffi"
+        ))]
+        return matches!(self.inner.kind, Kind::HeaderTimeout) || self.find_source::<TimedOut>().is_some();
+
+        #[cfg(not(any(
+            all(feature = "http1", feature = "server"),
+            feature = "ffi"
+        )))]
         self.find_source::<TimedOut>().is_some()
     }
 
diff --git a/tests/server.rs b/tests/server.rs
index f72cf62702..e2a32fe4b6 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -2861,6 +2861,39 @@ fn http1_trailer_recv_fields() {
     );
 }
 
+#[tokio::test]
+async fn timeout_err() {
+    let (listener, addr) = setup_tcp_listener();
+
+    let j = tokio::spawn(async move {
+        let (socket, _) = listener.accept().await.expect("accept");
+        let socket = TokioIo::new(socket);
+
+        if let Err(e) = http1::Builder::new()
+            .timer(TokioTimer)
+            .header_read_timeout(Duration::from_secs(1))
+            .serve_connection(socket, HelloWorld)
+            .await {
+                Some(e.is_timeout())
+            } else {
+                None
+            }
+    });
+
+    let tcp = TokioIo::new(connect_async(addr).await);
+    let (_client, conn) = hyper::client::conn::http1::Builder::new()
+        .handshake::<_,Empty<Bytes>>(tcp)
+        .await
+        .expect("http handshake");
+
+    tokio::spawn(async move {
+        conn.await.expect_err("client conn fail");
+    });
+
+    TokioTimer.sleep(Duration::from_secs(2)).await;
+    assert_eq!(j.await.unwrap(), Some(true));
+}
+
 // -------------------------------------------------
 // the Server that is used to run all the tests with
 // -------------------------------------------------

From 87d456dc8e64599db2f7a59da790baade032f7a4 Mon Sep 17 00:00:00 2001
From: Traian <53470229+ImperiaL-24@users.noreply.github.com>
Date: Mon, 18 Nov 2024 19:15:51 +0200
Subject: [PATCH 2/2] refactor(http1): fixed style error

---
 src/error.rs    | 13 ++++---------
 tests/server.rs | 15 ++++++++-------
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/src/error.rs b/src/error.rs
index 98ea7a779c..cd2c8c2da3 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -240,16 +240,11 @@ impl Error {
 
     /// Returns true if the error was caused by a timeout.
     pub fn is_timeout(&self) -> bool {
-        #[cfg(any(
-            all(feature = "http1", feature = "server"),
-            feature = "ffi"
-        ))]
-        return matches!(self.inner.kind, Kind::HeaderTimeout) || self.find_source::<TimedOut>().is_some();
+        #[cfg(any(all(feature = "http1", feature = "server"), feature = "ffi"))]
+        return matches!(self.inner.kind, Kind::HeaderTimeout)
+            || self.find_source::<TimedOut>().is_some();
 
-        #[cfg(not(any(
-            all(feature = "http1", feature = "server"),
-            feature = "ffi"
-        )))]
+        #[cfg(not(any(all(feature = "http1", feature = "server"), feature = "ffi")))]
         self.find_source::<TimedOut>().is_some()
     }
 
diff --git a/tests/server.rs b/tests/server.rs
index e2a32fe4b6..b83a1ad41f 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -2862,7 +2862,7 @@ fn http1_trailer_recv_fields() {
 }
 
 #[tokio::test]
-async fn timeout_err() {
+async fn http1_timeout_error() {
     let (listener, addr) = setup_tcp_listener();
 
     let j = tokio::spawn(async move {
@@ -2873,16 +2873,17 @@ async fn timeout_err() {
             .timer(TokioTimer)
             .header_read_timeout(Duration::from_secs(1))
             .serve_connection(socket, HelloWorld)
-            .await {
-                Some(e.is_timeout())
-            } else {
-                None
-            }
+            .await
+        {
+            Some(e.is_timeout())
+        } else {
+            None
+        }
     });
 
     let tcp = TokioIo::new(connect_async(addr).await);
     let (_client, conn) = hyper::client::conn::http1::Builder::new()
-        .handshake::<_,Empty<Bytes>>(tcp)
+        .handshake::<_, Empty<Bytes>>(tcp)
         .await
         .expect("http handshake");