feat: simplify split api

Author: Ddystopia

src/asynch.rs

@@ -1,22 +1,20 @@
+use core::sync::atomic::{AtomicBool, Ordering};
+
 use crate::common::decrypted_buffer_info::DecryptedBufferInfo;
 use crate::common::decrypted_read_handler::DecryptedReadHandler;
 use crate::connection::{decrypt_record, Handshake, State};
 use crate::key_schedule::KeySchedule;
-use crate::key_schedule::{ReadKeySchedule, SharedState, WriteKeySchedule};
+use crate::key_schedule::{ReadKeySchedule, WriteKeySchedule};
 use crate::read_buffer::ReadBuffer;
 use crate::record::{ClientRecord, ClientRecordHeader};
-use crate::record_reader::RecordReader;
-use crate::split::{SplitState, SplitStateContainer};
-use crate::write_buffer::WriteBuffer;
+use crate::record_reader::{RecordReader, RecordReaderBorrowMut};
+use crate::write_buffer::{WriteBuffer, WriteBufferBorrowMut};
 use crate::TlsError;
 use embedded_io::Error as _;
 use embedded_io::ErrorType;
 use embedded_io_async::{BufRead, Read as AsyncRead, Write as AsyncWrite};
 
 pub use crate::config::*;
-#[cfg(feature = "std")]
-pub use crate::split::ManagedSplitState;
-pub use crate::split::SplitConnectionState;
 
 /// Type representing an async TLS connection. An instance of this type can
 /// be used to establish a TLS connection, write and read encrypted data over this connection,
@@ -27,7 +25,7 @@ where
     CipherSuite: TlsCipherSuite + 'static,
 {
     delegate: Socket,
-    opened: bool,
+    opened: AtomicBool,
     key_schedule: KeySchedule<CipherSuite>,
     record_reader: RecordReader<'a>,
     record_write_buf: WriteBuffer<'a>,
@@ -39,6 +37,9 @@ where
     Socket: AsyncRead + AsyncWrite + 'a,
     CipherSuite: TlsCipherSuite + 'static,
 {
+    pub fn is_opened(&mut self) -> bool {
+        *self.opened.get_mut()
+    }
     /// Create a new TLS connection with the provided context and a async I/O implementation
     ///
     /// NOTE: The record read buffer should be sized to fit an encrypted TLS record. The size of this record
@@ -57,7 +58,7 @@ where
     ) -> Self {
         Self {
             delegate,
-            opened: false,
+            opened: AtomicBool::new(false),
             key_schedule: KeySchedule::new(),
             record_reader: RecordReader::new(record_read_buf),
             record_write_buf: WriteBuffer::new(record_write_buf),
@@ -101,7 +102,7 @@ where
             trace!("State {:?} -> {:?}", state, next_state);
             state = next_state;
         }
-        self.opened = true;
+        *self.opened.get_mut() = true;
 
         Ok(())
     }
@@ -115,7 +116,7 @@ where
     ///
     /// Returns the number of bytes buffered/written.
     pub async fn write(&mut self, buf: &[u8]) -> Result<usize, TlsError> {
-        if self.opened {
+        if self.is_opened() {
             if !self
                 .record_write_buf
                 .contains(ClientRecordHeader::ApplicationData)
@@ -179,7 +180,7 @@ where
 
     /// Reads buffered data. If nothing is in memory, it'll wait for a TLS record and process it.
     pub async fn read_buffered(&mut self) -> Result<ReadBuffer, TlsError> {
-        if self.opened {
+        if self.is_opened() {
             while self.decrypted.is_empty() {
                 self.read_application_data().await?;
             }
@@ -200,7 +201,7 @@ where
         let mut handler = DecryptedReadHandler {
             source_buffer: buf_ptr_range,
             buffer_info: &mut self.decrypted,
-            is_open: &mut self.opened,
+            is_open: self.opened.get_mut(),
         };
         decrypt_record(
             self.key_schedule.read_state(),
@@ -215,9 +216,10 @@ where
     async fn close_internal(&mut self) -> Result<(), TlsError> {
         self.flush().await?;
 
+        let is_opened = self.is_opened();
         let (write_key_schedule, read_key_schedule) = self.key_schedule.as_split();
         let slice = self.record_write_buf.write_record(
-            &ClientRecord::close_notify(self.opened),
+            &ClientRecord::close_notify(is_opened),
             write_key_schedule,
             Some(read_key_schedule),
         )?;
@@ -240,77 +242,33 @@ where
         }
     }
 
-    #[cfg(feature = "std")]
-    pub fn split(
-        self,
-    ) -> (
-        TlsReader<'a, Socket, CipherSuite, ManagedSplitState>,
-        TlsWriter<'a, Socket, CipherSuite, ManagedSplitState>,
-    )
-    where
-        Socket: Clone,
-    {
-        self.split_with(ManagedSplitState::new())
-    }
-
-    #[allow(clippy::type_complexity)] // Requires inherent type aliases to solve well.
-    pub fn split_with<StateContainer>(
-        self,
-        state: StateContainer,
+    pub fn split<'b>(
+        &'b mut self,
     ) -> (
-        TlsReader<'a, Socket, CipherSuite, StateContainer::State>,
-        TlsWriter<'a, Socket, CipherSuite, StateContainer::State>,
+        TlsReader<'b, Socket, CipherSuite>,
+        TlsWriter<'b, Socket, CipherSuite>,
     )
     where
         Socket: Clone,
-        StateContainer: SplitStateContainer,
     {
-        let state = state.state();
-        state.set_open(self.opened);
-
-        let (shared, wks, rks) = self.key_schedule.split();
+        let (wks, rks) = self.key_schedule.as_split();
 
         let reader = TlsReader {
-            state: state.clone(),
+            opened: &self.opened,
             delegate: self.delegate.clone(),
             key_schedule: rks,
-            record_reader: self.record_reader,
-            decrypted: self.decrypted,
+            record_reader: self.record_reader.reborrow_mut(),
+            decrypted: &mut self.decrypted,
         };
         let writer = TlsWriter {
-            state,
-            delegate: self.delegate,
-            key_schedule_shared: shared,
+            opened: &self.opened,
+            delegate: self.delegate.clone(),
             key_schedule: wks,
-            record_write_buf: self.record_write_buf,
+            record_write_buf: self.record_write_buf.reborrow_mut(),
         };
 
         (reader, writer)
     }
-
-    pub fn unsplit<State>(
-        reader: TlsReader<'a, Socket, CipherSuite, State>,
-        writer: TlsWriter<'a, Socket, CipherSuite, State>,
-    ) -> Self
-    where
-        Socket: Clone,
-        State: SplitState,
-    {
-        debug_assert!(reader.state.same(&writer.state));
-
-        TlsConnection {
-            delegate: writer.delegate,
-            opened: writer.state.is_open(),
-            key_schedule: KeySchedule::unsplit(
-                writer.key_schedule_shared,
-                writer.key_schedule,
-                reader.key_schedule,
-            ),
-            record_reader: reader.record_reader,
-            record_write_buf: writer.record_write_buf,
-            decrypted: reader.decrypted,
-        }
-    }
 }
 
 impl<'a, Socket, CipherSuite> ErrorType for TlsConnection<'a, Socket, CipherSuite>
@@ -359,18 +317,18 @@ where
     }
 }
 
-pub struct TlsReader<'a, Socket, CipherSuite, State>
+pub struct TlsReader<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
-    state: State,
+    opened: &'a AtomicBool,
     delegate: Socket,
-    key_schedule: ReadKeySchedule<CipherSuite>,
-    record_reader: RecordReader<'a>,
-    decrypted: DecryptedBufferInfo,
+    key_schedule: &'a mut ReadKeySchedule<CipherSuite>,
+    record_reader: RecordReaderBorrowMut<'a>,
+    decrypted: &'a mut DecryptedBufferInfo,
 }
 
-impl<'a, Socket, CipherSuite, State> AsRef<Socket> for TlsReader<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> AsRef<Socket> for TlsReader<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
@@ -379,19 +337,18 @@ where
     }
 }
 
-impl<'a, Socket, CipherSuite, State> TlsReader<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> TlsReader<'a, Socket, CipherSuite>
 where
     Socket: AsyncRead + 'a,
     CipherSuite: TlsCipherSuite + 'static,
-    State: SplitState,
 {
     fn create_read_buffer(&mut self) -> ReadBuffer {
         self.decrypted.create_read_buffer(self.record_reader.buf)
     }
 
     /// Reads buffered data. If nothing is in memory, it'll wait for a TLS record and process it.
     pub async fn read_buffered(&mut self) -> Result<ReadBuffer, TlsError> {
-        if self.state.is_open() {
+        if self.opened.load(Ordering::Acquire) {
             while self.decrypted.is_empty() {
                 self.read_application_data().await?;
             }
@@ -409,7 +366,7 @@ where
             .read(&mut self.delegate, &mut self.key_schedule)
             .await?;
 
-        let mut opened = self.state.is_open();
+        let mut opened = self.opened.load(Ordering::Acquire);
         let mut handler = DecryptedReadHandler {
             source_buffer: buf_ptr_range,
             buffer_info: &mut self.decrypted,
@@ -420,24 +377,23 @@ where
         });
 
         if !opened {
-            self.state.set_open(false);
+            self.opened.store(false, Ordering::Release);
         }
         result
     }
 }
 
-pub struct TlsWriter<'a, Socket, CipherSuite, State>
+pub struct TlsWriter<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
-    state: State,
+    opened: &'a AtomicBool,
     delegate: Socket,
-    key_schedule_shared: SharedState<CipherSuite>,
-    key_schedule: WriteKeySchedule<CipherSuite>,
-    record_write_buf: WriteBuffer<'a>,
+    key_schedule: &'a mut WriteKeySchedule<CipherSuite>,
+    record_write_buf: WriteBufferBorrowMut<'a>,
 }
 
-impl<'a, Socket, CipherSuite, State> AsRef<Socket> for TlsWriter<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> AsRef<Socket> for TlsWriter<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
@@ -446,25 +402,24 @@ where
     }
 }
 
-impl<'a, Socket, CipherSuite, State> ErrorType for TlsWriter<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> ErrorType for TlsWriter<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
     type Error = TlsError;
 }
 
-impl<'a, Socket, CipherSuite, State> ErrorType for TlsReader<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> ErrorType for TlsReader<'a, Socket, CipherSuite>
 where
     CipherSuite: TlsCipherSuite + 'static,
 {
     type Error = TlsError;
 }
 
-impl<'a, Socket, CipherSuite, State> AsyncRead for TlsReader<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> AsyncRead for TlsReader<'a, Socket, CipherSuite>
 where
     Socket: AsyncRead + 'a,
     CipherSuite: TlsCipherSuite + 'static,
-    State: SplitState,
 {
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         if buf.is_empty() {
@@ -479,11 +434,10 @@ where
     }
 }
 
-impl<'a, Socket, CipherSuite, State> BufRead for TlsReader<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> BufRead for TlsReader<'a, Socket, CipherSuite>
 where
     Socket: AsyncRead + 'a,
     CipherSuite: TlsCipherSuite + 'static,
-    State: SplitState,
 {
     async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
         self.read_buffered().await.map(|mut buf| buf.peek_all())
@@ -494,14 +448,13 @@ where
     }
 }
 
-impl<'a, Socket, CipherSuite, State> AsyncWrite for TlsWriter<'a, Socket, CipherSuite, State>
+impl<'a, Socket, CipherSuite> AsyncWrite for TlsWriter<'a, Socket, CipherSuite>
 where
     Socket: AsyncWrite + 'a,
     CipherSuite: TlsCipherSuite + 'static,
-    State: SplitState,
 {
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        if self.state.is_open() {
+        if self.opened.load(Ordering::Acquire) {
             if !self
                 .record_write_buf
                 .contains(ClientRecordHeader::ApplicationData)