1use 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}