use std::{io::{Read, Write}, net::TcpListener, sync::{Arc, OnceLock}};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use crate::{AcceptedTls, AlpnHandlerConfig, Error, EventReceiver, Result};
static RUNTIME: OnceLock<Arc<tokio::runtime::Runtime>> = OnceLock::new();
fn runtime() -> Result<&'static Arc<tokio::runtime::Runtime>> {
RUNTIME.get().ok_or(Error::AlpnHandlerNotRegistered)
}
fn assert_outside_runtime() -> Result<()> {
if tokio::runtime::Handle::try_current().is_ok() {
return Err(Error::InvalidConfig("blocking API called from inside an async runtime".into()));
}
Ok(())
}
pub struct ManagedTlsListener { inner: crate::ManagedTlsListener, runtime: Arc<tokio::runtime::Runtime> }
impl ManagedTlsListener {
pub fn accept(&mut self) -> Result<Option<AcceptedTlsStream>> {
assert_outside_runtime()?;
self.runtime.block_on(self.inner.accept()).map(|value| value.map(|inner| AcceptedTlsStream { inner, runtime: Arc::clone(&self.runtime) }))
}
}
pub struct AcceptedTlsStream { inner: AcceptedTls, runtime: Arc<tokio::runtime::Runtime> }
impl AcceptedTlsStream {
#[must_use] pub fn server_name(&self) -> &crate::DnsName { self.inner.server_name() }
#[must_use] pub fn negotiated_alpn(&self) -> Option<&[u8]> { self.inner.negotiated_alpn() }
}
impl Read for AcceptedTlsStream {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> { self.runtime.block_on(self.inner.read(buffer)) }
}
impl Write for AcceptedTlsStream {
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> { self.runtime.block_on(self.inner.write(buffer)) }
fn flush(&mut self) -> std::io::Result<()> { self.runtime.block_on(self.inner.flush()) }
}
pub fn register_alpn_handler(listener: TcpListener, config: Option<AlpnHandlerConfig>) -> Result<ManagedTlsListener> {
assert_outside_runtime()?;
let runtime = Arc::new(tokio::runtime::Builder::new_multi_thread().enable_all().build()?);
listener.set_nonblocking(true)?;
let tokio_listener = { let _guard = runtime.enter(); tokio::net::TcpListener::from_std(listener)? };
let inner = runtime.block_on(crate::register_alpn_handler(tokio_listener, config))?;
RUNTIME.set(Arc::clone(&runtime)).map_err(|_| Error::AlpnHandlerAlreadyRegistered)?;
Ok(ManagedTlsListener { inner, runtime })
}
pub fn register_handler(listener: TcpListener) -> Result<ManagedTlsListener> {
assert_outside_runtime()?;
let runtime = Arc::clone(runtime()?);
listener.set_nonblocking(true)?;
let tokio_listener = { let _guard = runtime.enter(); tokio::net::TcpListener::from_std(listener)? };
let inner = runtime.block_on(crate::register_handler(tokio_listener))?;
Ok(ManagedTlsListener { inner, runtime })
}
pub fn get_certificate(name: &str) -> Result<Arc<crate::StoredCertificate>> { assert_outside_runtime()?; runtime()?.block_on(crate::get_certificate(name)) }
pub fn get_or_issue_certificate(name: &str) -> Result<Arc<crate::StoredCertificate>> { assert_outside_runtime()?; runtime()?.block_on(crate::get_or_issue_certificate(name)) }
pub fn list_certificates() -> Result<Vec<Arc<crate::StoredCertificate>>> { assert_outside_runtime()?; runtime()?.block_on(crate::list_certificates()) }
pub fn subscribe_events() -> Result<EventReceiver> { crate::subscribe_events() }
#[cfg(test)]
mod tests {
use super::*;
use crate::{AcmeEndpoint, EventOutput, HostPattern};
use rustls::{ClientConfig, ClientConnection, RootCertStore, StreamOwned, pki_types::{CertificateDer, ServerName}};
#[test]
#[ignore = "uses the process-global manager; run as an isolated filtered test"]
fn blocking_acceptor_completes_tls_and_supports_read_write() {
let directory = tempfile::tempdir().unwrap();
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let mut config = AlpnHandlerConfig::default();
config.allowed_hosts = vec![HostPattern::exact("blocking.test").unwrap()];
config.verify_dns_before_issuance = false;
config.acme_endpoint = AcmeEndpoint::LocalOnly;
config.cert_store_directory = directory.path().to_owned();
config.events = EventOutput::Subscribe;
config.allow_non_443_listener = true;
let mut managed = register_alpn_handler(listener, Some(config)).unwrap();
let server = std::thread::spawn(move || {
let mut stream = managed.accept().unwrap().unwrap();
assert_eq!(stream.server_name().as_str(), "blocking.test");
let mut byte = [0_u8; 1];
stream.read_exact(&mut byte).unwrap();
stream.write_all(&[byte[0] + 1]).unwrap();
stream.flush().unwrap();
});
let ca_pem = std::fs::read(directory.path().join("Local/CA.pem")).unwrap();
let (_, ca) = x509_parser::pem::parse_x509_pem(&ca_pem).unwrap();
let mut roots = RootCertStore::empty();
roots.add(CertificateDer::from(ca.contents)).unwrap();
let client = Arc::new(ClientConfig::builder().with_root_certificates(roots).with_no_client_auth());
let connection = ClientConnection::new(client, ServerName::try_from("blocking.test").unwrap()).unwrap();
let socket = std::net::TcpStream::connect(address).unwrap();
let mut tls = StreamOwned::new(connection, socket);
tls.write_all(&[41]).unwrap();
tls.flush().unwrap();
let mut response = [0_u8; 1];
tls.read_exact(&mut response).unwrap();
assert_eq!(response, [42]);
server.join().unwrap();
}
}