From 4021b1692a8fda178e0c10ca3787aceef7523ce6 Mon Sep 17 00:00:00 2001
From: Adrian Cruceru <cruceruadrian@gmail.com>
Date: Fri, 11 Feb 2022 15:21:12 +0100
Subject: [PATCH] Remove bounds on establish, test that Send gets derived as
 needed

---
 mbedtls/src/ssl/context.rs | 64 +++++++++++++++++++++++++++++++++++---
 mbedtls/tests/hyper.rs     | 10 ++----
 2 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/mbedtls/src/ssl/context.rs b/mbedtls/src/ssl/context.rs
index 04a48a973..56d8178ad 100644
--- a/mbedtls/src/ssl/context.rs
+++ b/mbedtls/src/ssl/context.rs
@@ -37,7 +37,7 @@ pub trait IoCallback {
     fn data_ptr(&mut self) -> *mut c_void;
 }
 
-impl<IO: Read + Write + 'static> IoCallback for IO {
+impl<IO: Read + Write> IoCallback for IO {
     unsafe extern "C" fn call_recv(user_data: *mut c_void, data: *mut c_uchar, len: size_t) -> c_int {
         let len = if len > (c_int::max_value() as size_t) {
             c_int::max_value() as size_t
@@ -140,7 +140,7 @@ impl<T> Context<T> {
     }
 }
 
-impl<T: IoCallback + Send + Sync + 'static> Context<T> {
+impl<T: IoCallback> Context<T> {
     pub fn establish(&mut self, io: T, hostname: Option<&str>) -> Result<()> {
         unsafe {
             let mut io = Box::new(io);
@@ -412,13 +412,69 @@ impl HandshakeContext {
 
 #[cfg(test)]
 mod tests {
-    use crate::ssl::context::HandshakeContext;
-    use crate::tests::TestTrait;
+    #[cfg(feature = "std")]
+    use std::io::{Read,Write, Result as IoResult};
+
+    #[cfg(not(feature = "std"))]
+    use core_io::{Read, Write, Result as IoResult};
 
+    use crate::ssl::context::{HandshakeContext, Context};
+    use crate::tests::TestTrait;
+    
     #[test]
     fn handshakecontext_sync() {
         assert!(!TestTrait::<dyn Sync, HandshakeContext>::new().impls_trait(), "HandshakeContext must be !Sync");
     }
+
+    struct NonSendStream {
+        _buffer: core::ptr::NonNull<u8>,
+    }
+
+    impl Read for NonSendStream {
+        fn read(&mut self, _: &mut [u8]) -> IoResult<usize> {
+            unimplemented!()
+        }
+    }
+    
+    impl Write for NonSendStream {
+        fn write(&mut self, _: &[u8]) -> IoResult<usize> {
+            unimplemented!()
+        }
+
+        fn flush(&mut self) -> IoResult<()> {
+            unimplemented!()
+        }
+    }
+
+    struct SendStream {
+        _buffer: u8,
+    }
+
+    impl Read for SendStream {
+        fn read(&mut self, _: &mut [u8]) -> IoResult<usize> {
+            unimplemented!()
+        }
+    }
+    
+    impl Write for SendStream {
+        fn write(&mut self, _: &[u8]) -> IoResult<usize> {
+            unimplemented!()
+        }
+
+        fn flush(&mut self) -> IoResult<()> {
+            unimplemented!()
+        }
+    }
+
+    #[test]
+    fn context_send() {
+        assert!(!TestTrait::<dyn Send, NonSendStream>::new().impls_trait(), "NonSendStream can't be send");
+        assert!(!TestTrait::<dyn Send, Context<NonSendStream>>::new().impls_trait(), "Context<NonSendStream> can't be send");
+
+        assert!(TestTrait::<dyn Send, SendStream>::new().impls_trait(), "SendStream is send");
+        assert!(TestTrait::<dyn Send, Context<SendStream>>::new().impls_trait(), "Context<SendStream> is send");
+    }
+
 }
 
 // ssl_get_alpn_protocol
diff --git a/mbedtls/tests/hyper.rs b/mbedtls/tests/hyper.rs
index 475599066..26eb9f604 100644
--- a/mbedtls/tests/hyper.rs
+++ b/mbedtls/tests/hyper.rs
@@ -25,18 +25,14 @@ impl<T> TlsStream<T> {
     }
 }
 
-unsafe impl<T> Send for TlsStream<T> {}
-unsafe impl<T> Sync for TlsStream<T> {}
-
-
-impl<T: io::Read + io::Write + 'static> io::Read for TlsStream<T>
+impl<T: io::Read + io::Write> io::Read for TlsStream<T>
 {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.context.lock().unwrap().read(buf)
     }
 }
 
-impl<T: io::Read + io::Write + 'static> io::Write for TlsStream<T>
+impl<T: io::Read + io::Write> io::Write for TlsStream<T>
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.context.lock().unwrap().write(buf)
@@ -83,8 +79,6 @@ impl MbedSSLServer {
     }
 }
 
-unsafe impl Send for MbedSSLServer {}
-
 /// An abstraction to allow any SSL implementation to be used with server-side HttpsStreams.
 impl<T> SslServer<T> for MbedSSLServer
     where T: NetworkStream + Send + Clone + fmt::Debug + Sync