Implement SerializeBytes for TlsByteVecUX types

tls_codec/src/tls_vec.rs

@@ -13,7 +13,7 @@ use serde::ser::SerializeStruct;
 use std::io::{Read, Write};
 use zeroize::Zeroize;
 
-use crate::{Deserialize, DeserializeBytes, Error, Serialize, Size};
+use crate::{Deserialize, DeserializeBytes, Error, Serialize, SerializeBytes, Size};
 
 macro_rules! impl_size {
     ($self:ident, $size:ty, $name:ident, $len_len:literal) => {
@@ -78,6 +78,45 @@ macro_rules! impl_byte_deserialize {
             let result = Self { vec: vec.to_vec() };
             Ok((result, &remainder.get(len..).ok_or(Error::EndOfStream)?))
         }
+
+        fn serialize_bytes_bytes(&$self) -> Result<Vec<u8>, Error> {
+            let tls_serialized_len = $self.tls_serialized_len();
+            let byte_length = tls_serialized_len - $len_len;
+
+            let max_len = <$size>::MAX as usize;
+            debug_assert!(
+                byte_length <= max_len,
+                "Vector length can't be encoded in the vector length a {} >= {}",
+                byte_length,
+                max_len
+            );
+            if byte_length > max_len {
+                return Err(Error::InvalidVectorLength);
+            }
+
+            let mut vec = Vec::<u8>::with_capacity(tls_serialized_len);
+            let length_vec =  <$size as SerializeBytes>::tls_serialize(&(byte_length as $size))?;
+            let mut written = length_vec.len();
+            vec.extend_from_slice(&length_vec);
+
+            let bytes = $self.as_slice();
+            vec.extend_from_slice(bytes);
+            written += bytes.len();
+
+            debug_assert_eq!(
+                written, tls_serialized_len,
+                "{} bytes should have been serialized but {} were written",
+                tls_serialized_len, written
+            );
+            if written != tls_serialized_len {
+                return Err(Error::EncodingError(format!(
+                    "{} bytes should have been serialized but {} were written",
+                    tls_serialized_len, written
+                )));
+            }
+
+            Ok(vec)
+        }
     };
 }
 
@@ -141,7 +180,7 @@ macro_rules! impl_serialize {
                 return Err(Error::InvalidVectorLength);
             }
 
-            let mut written = (byte_length as $size).tls_serialize(writer)?;
+            let mut written =  <$size as Serialize>::tls_serialize(&(byte_length as $size), writer)?;
 
             // Now serialize the elements
             for e in $self.as_slice().iter() {
@@ -185,7 +224,7 @@ macro_rules! impl_byte_serialize {
                 return Err(Error::InvalidVectorLength);
             }
 
-            let mut written = (byte_length as $size).tls_serialize(writer)?;
+            let mut written = <$size as Serialize>::tls_serialize(&(byte_length as $size), writer)?;
 
             // Now serialize the elements
             written += writer.write($self.as_slice())?;
@@ -293,6 +332,12 @@ macro_rules! impl_tls_vec_codec_bytes {
                 Self::deserialize_bytes_bytes(bytes)
             }
         }
+
+        impl SerializeBytes for $name {
+            fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
+                self.serialize_bytes_bytes()
+            }
+        }
     };
 }
 

tls_codec/tests/encode_bytes.rs

@@ -1,4 +1,4 @@
-use tls_codec::SerializeBytes;
+use tls_codec::{SerializeBytes, TlsByteVecU16, TlsByteVecU32, TlsByteVecU8};
 
 #[test]
 fn serialize_primitives() {
@@ -40,3 +40,30 @@ fn serialize_var_len_boundaries() {
     let serialized = v.tls_serialize().expect("Error encoding vector");
     assert_eq!(&serialized[0..5], &[0x80, 0, 0x40, 0, 99]);
 }
+
+#[test]
+fn serialize_tls_byte_vec_u8() {
+    let byte_vec = TlsByteVecU8::from_slice(&[1, 2, 3]);
+    let actual_result = byte_vec
+        .tls_serialize()
+        .expect("Error encoding byte vector");
+    assert_eq!(actual_result, vec![3, 1, 2, 3]);
+}
+
+#[test]
+fn serialize_tls_byte_vec_u16() {
+    let byte_vec = TlsByteVecU16::from_slice(&[1, 2, 3]);
+    let actual_result = byte_vec
+        .tls_serialize()
+        .expect("Error encoding byte vector");
+    assert_eq!(actual_result, vec![0, 3, 1, 2, 3]);
+}
+
+#[test]
+fn serialize_tls_byte_vec_u32() {
+    let byte_vec = TlsByteVecU32::from_slice(&[1, 2, 3]);
+    let actual_result = byte_vec
+        .tls_serialize()
+        .expect("Error encoding byte vector");
+    assert_eq!(actual_result, vec![0, 0, 0, 3, 1, 2, 3]);
+}