tls_codec: use write_all instead of write

tls_codec/src/arrays.rs

@@ -11,14 +11,8 @@ impl<const LEN: usize> Serialize for [u8; LEN] {
     #[cfg(feature = "std")]
     #[inline]
     fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
-        let written = writer.write(self)?;
-        if written == LEN {
-            Ok(written)
-        } else {
-            Err(Error::InvalidWriteLength(format!(
-                "Expected to write {LEN} bytes but only {written} were written."
-            )))
-        }
+        writer.write_all(self)?;
+        Ok(LEN)
     }
 }
 

tls_codec/src/lib.rs

@@ -77,6 +77,9 @@ pub enum Error {
     InvalidVectorLength,
 
     /// Error writing everything out.
+    ///
+    /// **Deprecated:** This error variant is not returned anymore and only kept to avoid breaking
+    /// existing code.
     InvalidWriteLength(String),
 
     /// Invalid input when trying to decode a primitive integer.

tls_codec/src/primitives.rs

@@ -32,8 +32,7 @@ impl<T: Serialize> Serialize for Option<T> {
     fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
         match self {
             Some(e) => {
-                let written = writer.write(&[1])?;
-                debug_assert_eq!(written, 1);
+                writer.write_all(&[1])?;
                 e.tls_serialize(writer).map(|l| l + 1)
             }
             None => {
@@ -156,9 +155,9 @@ macro_rules! impl_unsigned {
             #[cfg(feature = "std")]
             #[inline]
             fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
-                let written = writer.write(&self.to_be_bytes())?;
-                debug_assert_eq!(written, $bytes);
-                Ok(written)
+                let bytes = &self.to_be_bytes();
+                writer.write_all(bytes)?;
+                Ok($bytes)
             }
         }
 

tls_codec/src/tls_vec.rs

@@ -155,7 +155,9 @@ macro_rules! impl_byte_serialize {
             let mut written = <$size as Serialize>::tls_serialize(&<$size>::try_from(byte_length).unwrap(), writer)?;
 
             // Now serialize the elements
-            written += writer.write($self.as_slice())?;
+            let bytes = $self.as_slice();
+            writer.write_all(bytes)?;
+            written += bytes.len();
 
             $self.assert_written_bytes(tls_serialized_len, written)?;
             Ok(written)

tls_codec/tests/encode.rs

@@ -87,3 +87,28 @@ fn serialize_var_len_boundaries() {
     let serialized = v.tls_serialize_detached().expect("Error encoding vector");
     assert_eq!(&serialized[0..5], &[0x80, 0, 0x40, 0, 99]);
 }
+
+struct SingleByteWriter<W>(W);
+
+impl<W: std::io::Write> std::io::Write for SingleByteWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        self.0.write(&buf[..1])
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.0.flush()
+    }
+}
+
+#[test]
+fn serialize_into_short_writer() {
+    let mut short_writer = SingleByteWriter(vec![0u8; 32]);
+
+    let first = [0u8, 1, 2];
+
+    first.tls_serialize(&mut short_writer).unwrap();
+}