Skip to main content

bornera_rustls/
port.rs

1//! Bornera transport lifecycle and readiness contract implementation.
2
3use bornera::{
4    RegisteredTransport, SlotTransport, TcpSocketPolicy, TransportBudget, TransportError,
5    TransportFailurePhase, TransportPressure, TransportProgress,
6};
7use calandria::{Interest, Readiness};
8
9use crate::{
10    RustlsTransport,
11    transport::{EofState, ShutdownState, TransportPhase},
12};
13
14impl SlotTransport for RustlsTransport {
15    fn drive_establishment(
16        &mut self,
17        policy: TcpSocketPolicy,
18        budget: TransportBudget,
19    ) -> Result<TransportProgress, TransportError> {
20        let progress = match self.phase {
21            TransportPhase::Connecting => self.complete_connect(),
22            TransportPhase::NoDelay => self.apply_no_delay(policy),
23            TransportPhase::Keepalive => self.apply_keepalive(policy),
24            TransportPhase::Handshaking => self.drive_tls_once(
25                budget,
26                TransportFailurePhase::Establishment,
27                TransportFailurePhase::Establishment,
28            ),
29            TransportPhase::Open => Ok(TransportProgress::IDLE),
30        }?;
31        if self.phase == TransportPhase::Handshaking
32            && !self.tls.is_handshaking()
33            && !self.tls.wants_write()
34        {
35            self.phase = TransportPhase::Open;
36        }
37        Ok(progress)
38    }
39
40    fn drive_transport(
41        &mut self,
42        budget: TransportBudget,
43    ) -> Result<TransportProgress, TransportError> {
44        if self.shutdown == ShutdownState::Started {
45            return self.drive_tls_write(budget, TransportFailurePhase::Shutdown);
46        }
47        self.drive_tls_once(
48            budget,
49            TransportFailurePhase::TransportRead,
50            TransportFailurePhase::TransportWrite,
51        )
52    }
53
54    fn begin_shutdown(
55        &mut self,
56        _budget: TransportBudget,
57    ) -> Result<TransportProgress, TransportError> {
58        self.tls.send_close_notify();
59        self.shutdown = ShutdownState::Started;
60        self.refresh_state(TransportFailurePhase::Shutdown)?;
61        Ok(TransportProgress::operation())
62    }
63
64    fn can_establish(&self) -> bool {
65        match self.phase {
66            TransportPhase::Connecting => self.can_connect(),
67            TransportPhase::NoDelay | TransportPhase::Keepalive => true,
68            TransportPhase::Handshaking => self.can_tls_progress(),
69            TransportPhase::Open => false,
70        }
71    }
72
73    fn has_transport_work(&self) -> bool {
74        if self.shutdown == ShutdownState::Started {
75            self.can_tls_write()
76        } else {
77            self.can_tls_progress()
78        }
79    }
80
81    fn is_shutdown_complete(&self) -> bool {
82        self.shutdown == ShutdownState::Started && !self.tls.wants_write()
83    }
84
85    fn is_open(&self) -> bool {
86        self.phase == TransportPhase::Open
87    }
88
89    fn can_read(&self) -> bool {
90        self.is_open() && self.can_read_plaintext()
91    }
92
93    fn can_write(&self) -> bool {
94        self.is_open() && self.shutdown == ShutdownState::NotStarted && self.can_accept_plaintext()
95    }
96
97    fn desired_interest(&self, has_writes: bool) -> Interest {
98        match self.phase {
99            TransportPhase::Connecting | TransportPhase::NoDelay | TransportPhase::Keepalive => {
100                Interest::READ_WRITE
101            }
102            TransportPhase::Handshaking | TransportPhase::Open => {
103                let read = self.shutdown == ShutdownState::NotStarted
104                    && self.eof == EofState::Live
105                    && self.tls.wants_read();
106                let write = self.tls.wants_write()
107                    || (self.phase == TransportPhase::Open
108                        && self.shutdown == ShutdownState::NotStarted
109                        && has_writes);
110                match (read, write) {
111                    (true, true) => Interest::READ_WRITE,
112                    (false, true) => Interest::WRITABLE,
113                    _ => Interest::READABLE,
114                }
115            }
116        }
117    }
118
119    fn pressure(&self) -> TransportPressure {
120        self.limits.pressure()
121    }
122
123    fn pressure_limit(&self) -> bornera::TransportLimits {
124        self.limits.transport_limits()
125    }
126
127    fn clear_read(&mut self) {
128        self.clear_raw_read();
129    }
130
131    fn clear_write(&mut self) {
132        self.clear_raw_write();
133    }
134}
135
136impl RegisteredTransport for RustlsTransport {
137    fn observe_readiness(&mut self, readiness: Readiness) {
138        self.observe(readiness);
139    }
140}