mirror of https://github.com/fafhrd91/actix-net
89 lines
2.5 KiB
Rust
89 lines
2.5 KiB
Rust
use std::io;
|
|
|
|
use actix_rt::net::ActixStream;
|
|
use actix_service::{Service, ServiceFactory};
|
|
use futures_core::future::LocalBoxFuture;
|
|
use log::trace;
|
|
use tokio_native_tls::{TlsConnector as TokioNativetlsConnector, TlsStream};
|
|
|
|
pub use tokio_native_tls::native_tls::TlsConnector;
|
|
|
|
use crate::connect::{Address, Connection};
|
|
|
|
/// Native-tls connector factory and service
|
|
pub struct NativetlsConnector {
|
|
connector: TokioNativetlsConnector,
|
|
}
|
|
|
|
impl NativetlsConnector {
|
|
pub fn new(connector: TlsConnector) -> Self {
|
|
Self {
|
|
connector: TokioNativetlsConnector::from(connector),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NativetlsConnector {
|
|
pub fn service(connector: TlsConnector) -> Self {
|
|
Self::new(connector)
|
|
}
|
|
}
|
|
|
|
impl Clone for NativetlsConnector {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
connector: self.connector.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Address, U> ServiceFactory<Connection<T, U>> for NativetlsConnector
|
|
where
|
|
U: ActixStream + 'static,
|
|
{
|
|
type Response = Connection<T, TlsStream<U>>;
|
|
type Error = io::Error;
|
|
type Config = ();
|
|
type Service = Self;
|
|
type InitError = ();
|
|
type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
|
|
|
|
fn new_service(&self, _: ()) -> Self::Future {
|
|
let connector = self.clone();
|
|
Box::pin(async { Ok(connector) })
|
|
}
|
|
}
|
|
|
|
// NativetlsConnector is both it's ServiceFactory and Service impl type.
|
|
// As the factory and service share the same type and state.
|
|
impl<T, U> Service<Connection<T, U>> for NativetlsConnector
|
|
where
|
|
T: Address,
|
|
U: ActixStream + 'static,
|
|
{
|
|
type Response = Connection<T, TlsStream<U>>;
|
|
type Error = io::Error;
|
|
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
|
|
|
|
actix_service::always_ready!();
|
|
|
|
fn call(&self, stream: Connection<T, U>) -> Self::Future {
|
|
let (io, stream) = stream.replace_io(());
|
|
let connector = self.connector.clone();
|
|
Box::pin(async move {
|
|
trace!("SSL Handshake start for: {:?}", stream.host());
|
|
connector
|
|
.connect(stream.host(), io)
|
|
.await
|
|
.map(|res| {
|
|
trace!("SSL Handshake success: {:?}", stream.host());
|
|
stream.replace_io(res).1
|
|
})
|
|
.map_err(|e| {
|
|
trace!("SSL Handshake error: {:?}", e);
|
|
io::Error::new(io::ErrorKind::Other, format!("{}", e))
|
|
})
|
|
})
|
|
}
|
|
}
|