Add BoundedBytes wrapper

Cargo.toml

@@ -3,7 +3,7 @@ name = "tl-proto"
 description = "A collection of traits for working with TL serialization/deserialization"
 authors = ["Ivan Kalinin <i.kalinin@dexpa.io>"]
 repository = "https://github.com/broxus/tl-proto"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 include = ["src/**/*.rs", "README.md"]
 license = "MIT"

src/seq.rs

@@ -329,6 +329,114 @@ where
  }
 }
 
+/// Bytes slice with a max length bound.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct BoundedBytes<const N: usize>([u8]);
+
+impl<const N: usize> BoundedBytes<N> {
+ /// Wraps a byte slice into a new type with length check.
+ #[inline]
+ pub const fn try_wrap(bytes: &[u8]) -> Option<&Self> {
+ if bytes.len() <= N {
+ // SAFETY: `BoundedBytes` has the same repr as `[u8]`
+ Some(unsafe { &*(bytes as *const [u8] as *const BoundedBytes<N>) })
+ } else {
+ None
+ }
+ }
+
+ /// Wraps a byte slice into a new type without any checks.
+ ///
+ /// # Safety
+ ///
+ /// The following must be true:
+ /// - `bytes` must have length not greater than `N`
+ #[inline]
+ pub unsafe fn wrap_unchecked(bytes: &[u8]) -> &Self {
+ // SAFETY: `BoundedBytes` has the same repr as `[u8]`
+ unsafe { &*(bytes as *const [u8] as *const BoundedBytes<N>) }
+ }
+}
+
+impl<const N: usize> AsRef<[u8]> for BoundedBytes<N> {
+ #[inline]
+ fn as_ref(&self) -> &[u8] {
+ &self.0
+ }
+}
+
+impl<const N: usize> AsMut<[u8]> for BoundedBytes<N> {
+ #[inline]
+ fn as_mut(&mut self) -> &mut [u8] {
+ &mut self.0
+ }
+}
+
+impl<const N: usize> std::ops::Deref for BoundedBytes<N> {
+ type Target = [u8];
+
+ #[inline]
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl<const N: usize> std::ops::DerefMut for BoundedBytes<N> {
+ #[inline]
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+impl<'a, const N: usize> TlRead<'a> for &'a BoundedBytes<N> {
+ type Repr = Bare;
+
+ #[inline]
+ fn read_from(packet: &'a [u8], offset: &mut usize) -> TlResult<Self> {
+ fn read_bytes_with_max_len<'a>(
+ packet: &'a [u8],
+ max_len: usize,
+ offset: &mut usize,
+ ) -> TlResult<&'a [u8]> {
+ let current_offset = *offset;
+ let (prefix_len, len, padding) = ok!(compute_bytes_meta(packet, current_offset));
+ if len > max_len {
+ return Err(TlError::InvalidData);
+ }
+
+ let result = unsafe {
+ std::slice::from_raw_parts(packet.as_ptr().add(current_offset + prefix_len), len)
+ };
+
+ *offset += prefix_len + len + padding;
+ Ok(result)
+ }
+
+ let result = ok!(read_bytes_with_max_len(packet, N, offset));
+
+ // SAFETY: `len <= N`
+ Ok(unsafe { BoundedBytes::wrap_unchecked(result) })
+ }
+}
+
+impl<const N: usize> TlWrite for &BoundedBytes<N> {
+ type Repr = Bare;
+
+ #[inline(always)]
+ fn max_size_hint(&self) -> usize {
+ bytes_max_size_hint(self.len())
+ }
+
+ #[inline(always)]
+ fn write_to<P>(&self, packet: &mut P)
+ where
+ P: TlPacket,
+ {
+ write_bytes(self, packet)
+ }
+}
+
 /// Helper type which is used to represent field value as bytes.
 #[derive(Debug, Clone)]
 pub struct IntermediateBytes<T>(pub T);
@@ -425,8 +533,9 @@ impl<R> PartialEq for RawBytes<'_, R> {
 
 impl<R> Copy for RawBytes<'_, R> {}
 impl<R> Clone for RawBytes<'_, R> {
+ #[inline]
  fn clone(&self) -> Self {
- Self(self.0, std::marker::PhantomData)
+ *self
  }
 }
 

test_suite/tests/tl_read.rs

@@ -1,6 +1,6 @@
 #[allow(dead_code)]
 mod tests {
- use tl_proto::{BytesMeta, TlError, TlRead, TlResult};
+ use tl_proto::{BoundedBytes, BytesMeta, TlError, TlRead, TlResult};
 
  #[derive(TlRead)]
  struct SimpleStruct {
@@ -166,4 +166,22 @@ mod tests {
  Err(TlError::UnexpectedEof)
  ));
  }
+
+ #[test]
+ fn bounded_bytes() {
+ #[derive(TlRead)]
+ struct Data<'tl> {
+ bytes: &'tl BoundedBytes<4>,
+ }
+
+ let packet = [4, 1, 2, 3, 4, 0, 0, 0];
+ let Data { bytes } = tl_proto::deserialize(&packet).unwrap();
+ assert_eq!(bytes.as_ref(), &[1, 2, 3, 4]);
+
+ let big_packet = [5, 1, 2, 3, 4, 5, 0, 0];
+ assert!(matches!(
+ tl_proto::deserialize::<Data>(&big_packet),
+ Err(TlError::InvalidData)
+ ));
+ }
 }