chateau 0.3.2

Tower primitives for Servers and Clients with ergonomic APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! Hyper TLS Acceptor with some support for tracing.

use core::task::{Context, Poll, ready};
use std::pin::Pin;
use std::sync::Arc;

use pin_project::pin_project;
use rustls::ServerConfig;
use tokio::io::{AsyncRead, AsyncWrite};

use crate::info::HasConnectionInfo;

use crate::server::conn::Accept;
/// TLS Acceptor which uses a [rustls::ServerConfig] to accept connections
/// and start a TLS handshake.
///
/// The actual handshake is handled in the [super::TlsStream] type.
///
/// The TLS acceptor implements the [Accept] trait.
#[derive(Debug)]
#[pin_project]
pub struct TlsAcceptor<A> {
    config: Arc<ServerConfig>,
    #[pin]
    incoming: A,
}

pub(super) use super::TlsStream;

impl<A> TlsAcceptor<A> {
    /// Create a new TLS Acceptor with the given [rustls::ServerConfig] and [tokio::net::TcpListener].
    pub fn new(config: Arc<ServerConfig>, incoming: A) -> Self {
        TlsAcceptor { config, incoming }
    }
}

impl<A> Accept for TlsAcceptor<A>
where
    A: Accept,
    A::Connection: AsyncRead + AsyncWrite + HasConnectionInfo,
    <A::Connection as HasConnectionInfo>::Addr: Clone + Unpin + Send + Sync + 'static,
{
    type Connection = TlsStream<A::Connection>;
    type Error = A::Error;

    fn poll_accept(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<Self::Connection, Self::Error>> {
        let this = self.project();

        match ready!(this.incoming.poll_accept(cx)) {
            // A new TCP connection is ready to be accepted.
            Ok(stream) => {
                let accept =
                    tokio_rustls::TlsAcceptor::from(Arc::clone(this.config)).accept(stream);
                Poll::Ready(Ok(TlsStream::new(accept)))
            }

            // An error occurred while accepting a new TCP connection.
            Err(e) => Poll::Ready(Err(e)),
        }
    }
}

/// Extension trait for the [Accept] trait to add a method to wrap the acceptor in a TLS acceptor.
pub trait TlsAcceptExt: Accept {
    /// Wrap the acceptor in a TLS acceptor using the given [rustls::ServerConfig].
    fn with_tls(self, config: Arc<ServerConfig>) -> TlsAcceptor<Self>
    where
        Self: Sized,
    {
        TlsAcceptor::new(config, self)
    }
}

impl<A> TlsAcceptExt for A where A: Accept {}