use embedded_io::ErrorType;
use embedded_io_async::{Read, Write};
use super::error::TlsError;
use super::session::TlsSession;
use super::{sealed, StartTls};
use crate::tls::TlsClientConfig;
use crate::transport::common::Transport;
use crate::transport::ReadCancelSafety;
pub(super) enum State<T: Read + Write> {
Plain(T),
Tls(TlsSession<T>),
Broken,
}
pub struct MaybeTls<T: Read + Write> {
pub(super) state: State<T>,
}
impl<T: Read + Write> MaybeTls<T> {
pub fn plain(inner: T) -> Self {
Self {
state: State::Plain(inner),
}
}
pub fn is_tls(&self) -> bool {
matches!(self.state, State::Tls(_))
}
pub fn is_plain(&self) -> bool {
matches!(self.state, State::Plain(_))
}
pub fn export_keying_material(
&self,
out: &mut [u8],
label: &[u8],
context: Option<&[u8]>,
) -> Result<(), TlsError<T::Error>> {
match &self.state {
State::Tls(s) => s
.export_keying_material(out, label, context)
.map_err(TlsError::Tls),
State::Plain(_) | State::Broken => Err(TlsError::NotAvailable),
}
}
pub async fn shutdown(&mut self) -> Result<(), TlsError<T::Error>> {
match &mut self.state {
State::Tls(s) => s.shutdown().await,
State::Plain(_) | State::Broken => Ok(()),
}
}
}
impl<T: Read + Write> ErrorType for MaybeTls<T> {
type Error = TlsError<T::Error>;
}
impl<T: Read + Write> Read for MaybeTls<T> {
async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
match &mut self.state {
State::Plain(t) => t.read(buf).await.map_err(TlsError::Io),
State::Tls(s) => s.read(buf).await,
State::Broken => Err(TlsError::NotAvailable),
}
}
}
impl<T: Read + Write> Write for MaybeTls<T> {
async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
match &mut self.state {
State::Plain(t) => t.write(buf).await.map_err(TlsError::Io),
State::Tls(s) => s.write(buf).await,
State::Broken => Err(TlsError::NotAvailable),
}
}
async fn flush(&mut self) -> Result<(), Self::Error> {
match &mut self.state {
State::Plain(t) => t.flush().await.map_err(TlsError::Io),
State::Tls(s) => s.flush().await,
State::Broken => Err(TlsError::NotAvailable),
}
}
}
impl<T: Read + Write> sealed::Sealed for MaybeTls<T> {}
impl<T: Read + Write> StartTls for MaybeTls<T> {
async fn start_tls(&mut self, config: &TlsClientConfig) -> Result<(), Self::Error> {
let inner = match core::mem::replace(&mut self.state, State::Broken) {
State::Plain(inner) => inner,
other => {
self.state = other;
return Err(TlsError::NotAvailable);
}
};
let mut session = TlsSession::new(inner, config)?;
session.handshake().await?;
self.state = State::Tls(session);
Ok(())
}
fn is_key_rejected(error: &Self::Error) -> bool {
error.is_key_rejected()
}
}
impl<T> ReadCancelSafety for MaybeTls<T>
where
T: Read + Write + ReadCancelSafety,
{
fn read_cancel_safe(&self) -> bool {
match &self.state {
State::Plain(t) => t.read_cancel_safe(),
State::Tls(s) => s.inner.read_cancel_safe(),
State::Broken => false,
}
}
}
impl<T, U> sealed::Sealed for Transport<MaybeTls<T>, U>
where
T: Read + Write,
U: Read + Write,
{
}
impl<T, U> StartTls for Transport<MaybeTls<T>, U>
where
T: Read + Write,
U: Read + Write,
{
async fn start_tls(&mut self, config: &TlsClientConfig) -> Result<(), Self::Error> {
match self {
Self::Tcp(t) => t
.start_tls(config)
.await
.map_err(crate::transport::common::TransportError::Tcp),
Self::Usb(_) => Err(crate::transport::common::TransportError::Tcp(
TlsError::NotAvailable,
)),
}
}
fn is_key_rejected(error: &Self::Error) -> bool {
match error {
crate::transport::common::TransportError::Tcp(e) => e.is_key_rejected(),
crate::transport::common::TransportError::Usb(_) => false,
}
}
}