use std::io;
use bornera::{TransportDiagnostic, TransportError, TransportFailureKind, TransportFailurePhase};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
#[repr(u32)]
pub enum RustlsDiagnostic {
Protocol = 1,
Certificate = 2,
ServerName = 3,
Truncated = 4,
Capacity = 5,
CallerState = 6,
}
impl RustlsDiagnostic {
pub const fn code(self) -> u32 {
self as u32
}
pub const fn from_code(code: u32) -> Option<Self> {
match code {
1 => Some(Self::Protocol),
2 => Some(Self::Certificate),
3 => Some(Self::ServerName),
4 => Some(Self::Truncated),
5 => Some(Self::Capacity),
6 => Some(Self::CallerState),
_ => None,
}
}
}
pub(crate) fn protocol_error(
phase: TransportFailurePhase,
error: &rustls::Error,
) -> TransportError {
let (failure, code) = match error {
rustls::Error::InvalidCertificate(
rustls::CertificateError::NotValidForName
| rustls::CertificateError::NotValidForNameContext { .. },
)
| rustls::Error::UnsupportedNameType => (
TransportFailureKind::ServerName,
RustlsDiagnostic::ServerName,
),
rustls::Error::InvalidCertificate(_)
| rustls::Error::InvalidCertRevocationList(_)
| rustls::Error::NoCertificatesPresented => (
TransportFailureKind::Certificate,
RustlsDiagnostic::Certificate,
),
_ => (TransportFailureKind::Protocol, RustlsDiagnostic::Protocol),
};
TransportError::new(TransportDiagnostic::new(
phase,
failure,
io::ErrorKind::InvalidData,
Some(code.code()),
))
}
pub(crate) fn truncated_error(phase: TransportFailurePhase) -> TransportError {
TransportError::new(TransportDiagnostic::new(
phase,
TransportFailureKind::Truncated,
io::ErrorKind::UnexpectedEof,
Some(RustlsDiagnostic::Truncated.code()),
))
}
pub(crate) fn caller_state_error(
phase: TransportFailurePhase,
kind: io::ErrorKind,
) -> TransportError {
TransportError::new(TransportDiagnostic::new(
phase,
TransportFailureKind::Contract,
kind,
Some(RustlsDiagnostic::CallerState.code()),
))
}