Skip to main content

bornera_rustls/
client_io.rs

1//! Caller-driven encrypted and plaintext progression for client sessions.
2
3use 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    /// Copies caller-owned ciphertext into rustls and returns its exact consumed count.
14    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    /// Reads authenticated plaintext and returns the exact copied count.
39    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    /// Irreversibly accepts bounded request plaintext and returns its exact count.
70    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    /// Copies pending TLS records into a caller buffer and returns the produced count.
93    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    /// Records raw input EOF, deferring truncation until authenticated plaintext drains.
114    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    /// Starts graceful local TLS shutdown; repeated calls are idempotent.
141    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}