bornera_rustls/
server_session.rs1use 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#[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 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 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 pub const fn pressure(&self) -> TransportPressure {
87 self.limits.pressure()
88 }
89
90 pub const fn limits(&self) -> RustlsTransportLimits {
92 self.limits
93 }
94
95 pub fn alpn_protocol(&self) -> Option<&[u8]> {
97 self.tls.alpn_protocol()
98 }
99
100 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}