Skip to main content

bornera_rustls/
server_session.rs

1//! Socket-free bounded rustls server progression driven by an external owner.
2
3use bornera::{
4    TransportDiagnostic, TransportError, TransportFailurePhase, TransportLimits, TransportPressure,
5};
6use rustls::ServerConnection;
7
8use crate::{
9    RustlsPeerClosure, RustlsServerConfig, RustlsServerSessionError, RustlsServerStatus,
10    RustlsTransportLimits,
11    diagnostic::protocol_error,
12    server_status::{
13        STATUS_CLOSE_NOTIFY_SENT, STATUS_HANDSHAKING, STATUS_OPEN, STATUS_WANTS_READ,
14        STATUS_WANTS_WRITE,
15    },
16};
17
18/// One bounded rustls server connection without a socket, clock, task, or runtime.
19#[derive(Debug)]
20pub struct RustlsServerSession {
21    pub(crate) tls: ServerConnection,
22    pub(crate) limits: RustlsTransportLimits,
23    pub(crate) plaintext_bytes: usize,
24    pub(crate) tls_egress_bytes: usize,
25    pub(crate) peer_closure: RustlsPeerClosure,
26    pub(crate) opened: bool,
27    pub(crate) close_notify_sent: bool,
28    pub(crate) failure: Option<TransportDiagnostic>,
29}
30
31impl RustlsServerSession {
32    /// Constructs a session only when its stable charge fits the supplied ceiling.
33    pub fn new(
34        config: &RustlsServerConfig,
35        supplied: TransportLimits,
36    ) -> Result<Self, RustlsServerSessionError> {
37        let limits = config.limits();
38        let required = limits.transport_limits().retained_bytes();
39        if required > supplied.retained_bytes() {
40            return Err(RustlsServerSessionError::Capacity {
41                required,
42                supplied: supplied.retained_bytes(),
43            });
44        }
45        let mut tls = ServerConnection::new(config.server_config().clone())
46            .map_err(RustlsServerSessionError::Tls)?;
47        tls.set_buffer_limit(Some(limits.application_write_buffer_bytes().get()));
48        let state = tls
49            .process_new_packets()
50            .map_err(RustlsServerSessionError::Tls)?;
51        limits
52            .validate_state(&state, TransportFailurePhase::Establishment)
53            .map_err(RustlsServerSessionError::Transport)?;
54        Ok(Self {
55            plaintext_bytes: state.plaintext_bytes_to_read(),
56            tls_egress_bytes: state.tls_bytes_to_write(),
57            tls,
58            limits,
59            peer_closure: RustlsPeerClosure::Open,
60            opened: false,
61            close_notify_sent: false,
62            failure: None,
63        })
64    }
65
66    /// Returns the exact externally actionable session state.
67    pub fn status(&self) -> RustlsServerStatus {
68        let failed = self.failure.is_some();
69        let wants_read =
70            self.tls.wants_read() && self.peer_closure == RustlsPeerClosure::Open && !failed;
71        let flags = (u8::from(self.tls.is_handshaking()) * STATUS_HANDSHAKING)
72            | (u8::from(self.opened && !self.close_notify_sent && !failed) * STATUS_OPEN)
73            | (u8::from(wants_read) * STATUS_WANTS_READ)
74            | (u8::from(self.tls.wants_write()) * STATUS_WANTS_WRITE)
75            | (u8::from(self.close_notify_sent) * STATUS_CLOSE_NOTIFY_SENT);
76        RustlsServerStatus {
77            flags,
78            readable_plaintext_bytes: self.plaintext_bytes,
79            tls_egress_bytes: self.tls_egress_bytes,
80            peer_closure: self.peer_closure,
81            failure: self.failure,
82        }
83    }
84
85    /// Returns the exact stable charge reserved for this session.
86    pub const fn pressure(&self) -> TransportPressure {
87        self.limits.pressure()
88    }
89
90    /// Returns the logical and accounting limits enforced by this session.
91    pub const fn limits(&self) -> RustlsTransportLimits {
92        self.limits
93    }
94
95    /// Returns the negotiated ALPN identifier without copying it.
96    pub fn alpn_protocol(&self) -> Option<&[u8]> {
97        self.tls.alpn_protocol()
98    }
99
100    /// Returns the offered `ClientHello` SNI value without copying it.
101    pub fn server_name(&self) -> Option<&str> {
102        self.tls.server_name()
103    }
104
105    pub(crate) fn refresh(&mut self, phase: TransportFailurePhase) -> Result<(), TransportError> {
106        let state = self
107            .tls
108            .process_new_packets()
109            .map_err(|error| protocol_error(phase, &error))?;
110        self.limits
111            .validate_state(&state, phase)
112            .map_err(TransportError::new)?;
113        self.plaintext_bytes = state.plaintext_bytes_to_read();
114        self.tls_egress_bytes = state.tls_bytes_to_write();
115        if state.peer_has_closed() {
116            self.peer_closure = RustlsPeerClosure::Clean;
117        }
118        if !self.tls.is_handshaking() && !self.tls.wants_write() {
119            self.opened = true;
120        }
121        Ok(())
122    }
123
124    pub(crate) fn ensure_progressing(&self) -> Result<(), TransportError> {
125        match self.failure {
126            Some(diagnostic) => Err(TransportError::new(diagnostic)),
127            None => Ok(()),
128        }
129    }
130
131    pub(crate) fn latch(&mut self, diagnostic: TransportDiagnostic) -> TransportError {
132        self.record_failure(diagnostic);
133        TransportError::new(diagnostic)
134    }
135
136    pub(crate) fn record_failure(&mut self, diagnostic: TransportDiagnostic) {
137        self.failure.get_or_insert(diagnostic);
138    }
139
140    pub(crate) fn read_phase(&self) -> TransportFailurePhase {
141        if self.tls.is_handshaking() {
142            TransportFailurePhase::Establishment
143        } else {
144            TransportFailurePhase::TransportRead
145        }
146    }
147
148    pub(crate) fn write_phase(&self) -> TransportFailurePhase {
149        if self.tls.is_handshaking() {
150            TransportFailurePhase::Establishment
151        } else if self.close_notify_sent {
152            TransportFailurePhase::Shutdown
153        } else {
154            TransportFailurePhase::TransportWrite
155        }
156    }
157
158    pub(crate) fn ingress_limit(&self) -> usize {
159        match usize::try_from(self.limits.pressure().inbound().get()) {
160            Ok(limit) => limit,
161            Err(_) => usize::MAX,
162        }
163    }
164}