1#![forbid(unsafe_code)]
20#![deny(missing_docs)]
21
22use std::io;
23use std::pin::Pin;
24use std::sync::Arc;
25use std::task::{Context, Poll};
26
27use futures_rustls::TlsConnector as RustlsConnector;
28use futures_rustls::rustls::{ClientConfig, RootCertStore};
29use moirai_async::io::{AsyncRead as MoiraiRead, AsyncWrite as MoiraiWrite};
30
31pub use futures_rustls::rustls;
33pub use rustls_pki_types::ServerName;
35
36#[derive(Debug)]
41pub struct ToFuturesIo<S>(
42 pub S,
44);
45
46impl<S: MoiraiRead + Unpin> futures_io::AsyncRead for ToFuturesIo<S> {
47 #[inline]
48 fn poll_read(
49 self: Pin<&mut Self>,
50 cx: &mut Context<'_>,
51 buf: &mut [u8],
52 ) -> Poll<io::Result<usize>> {
53 MoiraiRead::poll_read(Pin::new(&mut self.get_mut().0), cx, buf)
54 }
55}
56
57impl<S: MoiraiWrite + Unpin> futures_io::AsyncWrite for ToFuturesIo<S> {
58 #[inline]
59 fn poll_write(
60 self: Pin<&mut Self>,
61 cx: &mut Context<'_>,
62 buf: &[u8],
63 ) -> Poll<io::Result<usize>> {
64 MoiraiWrite::poll_write(Pin::new(&mut self.get_mut().0), cx, buf)
65 }
66
67 #[inline]
68 fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
69 MoiraiWrite::poll_flush(Pin::new(&mut self.get_mut().0), cx)
70 }
71
72 #[inline]
73 fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
74 MoiraiWrite::poll_shutdown(Pin::new(&mut self.get_mut().0), cx)
75 }
76}
77
78#[derive(Debug)]
80pub struct ToMoiraiIo<S>(
81 pub S,
83);
84
85impl<S: futures_io::AsyncRead + Unpin> MoiraiRead for ToMoiraiIo<S> {
86 #[inline]
87 fn poll_read(
88 self: Pin<&mut Self>,
89 cx: &mut Context<'_>,
90 buf: &mut [u8],
91 ) -> Poll<io::Result<usize>> {
92 futures_io::AsyncRead::poll_read(Pin::new(&mut self.get_mut().0), cx, buf)
93 }
94}
95
96impl<S: futures_io::AsyncWrite + Unpin> MoiraiWrite for ToMoiraiIo<S> {
97 #[inline]
98 fn poll_write(
99 self: Pin<&mut Self>,
100 cx: &mut Context<'_>,
101 buf: &[u8],
102 ) -> Poll<io::Result<usize>> {
103 futures_io::AsyncWrite::poll_write(Pin::new(&mut self.get_mut().0), cx, buf)
104 }
105
106 #[inline]
107 fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
108 futures_io::AsyncWrite::poll_flush(Pin::new(&mut self.get_mut().0), cx)
109 }
110
111 #[inline]
112 fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
113 futures_io::AsyncWrite::poll_close(Pin::new(&mut self.get_mut().0), cx)
114 }
115}
116
117pub type TlsStream<S> = ToMoiraiIo<futures_rustls::client::TlsStream<ToFuturesIo<S>>>;
123
124#[derive(Clone)]
126pub struct TlsConnector {
127 inner: RustlsConnector,
128}
129
130impl TlsConnector {
131 #[must_use]
133 pub fn from_config(config: Arc<ClientConfig>) -> Self {
134 Self {
135 inner: RustlsConnector::from(config),
136 }
137 }
138
139 #[must_use]
143 pub fn with_webpki_roots() -> Self {
144 let mut roots = RootCertStore::empty();
145 roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
146 Self::from_config(Arc::new(client_config_with_roots(roots)))
147 }
148
149 pub async fn connect<S>(
155 &self,
156 domain: ServerName<'static>,
157 stream: S,
158 ) -> io::Result<TlsStream<S>>
159 where
160 S: MoiraiRead + MoiraiWrite + Unpin,
161 {
162 let raw = self.inner.connect(domain, ToFuturesIo(stream)).await?;
163 Ok(ToMoiraiIo(raw))
164 }
165}
166
167#[must_use]
172pub fn client_config_with_roots(roots: RootCertStore) -> ClientConfig {
173 ClientConfig::builder_with_provider(Arc::new(moirai_crypto::provider()))
174 .with_safe_default_protocol_versions()
175 .expect("moirai-crypto provider supports safe default protocol versions")
176 .with_root_certificates(roots)
177 .with_no_client_auth()
178}