bornera_rustls/
client_io.rs1use std::io::{self, Read, Write};
4
5use bornera::{TransportError, TransportFailurePhase};
6
7use crate::{
8 RustlsClientSession, RustlsPeerClosure,
9 diagnostic::{caller_state_error, truncated_error},
10};
11
12impl RustlsClientSession {
13 pub fn ingest_tls(&mut self, ciphertext: &[u8]) -> Result<usize, TransportError> {
15 if ciphertext.is_empty() {
16 return Ok(0);
17 }
18 self.ensure_progressing()?;
19 if self.peer_closure != RustlsPeerClosure::Open {
20 return Err(caller_state_error(
21 self.read_phase(),
22 io::ErrorKind::InvalidInput,
23 ));
24 }
25 let length = ciphertext.len().min(self.ingress_limit());
26 let mut source = &ciphertext[..length];
27 let phase = self.read_phase();
28 let read = self
29 .tls
30 .read_tls(&mut source)
31 .map_err(|error| TransportError::from_io(phase, error))?;
32 if let Err(error) = self.refresh(phase) {
33 return Err(self.latch(error.diagnostic()));
34 }
35 Ok(read)
36 }
37
38 pub fn read_plaintext(&mut self, output: &mut [u8]) -> Result<usize, TransportError> {
40 if output.is_empty() {
41 return Ok(0);
42 }
43 self.ensure_progressing()?;
44 if self.peer_closure == RustlsPeerClosure::Truncated && self.plaintext_bytes == 0 {
45 let error = truncated_error(self.read_phase());
46 return Err(self.latch(error.diagnostic()));
47 }
48 match self.tls.reader().read(output) {
49 Ok(read) => {
50 self.plaintext_bytes = self.plaintext_bytes.saturating_sub(read);
51 Ok(read)
52 }
53 Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
54 self.peer_closure = RustlsPeerClosure::Truncated;
55 let error = truncated_error(self.read_phase());
56 Err(self.latch(error.diagnostic()))
57 }
58 Err(error) if error.kind() == io::ErrorKind::WouldBlock => Err(caller_state_error(
59 TransportFailurePhase::Read,
60 io::ErrorKind::WouldBlock,
61 )),
62 Err(error) => {
63 let error = TransportError::from_io(TransportFailurePhase::Read, error);
64 Err(self.latch(error.diagnostic()))
65 }
66 }
67 }
68
69 pub fn write_plaintext(&mut self, plaintext: &[u8]) -> Result<usize, TransportError> {
71 if plaintext.is_empty() {
72 return Ok(0);
73 }
74 self.ensure_progressing()?;
75 if !self.opened || self.close_notify_sent {
76 return Err(caller_state_error(
77 TransportFailurePhase::Write,
78 io::ErrorKind::InvalidInput,
79 ));
80 }
81 let written = self
82 .tls
83 .writer()
84 .write(plaintext)
85 .map_err(|error| TransportError::from_io(TransportFailurePhase::Write, error))?;
86 if let Err(error) = self.refresh(TransportFailurePhase::Write) {
87 self.failure.get_or_insert(error.diagnostic());
88 }
89 Ok(written)
90 }
91
92 pub fn drain_tls(&mut self, output: &mut [u8]) -> Result<usize, TransportError> {
94 if output.is_empty() || !self.tls.wants_write() {
95 return Ok(0);
96 }
97 let phase = self.write_phase();
98 let mut sink = output;
99 let written = self
100 .tls
101 .write_tls(&mut sink)
102 .map_err(|error| TransportError::from_io(phase, error))?;
103 if self.failure.is_none() {
104 if let Err(error) = self.refresh(phase) {
105 self.failure.get_or_insert(error.diagnostic());
106 }
107 } else {
108 self.tls_egress_bytes = self.tls_egress_bytes.saturating_sub(written);
109 }
110 Ok(written)
111 }
112
113 pub fn finish_input(&mut self) -> Result<(), TransportError> {
115 self.ensure_progressing()?;
116 if self.peer_closure == RustlsPeerClosure::Clean {
117 return Ok(());
118 }
119 if self.peer_closure == RustlsPeerClosure::Open {
120 let mut eof = io::empty();
121 let phase = self.read_phase();
122 let _eof = self
123 .tls
124 .read_tls(&mut eof)
125 .map_err(|error| TransportError::from_io(phase, error))?;
126 if let Err(error) = self.refresh(phase) {
127 return Err(self.latch(error.diagnostic()));
128 }
129 if self.peer_closure != RustlsPeerClosure::Clean {
130 self.peer_closure = RustlsPeerClosure::Truncated;
131 }
132 }
133 if self.plaintext_bytes == 0 {
134 let error = truncated_error(self.read_phase());
135 return Err(self.latch(error.diagnostic()));
136 }
137 Ok(())
138 }
139
140 pub fn send_close_notify(&mut self) -> Result<(), TransportError> {
142 self.ensure_progressing()?;
143 if self.close_notify_sent {
144 return Ok(());
145 }
146 if !self.opened {
147 return Err(caller_state_error(
148 TransportFailurePhase::Shutdown,
149 io::ErrorKind::InvalidInput,
150 ));
151 }
152 self.tls.send_close_notify();
153 self.close_notify_sent = true;
154 match self.refresh(TransportFailurePhase::Shutdown) {
155 Ok(()) => Ok(()),
156 Err(error) => Err(self.latch(error.diagnostic())),
157 }
158 }
159}