Avoid deadlock on data bigger than buffer by chunking

src/conn.rs

@@ -85,9 +85,23 @@ enum State<const N: usize> {
     },
 }
 
-pub type Write = (Vec<u8>, oneshot::Sender<io::Result<usize>>);
+pub type Write = (Chunk, oneshot::Sender<io::Result<usize>>);
 pub type Read = (usize, oneshot::Sender<io::Result<Vec<u8>>>);
 
+/// Chunks of a [`Write`] not yet written.
+pub struct Chunk {
+    /// Data pending write.
+    data: Vec<u8>,
+    /// The accumulated length of written chunks
+    acc_len: usize,
+}
+
+impl From<Vec<u8>> for Chunk {
+    fn from(data: Vec<u8>) -> Self {
+        Self { data, acc_len: 0 }
+    }
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct ConnectionConfig {
     pub max_packet_size: u16,
@@ -455,15 +469,27 @@ impl<const N: usize, P: ConnectionPeer> Connection<N, P> {
         }
 
         // Write as much data as possible into send buffer.
-        while let Some((data, ..)) = self.pending_writes.front() {
-            if data.len() <= send_buf.available() {
-                let (data, tx) = self.pending_writes.pop_front().unwrap();
-                send_buf.write(&data).unwrap();
-                let _ = tx.send(Ok(data.len()));
-                self.writable.notify_one();
-            } else {
+        while send_buf.available() > 0 {
+            let Some((Chunk{data, mut acc_len}, tx)) = self.pending_writes.pop_front() else {
                 break;
+            };
+            let written = send_buf.write(&data).unwrap();
+            acc_len += written;
+            if written < data.len() {
+                // not all data fit in the send buffer, chunk data
+                let mut data = data;
+                let remaining = data.split_off(data.len() - written);
+                self.pending_writes.push_front((
+                    Chunk {
+                        data: remaining,
+                        acc_len,
+                    },
+                    tx,
+                ));
+            } else {
+                let _ = tx.send(Ok(acc_len));
             }
+            self.writable.notify_one();
         }
 
         // Transmit data packets.

src/stream.rs

@@ -93,7 +93,7 @@ where
 
         let (tx, rx) = oneshot::channel();
         self.writes
-            .send((buf.to_vec(), tx))
+            .send((buf.to_vec().into(), tx))
             .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))?;
 
         match rx.await {