restore rust-tls support

src/server/http.rs

@@ -15,8 +15,8 @@ use native_tls::TlsAcceptor;
 #[cfg(any(feature = "alpn", feature = "ssl"))]
 use openssl::ssl::SslAcceptorBuilder;
 
-//#[cfg(feature = "rust-tls")]
-//use rustls::ServerConfig;
+#[cfg(feature = "rust-tls")]
+use rustls::ServerConfig;
 
 use super::acceptor::{AcceptorServiceFactory, DefaultAcceptor};
 use super::builder::DefaultPipelineFactory;
@@ -313,22 +313,38 @@ where
         Ok(self)
     }
 
-    // #[cfg(feature = "rust-tls")]
-    // /// Use listener for accepting incoming tls connection requests
-    // ///
-    // /// This method sets alpn protocols to "h2" and "http/1.1"
-    // pub fn listen_rustls(self, lst: net::TcpListener, builder: ServerConfig) -> Self {
-    //     use super::{RustlsAcceptor, ServerFlags};
+    #[cfg(feature = "rust-tls")]
+    /// Use listener for accepting incoming tls connection requests
+    ///
+    /// This method sets alpn protocols to "h2" and "http/1.1"
+    pub fn listen_rustls(mut self, lst: net::TcpListener, config: ServerConfig) -> Self {
+        use super::{RustlsAcceptor, ServerFlags};
+        use actix_net::service::NewServiceExt;
 
-    //     // alpn support
-    //     let flags = if self.no_http2 {
-    //         ServerFlags::HTTP1
-    //     } else {
-    //         ServerFlags::HTTP1 | ServerFlags::HTTP2
-    //     };
-    //
-    //     self.listen_with(lst, RustlsAcceptor::with_flags(builder, flags))
-    // }
+        // alpn support
+        let flags = if self.no_http2 {
+            ServerFlags::HTTP1
+        } else {
+            ServerFlags::HTTP1 | ServerFlags::HTTP2
+        };
+
+        let addr = lst.local_addr().unwrap();
+        self.sockets.push(Socket {
+            lst,
+            addr,
+            scheme: "https",
+            handler: Box::new(HttpServiceBuilder::new(
+                self.factory.clone(),
+                move || {
+                    RustlsAcceptor::with_flags(config.clone(), flags).map_err(|_| ())
+                },
+                DefaultPipelineFactory::new(),
+            )),
+        });
+
+        //Ok(self)
+        self
+    }
 
     /// The socket address to bind
     ///

src/server/ssl/mod.rs

@@ -6,7 +6,7 @@ pub use self::openssl::*;
 #[cfg(feature = "tls")]
 mod nativetls;
 
-//#[cfg(feature = "rust-tls")]
-//mod rustls;
-//#[cfg(feature = "rust-tls")]
-//pub use self::rustls::RustlsAcceptor;
+#[cfg(feature = "rust-tls")]
+mod rustls;
+#[cfg(feature = "rust-tls")]
+pub use self::rustls::RustlsAcceptor;

src/server/ssl/rustls.rs

@@ -1,29 +1,25 @@
 use std::net::Shutdown;
-use std::sync::Arc;
 use std::{io, time};
 
+use actix_net::ssl; //::RustlsAcceptor;
 use rustls::{ClientSession, ServerConfig, ServerSession};
-use tokio_io::AsyncWrite;
-use tokio_rustls::{AcceptAsync, ServerConfigExt, TlsStream};
+use tokio_io::{AsyncRead, AsyncWrite};
+use tokio_rustls::TlsStream;
 
-use server::{AcceptorService, IoStream, ServerFlags};
+use server::{IoStream, ServerFlags};
 
-#[derive(Clone)]
 /// Support `SSL` connections via rustls package
 ///
 /// `rust-tls` feature enables `RustlsAcceptor` type
-pub struct RustlsAcceptor {
-    config: Arc<ServerConfig>,
+pub struct RustlsAcceptor<T> {
+    _t: ssl::RustlsAcceptor<T>,
 }
 
-impl RustlsAcceptor {
-    /// Create `OpensslAcceptor` with enabled `HTTP/2` and `HTTP1.1` support.
-    pub fn new(config: ServerConfig) -> Self {
-        RustlsAcceptor::with_flags(config, ServerFlags::HTTP1 | ServerFlags::HTTP2)
-    }
-
-    /// Create `OpensslAcceptor` with custom server flags.
-    pub fn with_flags(mut config: ServerConfig, flags: ServerFlags) -> Self {
+impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
+    /// Create `RustlsAcceptor` with custom server flags.
+    pub fn with_flags(
+        mut config: ServerConfig, flags: ServerFlags,
+    ) -> ssl::RustlsAcceptor<T> {
         let mut protos = Vec::new();
         if flags.contains(ServerFlags::HTTP2) {
             protos.push("h2".to_string());
@@ -35,22 +31,7 @@ impl RustlsAcceptor {
             config.set_protocols(&protos);
         }
 
-        RustlsAcceptor {
-            config: Arc::new(config),
-        }
-    }
-}
-
-impl<Io: IoStream> AcceptorService<Io> for RustlsAcceptor {
-    type Accepted = TlsStream<Io, ServerSession>;
-    type Future = AcceptAsync<Io>;
-
-    fn scheme(&self) -> &'static str {
-        "https"
-    }
-
-    fn accept(&self, io: Io) -> Self::Future {
-        ServerConfigExt::accept_async(&self.config, io)
+        ssl::RustlsAcceptor::new(config)
     }
 }