fortanix · Taowyoo · Jan 9, 2025 · Jan 9, 2025
diff --git a/mbedtls/tests/client_server.rs b/mbedtls/tests/client_server.rs
@@ -252,7 +252,7 @@ where
 
 #[cfg(unix)]
 mod test {
-    use std::thread;
+    use crate::support::thread_spawn_named;
 
     #[test]
     fn client_server_test() {
@@ -348,17 +348,25 @@ mod test {
             // TLS tests using certificates
 
             let (c, s) = crate::support::net::create_tcp_pair().unwrap();
-            let c = thread::spawn(move || super::client(c, min_c, max_c, exp_ver, false).unwrap());
-            let s = thread::spawn(move || super::server(s, min_s, max_s, exp_ver, false).unwrap());
+            let c = thread_spawn_named("client_tls_cert", move || {
+                super::client(c, min_c, max_c, exp_ver, false).unwrap()
+            });
+            let s = thread_spawn_named("server_tls_cert", move || {
+                super::server(s, min_s, max_s, exp_ver, false).unwrap()
+            });
 
             c.join().unwrap();
             s.join().unwrap();
 
             // TLS tests using PSK
 
             let (c, s) = crate::support::net::create_tcp_pair().unwrap();
-            let c = thread::spawn(move || super::client(c, min_c, max_c, exp_ver, true).unwrap());
-            let s = thread::spawn(move || super::server(s, min_s, max_s, exp_ver, true).unwrap());
+            let c = thread_spawn_named("client_tls_psk", move || {
+                super::client(c, min_c, max_c, exp_ver, true).unwrap()
+            });
+            let s = thread_spawn_named("server_tls_psk", move || {
+                super::server(s, min_s, max_s, exp_ver, true).unwrap()
+            });
 
             c.join().unwrap();
             s.join().unwrap();
@@ -372,10 +380,14 @@ mod test {
 
             let s = UdpSocket::bind("127.0.0.1:12340").expect("could not bind UdpSocket");
             let s = ConnectedUdpSocket::connect(s, "127.0.0.1:12341").expect("could not connect UdpSocket");
-            let s = thread::spawn(move || super::server(s, min_s, max_s, exp_ver, false).unwrap());
+            let s = thread_spawn_named("server_dtls_cert", move || {
+                super::server(s, min_s, max_s, exp_ver, false).unwrap()
+            });
             let c = UdpSocket::bind("127.0.0.1:12341").expect("could not bind UdpSocket");
             let c = ConnectedUdpSocket::connect(c, "127.0.0.1:12340").expect("could not connect UdpSocket");
-            let c = thread::spawn(move || super::client(c, min_c, max_c, exp_ver, false).unwrap());
+            let c = thread_spawn_named("client_dtls_cert", move || {
+                super::client(c, min_c, max_c, exp_ver, false).unwrap()
+            });
 
             s.join().unwrap();
             c.join().unwrap();
@@ -389,10 +401,14 @@ mod test {
 
             let s = UdpSocket::bind("127.0.0.1:12340").expect("could not bind UdpSocket");
             let s = ConnectedUdpSocket::connect(s, "127.0.0.1:12341").expect("could not connect UdpSocket");
-            let s = thread::spawn(move || super::server(s, min_s, max_s, exp_ver, true).unwrap());
+            let s = thread_spawn_named("client_dtls_psk", move || {
+                super::server(s, min_s, max_s, exp_ver, true).unwrap()
+            });
             let c = UdpSocket::bind("127.0.0.1:12341").expect("could not bind UdpSocket");
             let c = ConnectedUdpSocket::connect(c, "127.0.0.1:12340").expect("could not connect UdpSocket");
-            let c = thread::spawn(move || super::client(c, min_c, max_c, exp_ver, true).unwrap());
+            let c = thread_spawn_named("client_dtls_psk", move || {
+                super::client(c, min_c, max_c, exp_ver, true).unwrap()
+            });
 
             s.join().unwrap();
             c.join().unwrap();
@@ -411,14 +427,14 @@ mod test {
         let data_to_write = expected_data.clone();
         assert_eq!(expected_data, data_to_write);
         let (c, s) = crate::support::net::create_tcp_pair().unwrap();
-        let c = thread::spawn(move || {
+        let c = thread_spawn_named("client", move || {
             super::with_client(c, move |mut session| {
                 let ret = session.write_all(&data_to_write);
                 assert!(ret.is_ok());
             })
         });
 
-        let s = thread::spawn(move || {
+        let s = thread_spawn_named("server", move || {
             super::with_server(s, move |mut session| {
                 let mut buf = vec![0; buffer_size];
                 match session.read_exact(&mut buf) {
@@ -450,7 +466,7 @@ mod test {
         let data_to_write = expected_data.clone();
         assert_eq!(expected_data, data_to_write);
         let (c, s) = crate::support::net::create_tcp_pair().unwrap();
-        let c = thread::spawn(move || {
+        let c = thread_spawn_named("client", move || {
             super::with_client(c, move |mut session| {
                 let ret = session.write_all(&data_to_write);
                 assert!(ret.is_err());
@@ -460,7 +476,7 @@ mod test {
             })
         });
 
-        let s = thread::spawn(move || {
+        let s = thread_spawn_named("server", move || {
             super::with_server(s, move |mut session| {
                 let mut buf = vec![0; buffer_size];
                 match session.read_exact(&mut buf) {

diff --git a/mbedtls/tests/hyper.rs b/mbedtls/tests/hyper.rs
@@ -9,6 +9,12 @@ use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+// needed to have common code for `mod support` in unit and integrations tests
+extern crate mbedtls;
+
+mod support;
+use support::thread_spawn_named;
+
 // Native TLS compatibility - to move to native tls client in the future
 #[derive(Clone)]
 pub struct TlsStream<T> {
@@ -254,12 +260,12 @@ mod tests {
 
         let clone1 = client.clone();
         let clone2 = client.clone();
-        let t1 = std::thread::spawn(move || {
+        let t1 = thread_spawn_named("client1", move || {
             let response = clone1.get("https://google.com").send().unwrap();
             assert_eq!(response.status, hyper::status::StatusCode::Ok);
         });
 
-        let t2 = std::thread::spawn(move || {
+        let t2 = thread_spawn_named("client2", move || {
             clone2.post("https://google.com").body("foo=bar").send().unwrap();
         });
 
@@ -353,12 +359,10 @@ mod tests {
         let client1 = client.clone();
 
         // If this fails due to EWOULDBLOCK it means not enough threads were created.
-        let t1 = std::thread::Builder::new()
-            .spawn(move || {
-                let response = client1.post(&format!("https://{}/path", local_addr)).body("foo=bar").send();
-                println!("{:?}", response);
-            })
-            .unwrap();
+        let t1 = thread_spawn_named("client", move || {
+            let response = client1.post(&format!("https://{}/path", local_addr)).body("foo=bar").send();
+            println!("{:?}", response);
+        });
 
         t1.join().unwrap();
         handler.close().unwrap();

diff --git a/mbedtls/tests/ssl_conf_ca_cb.rs b/mbedtls/tests/ssl_conf_ca_cb.rs
@@ -59,8 +59,8 @@ mod test {
     use super::*;
     use crate::support::keys;
     use crate::support::net::create_tcp_pair;
+    use crate::support::thread_spawn_named;
     use mbedtls::error::codes;
-    use std::thread;
 
     // This callback should accept any valid self-signed certificate
     fn self_signed_ca_callback(child: &MbedtlsList<Certificate>) -> TlsResult<MbedtlsList<Certificate>> {
@@ -74,8 +74,10 @@ mod test {
         let ca_callback = |_: &MbedtlsList<Certificate>| -> TlsResult<MbedtlsList<Certificate>> {
             Ok(Certificate::from_pem_multiple(keys::ROOT_CA_CERT.as_bytes()).unwrap())
         };
-        let c = thread::spawn(move || super::client(c, ca_callback).unwrap());
-        let s = thread::spawn(move || super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap());
+        let c = thread_spawn_named("client", move || super::client(c, ca_callback).unwrap());
+        let s = thread_spawn_named("server", move || {
+            super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap()
+        });
         c.join().unwrap();
         s.join().unwrap();
     }
@@ -85,20 +87,24 @@ mod test {
         let (c, s) = create_tcp_pair().unwrap();
         let ca_callback =
             |_: &MbedtlsList<Certificate>| -> TlsResult<MbedtlsList<Certificate>> { Ok(MbedtlsList::<Certificate>::new()) };
-        let c = thread::spawn(move || {
+        let c = thread_spawn_named("client", move || {
             let result = super::client(c, ca_callback);
             assert_eq!(result, Err(codes::X509CertVerifyFailed.into()));
         });
-        let s = thread::spawn(move || super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap());
+        let s = thread_spawn_named("server", move || {
+            super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap()
+        });
         c.join().unwrap();
         s.join().unwrap();
     }
 
     #[test]
     fn callback_self_signed() {
         let (c, s) = create_tcp_pair().unwrap();
-        let c = thread::spawn(move || super::client(c, self_signed_ca_callback).unwrap());
-        let s = thread::spawn(move || super::server(s, keys::PEM_SELF_SIGNED_CERT, keys::PEM_SELF_SIGNED_KEY).unwrap());
+        let c = thread_spawn_named("client", move || super::client(c, self_signed_ca_callback).unwrap());
+        let s = thread_spawn_named("server", move || {
+            super::server(s, keys::PEM_SELF_SIGNED_CERT, keys::PEM_SELF_SIGNED_KEY).unwrap()
+        });
         c.join().unwrap();
         s.join().unwrap();
     }
@@ -109,11 +115,13 @@ mod test {
         // be rejected by the client, because the ca_callback should only accept
         // self-signed certificates.
         let (c, s) = create_tcp_pair().unwrap();
-        let c = thread::spawn(move || {
+        let c = thread_spawn_named("client", move || {
             let result = super::client(c, self_signed_ca_callback);
             assert_eq!(result, Err(codes::X509CertVerifyFailed.into()));
         });
-        let s = thread::spawn(move || super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap());
+        let s = thread_spawn_named("server", move || {
+            super::server(s, keys::PEM_CERT.as_bytes(), keys::PEM_KEY.as_bytes()).unwrap()
+        });
         c.join().unwrap();
         s.join().unwrap();
     }
@@ -123,12 +131,13 @@ mod test {
         // We set up the server to supply a self-signed certificate with an invalid
         // signature. It should be rejected by the client.
         let (c, s) = create_tcp_pair().unwrap();
-        let c = thread::spawn(move || {
+        let c = thread_spawn_named("client", move || {
             let result = super::client(c, self_signed_ca_callback);
             assert_eq!(result, Err(codes::X509CertVerifyFailed.into()));
         });
-        let s =
-            thread::spawn(move || super::server(s, keys::PEM_SELF_SIGNED_CERT_INVALID_SIG, keys::PEM_SELF_SIGNED_KEY).unwrap());
+        let s = thread_spawn_named("server", move || {
+            super::server(s, keys::PEM_SELF_SIGNED_CERT_INVALID_SIG, keys::PEM_SELF_SIGNED_KEY).unwrap()
+        });
         c.join().unwrap();
         s.join().unwrap();
     }

diff --git a/mbedtls/tests/ssl_conf_verify.rs b/mbedtls/tests/ssl_conf_verify.rs
@@ -83,14 +83,16 @@ fn server(conn: TcpStream) -> TlsResult<()> {
 #[cfg(unix)]
 mod test {
     use crate::support::net::create_tcp_pair;
-    use std::thread;
+    use crate::support::thread_spawn_named;
 
     #[test]
     fn callback_set_verify_flags() {
         let (c, s) = create_tcp_pair().unwrap();
 
-        let c = thread::spawn(move || super::client(c, super::Test::CallbackSetVerifyFlags).unwrap());
-        let s = thread::spawn(move || super::server(s).unwrap());
+        let c = thread_spawn_named("client", move || {
+            super::client(c, super::Test::CallbackSetVerifyFlags).unwrap()
+        });
+        let s = thread_spawn_named("server", move || super::server(s).unwrap());
         c.join().unwrap();
         s.join().unwrap();
     }
@@ -99,8 +101,8 @@ mod test {
     fn callback_error() {
         let (c, s) = create_tcp_pair().unwrap();
 
-        let c = thread::spawn(move || super::client(c, super::Test::CallbackError).unwrap());
-        let s = thread::spawn(move || super::server(s).unwrap());
+        let c = thread_spawn_named("client", move || super::client(c, super::Test::CallbackError).unwrap());
+        let s = thread_spawn_named("server", move || super::server(s).unwrap());
         c.join().unwrap();
         s.join().unwrap();
     }

diff --git a/mbedtls/tests/support/mod.rs b/mbedtls/tests/support/mod.rs
@@ -7,6 +7,7 @@
  * according to those terms. */
 
 #![allow(dead_code)]
+
 #[cfg(all(feature = "std", feature = "async"))]
 pub mod custom_write_all;
 pub mod entropy;
@@ -15,3 +16,15 @@ pub mod keys;
 #[cfg(sys_std_component = "net")]
 pub mod net;
 pub mod rand;
+
+#[cfg(feature = "std")]
+use std::thread::{Builder, JoinHandle};
+#[cfg(feature = "std")]
+pub fn thread_spawn_named<F, T, S>(name: S, f: F) -> JoinHandle<T>
+where
+    F: FnOnce() -> T + Send + 'static,
+    T: Send + 'static,
+    S: Into<String>,
+{
+    Builder::new().name(name.into()).spawn(f).unwrap()
+}