android/vendor/rustls-0.21.10/src/msgs/codec.rs - toolchain/cargo-deny - Git at Google

 use std::fmt::Debug;

 use crate::error::InvalidMessage;

 /// Wrapper over a slice of bytes that allows reading chunks from
 /// with the current position state held using a cursor.
 ///
 /// A new reader for a sub section of the the buffer can be created
 /// using the `sub` function or a section of a certain length can
 /// be obtained using the `take` function
 pub struct Reader<'a> {
     /// The underlying buffer storing the readers content
     buffer: &'a [u8],
     /// Stores the current reading position for the buffer
     cursor: usize,
 }

 impl<'a> Reader<'a> {
     /// Creates a new Reader of the provided `bytes` slice with
     /// the initial cursor position of zero.
     pub fn init(bytes: &[u8]) -> Reader {
         Reader {
             buffer: bytes,
             cursor: 0,
         }
     }

     /// Attempts to create a new Reader on a sub section of this
     /// readers bytes by taking a slice of the provided `length`
     /// will return None if there is not enough bytes
     pub fn sub(&mut self, length: usize) -> Result<Reader, InvalidMessage> {
         match self.take(length) {
             Some(bytes) => Ok(Reader::init(bytes)),
             None => Err(InvalidMessage::MessageTooShort),
         }
     }

     /// Borrows a slice of all the remaining bytes
     /// that appear after the cursor position.
     ///
     /// Moves the cursor to the end of the buffer length.
     pub fn rest(&mut self) -> &[u8] {
         let rest = &self.buffer[self.cursor..];
         self.cursor = self.buffer.len();
         rest
     }

     /// Attempts to borrow a slice of bytes from the current
     /// cursor position of `length` if there is not enough
     /// bytes remaining after the cursor to take the length
     /// then None is returned instead.
     pub fn take(&mut self, length: usize) -> Option<&[u8]> {
         if self.left() < length {
             return None;
         }
         let current = self.cursor;
         self.cursor += length;
         Some(&self.buffer[current..current + length])
     }

     /// Used to check whether the reader has any content left
     /// after the cursor (cursor has not reached end of buffer)
     pub fn any_left(&self) -> bool {
         self.cursor < self.buffer.len()
     }

     pub fn expect_empty(&self, name: &'static str) -> Result<(), InvalidMessage> {
         match self.any_left() {
             true => Err(InvalidMessage::TrailingData(name)),
             false => Ok(()),
         }
     }

     /// Returns the cursor position which is also the number
     /// of bytes that have been read from the buffer.
     pub fn used(&self) -> usize {
         self.cursor
     }

     /// Returns the number of bytes that are still able to be
     /// read (The number of remaining takes)
     pub fn left(&self) -> usize {
         self.buffer.len() - self.cursor
     }
 }

 /// Trait for implementing encoding and decoding functionality
 /// on something.
 pub trait Codec: Debug + Sized {
     /// Function for encoding itself by appending itself to
     /// the provided vec of bytes.
     fn encode(&self, bytes: &mut Vec<u8>);

     /// Function for decoding itself from the provided reader
     /// will return Some if the decoding was successful or
     /// None if it was not.
     fn read(_: &mut Reader) -> Result<Self, InvalidMessage>;

     /// Convenience function for encoding the implementation
     /// into a vec and returning it
     fn get_encoding(&self) -> Vec<u8> {
         let mut bytes = Vec::new();
         self.encode(&mut bytes);
         bytes
     }

     /// Function for wrapping a call to the read function in
     /// a Reader for the slice of bytes provided
     fn read_bytes(bytes: &[u8]) -> Result<Self, InvalidMessage> {
         let mut reader = Reader::init(bytes);
         Self::read(&mut reader)
     }
 }

 impl Codec for u8 {
     fn encode(&self, bytes: &mut Vec<u8>) {
         bytes.push(*self);
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         match r.take(1) {
             Some(&[byte]) => Ok(byte),
             _ => Err(InvalidMessage::MissingData("u8")),
         }
     }
 }

 pub fn put_u16(v: u16, out: &mut [u8]) {
     let out: &mut [u8; 2] = (&mut out[..2]).try_into().unwrap();
     *out = u16::to_be_bytes(v);
 }

 impl Codec for u16 {
     fn encode(&self, bytes: &mut Vec<u8>) {
         let mut b16 = [0u8; 2];
         put_u16(*self, &mut b16);
         bytes.extend_from_slice(&b16);
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         match r.take(2) {
             Some(&[b1, b2]) => Ok(Self::from_be_bytes([b1, b2])),
             _ => Err(InvalidMessage::MissingData("u8")),
         }
     }
 }

 // Make a distinct type for u24, even though it's a u32 underneath
 #[allow(non_camel_case_types)]
 #[derive(Debug, Copy, Clone)]
 pub struct u24(pub u32);

 #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
 impl From<u24> for usize {
     #[inline]
     fn from(v: u24) -> Self {
         v.0 as Self
     }
 }

 impl Codec for u24 {
     fn encode(&self, bytes: &mut Vec<u8>) {
         let be_bytes = u32::to_be_bytes(self.0);
         bytes.extend_from_slice(&be_bytes[1..]);
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         match r.take(3) {
             Some(&[a, b, c]) => Ok(Self(u32::from_be_bytes([0, a, b, c]))),
             _ => Err(InvalidMessage::MissingData("u24")),
         }
     }
 }

 impl Codec for u32 {
     fn encode(&self, bytes: &mut Vec<u8>) {
         bytes.extend(Self::to_be_bytes(*self));
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         match r.take(4) {
             Some(&[a, b, c, d]) => Ok(Self::from_be_bytes([a, b, c, d])),
             _ => Err(InvalidMessage::MissingData("u32")),
         }
     }
 }

 pub fn put_u64(v: u64, bytes: &mut [u8]) {
     let bytes: &mut [u8; 8] = (&mut bytes[..8]).try_into().unwrap();
     *bytes = u64::to_be_bytes(v);
 }

 impl Codec for u64 {
     fn encode(&self, bytes: &mut Vec<u8>) {
         let mut b64 = [0u8; 8];
         put_u64(*self, &mut b64);
         bytes.extend_from_slice(&b64);
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         match r.take(8) {
             Some(&[a, b, c, d, e, f, g, h]) => Ok(Self::from_be_bytes([a, b, c, d, e, f, g, h])),
             _ => Err(InvalidMessage::MissingData("u64")),
         }
     }
 }

 /// Implement `Codec` for lists of elements that implement `TlsListElement`.
 ///
 /// `TlsListElement` provides the size of the length prefix for the list.
 impl<T: Codec + TlsListElement + Debug> Codec for Vec<T> {
     fn encode(&self, bytes: &mut Vec<u8>) {
         let len_offset = bytes.len();
         bytes.extend(match T::SIZE_LEN {
             ListLength::U8 => &[0][..],
             ListLength::U16 => &[0, 0],
             ListLength::U24 { .. } => &[0, 0, 0],
         });

         for i in self {
             i.encode(bytes);
         }

         match T::SIZE_LEN {
             ListLength::U8 => {
                 let len = bytes.len() - len_offset - 1;
                 debug_assert!(len <= 0xff);
                 bytes[len_offset] = len as u8;
             }
             ListLength::U16 => {
                 let len = bytes.len() - len_offset - 2;
                 debug_assert!(len <= 0xffff);
                 let out: &mut [u8; 2] = (&mut bytes[len_offset..len_offset + 2])
                     .try_into()
                     .unwrap();
                 *out = u16::to_be_bytes(len as u16);
             }
             ListLength::U24 { .. } => {
                 let len = bytes.len() - len_offset - 3;
                 debug_assert!(len <= 0xff_ffff);
                 let len_bytes = u32::to_be_bytes(len as u32);
                 let out: &mut [u8; 3] = (&mut bytes[len_offset..len_offset + 3])
                     .try_into()
                     .unwrap();
                 out.copy_from_slice(&len_bytes[1..]);
             }
         }
     }

     fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
         let len = match T::SIZE_LEN {
             ListLength::U8 => usize::from(u8::read(r)?),
             ListLength::U16 => usize::from(u16::read(r)?),
             ListLength::U24 { max } => Ord::min(usize::from(u24::read(r)?), max),
         };

         let mut sub = r.sub(len)?;
         let mut ret = Self::new();
         while sub.any_left() {
             ret.push(T::read(&mut sub)?);
         }

         Ok(ret)
     }
 }

 /// A trait for types that can be encoded and decoded in a list.
 ///
 /// This trait is used to implement `Codec` for `Vec<T>`. Lists in the TLS wire format are
 /// prefixed with a length, the size of which depends on the type of the list elements.
 /// As such, the `Codec` implementation for `Vec<T>` requires an implementation of this trait
 /// for its element type `T`.
 ///
 // TODO: make this `pub(crate)` once our MSRV allows it?
 pub trait TlsListElement {
     const SIZE_LEN: ListLength;
 }

 /// The length of the length prefix for a list.
 ///
 /// The types that appear in lists are limited to three kinds of length prefixes:
 /// 1, 2, and 3 bytes. For the latter kind, we require a `TlsListElement` implementer
 /// to specify a maximum length.
 ///
 // TODO: make this `pub(crate)` once our MSRV allows it?
 pub enum ListLength {
     U8,
     U16,
     U24 { max: usize },
 }
	use std::fmt::Debug;

	use crate::error::InvalidMessage;

	/// Wrapper over a slice of bytes that allows reading chunks from
	/// with the current position state held using a cursor.
	///
	/// A new reader for a sub section of the the buffer can be created
	/// using the `sub` function or a section of a certain length can
	/// be obtained using the `take` function
	pub struct Reader<'a> {
	/// The underlying buffer storing the readers content
	buffer: &'a [u8],
	/// Stores the current reading position for the buffer
	cursor: usize,
	}

	impl<'a> Reader<'a> {
	/// Creates a new Reader of the provided `bytes` slice with
	/// the initial cursor position of zero.
	pub fn init(bytes: &[u8]) -> Reader {
	Reader {
	buffer: bytes,
	cursor: 0,
	}
	}

	/// Attempts to create a new Reader on a sub section of this
	/// readers bytes by taking a slice of the provided `length`
	/// will return None if there is not enough bytes
	pub fn sub(&mut self, length: usize) -> Result<Reader, InvalidMessage> {
	match self.take(length) {
	Some(bytes) => Ok(Reader::init(bytes)),
	None => Err(InvalidMessage::MessageTooShort),
	}
	}

	/// Borrows a slice of all the remaining bytes
	/// that appear after the cursor position.
	///
	/// Moves the cursor to the end of the buffer length.
	pub fn rest(&mut self) -> &[u8] {
	let rest = &self.buffer[self.cursor..];
	self.cursor = self.buffer.len();
	rest
	}

	/// Attempts to borrow a slice of bytes from the current
	/// cursor position of `length` if there is not enough
	/// bytes remaining after the cursor to take the length
	/// then None is returned instead.
	pub fn take(&mut self, length: usize) -> Option<&[u8]> {
	if self.left() < length {
	return None;
	}
	let current = self.cursor;
	self.cursor += length;
	Some(&self.buffer[current..current + length])
	}

	/// Used to check whether the reader has any content left
	/// after the cursor (cursor has not reached end of buffer)
	pub fn any_left(&self) -> bool {
	self.cursor < self.buffer.len()
	}

	pub fn expect_empty(&self, name: &'static str) -> Result<(), InvalidMessage> {
	match self.any_left() {
	true => Err(InvalidMessage::TrailingData(name)),
	false => Ok(()),
	}
	}

	/// Returns the cursor position which is also the number
	/// of bytes that have been read from the buffer.
	pub fn used(&self) -> usize {
	self.cursor
	}

	/// Returns the number of bytes that are still able to be
	/// read (The number of remaining takes)
	pub fn left(&self) -> usize {
	self.buffer.len() - self.cursor
	}
	}

	/// Trait for implementing encoding and decoding functionality
	/// on something.
	pub trait Codec: Debug + Sized {
	/// Function for encoding itself by appending itself to
	/// the provided vec of bytes.
	fn encode(&self, bytes: &mut Vec<u8>);

	/// Function for decoding itself from the provided reader
	/// will return Some if the decoding was successful or
	/// None if it was not.
	fn read(_: &mut Reader) -> Result<Self, InvalidMessage>;

	/// Convenience function for encoding the implementation
	/// into a vec and returning it
	fn get_encoding(&self) -> Vec<u8> {
	let mut bytes = Vec::new();
	self.encode(&mut bytes);
	bytes
	}

	/// Function for wrapping a call to the read function in
	/// a Reader for the slice of bytes provided
	fn read_bytes(bytes: &[u8]) -> Result<Self, InvalidMessage> {
	let mut reader = Reader::init(bytes);
	Self::read(&mut reader)
	}
	}

	impl Codec for u8 {
	fn encode(&self, bytes: &mut Vec<u8>) {
	bytes.push(*self);
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	match r.take(1) {
	Some(&[byte]) => Ok(byte),
	_ => Err(InvalidMessage::MissingData("u8")),
	}
	}
	}

	pub fn put_u16(v: u16, out: &mut [u8]) {
	let out: &mut [u8; 2] = (&mut out[..2]).try_into().unwrap();
	*out = u16::to_be_bytes(v);
	}

	impl Codec for u16 {
	fn encode(&self, bytes: &mut Vec<u8>) {
	let mut b16 = [0u8; 2];
	put_u16(*self, &mut b16);
	bytes.extend_from_slice(&b16);
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	match r.take(2) {
	Some(&[b1, b2]) => Ok(Self::from_be_bytes([b1, b2])),
	_ => Err(InvalidMessage::MissingData("u8")),
	}
	}
	}

	// Make a distinct type for u24, even though it's a u32 underneath
	#[allow(non_camel_case_types)]
	#[derive(Debug, Copy, Clone)]
	pub struct u24(pub u32);

	#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
	impl From<u24> for usize {
	#[inline]
	fn from(v: u24) -> Self {
	v.0 as Self
	}
	}

	impl Codec for u24 {
	fn encode(&self, bytes: &mut Vec<u8>) {
	let be_bytes = u32::to_be_bytes(self.0);
	bytes.extend_from_slice(&be_bytes[1..]);
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	match r.take(3) {
	Some(&[a, b, c]) => Ok(Self(u32::from_be_bytes([0, a, b, c]))),
	_ => Err(InvalidMessage::MissingData("u24")),
	}
	}
	}

	impl Codec for u32 {
	fn encode(&self, bytes: &mut Vec<u8>) {
	bytes.extend(Self::to_be_bytes(*self));
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	match r.take(4) {
	Some(&[a, b, c, d]) => Ok(Self::from_be_bytes([a, b, c, d])),
	_ => Err(InvalidMessage::MissingData("u32")),
	}
	}
	}

	pub fn put_u64(v: u64, bytes: &mut [u8]) {
	let bytes: &mut [u8; 8] = (&mut bytes[..8]).try_into().unwrap();
	*bytes = u64::to_be_bytes(v);
	}

	impl Codec for u64 {
	fn encode(&self, bytes: &mut Vec<u8>) {
	let mut b64 = [0u8; 8];
	put_u64(*self, &mut b64);
	bytes.extend_from_slice(&b64);
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	match r.take(8) {
	Some(&[a, b, c, d, e, f, g, h]) => Ok(Self::from_be_bytes([a, b, c, d, e, f, g, h])),
	_ => Err(InvalidMessage::MissingData("u64")),
	}
	}
	}

	/// Implement `Codec` for lists of elements that implement `TlsListElement`.
	///
	/// `TlsListElement` provides the size of the length prefix for the list.
	impl<T: Codec + TlsListElement + Debug> Codec for Vec<T> {
	fn encode(&self, bytes: &mut Vec<u8>) {
	let len_offset = bytes.len();
	bytes.extend(match T::SIZE_LEN {
	ListLength::U8 => &[0][..],
	ListLength::U16 => &[0, 0],
	ListLength::U24 { .. } => &[0, 0, 0],
	});

	for i in self {
	i.encode(bytes);
	}

	match T::SIZE_LEN {
	ListLength::U8 => {
	let len = bytes.len() - len_offset - 1;
	debug_assert!(len <= 0xff);
	bytes[len_offset] = len as u8;
	}
	ListLength::U16 => {
	let len = bytes.len() - len_offset - 2;
	debug_assert!(len <= 0xffff);
	let out: &mut [u8; 2] = (&mut bytes[len_offset..len_offset + 2])
	.try_into()
	.unwrap();
	*out = u16::to_be_bytes(len as u16);
	}
	ListLength::U24 { .. } => {
	let len = bytes.len() - len_offset - 3;
	debug_assert!(len <= 0xff_ffff);
	let len_bytes = u32::to_be_bytes(len as u32);
	let out: &mut [u8; 3] = (&mut bytes[len_offset..len_offset + 3])
	.try_into()
	.unwrap();
	out.copy_from_slice(&len_bytes[1..]);
	}
	}
	}

	fn read(r: &mut Reader) -> Result<Self, InvalidMessage> {
	let len = match T::SIZE_LEN {
	ListLength::U8 => usize::from(u8::read(r)?),
	ListLength::U16 => usize::from(u16::read(r)?),
	ListLength::U24 { max } => Ord::min(usize::from(u24::read(r)?), max),
	};

	let mut sub = r.sub(len)?;
	let mut ret = Self::new();
	while sub.any_left() {
	ret.push(T::read(&mut sub)?);
	}

	Ok(ret)
	}
	}

	/// A trait for types that can be encoded and decoded in a list.
	///
	/// This trait is used to implement `Codec` for `Vec<T>`. Lists in the TLS wire format are
	/// prefixed with a length, the size of which depends on the type of the list elements.
	/// As such, the `Codec` implementation for `Vec<T>` requires an implementation of this trait
	/// for its element type `T`.
	///
	// TODO: make this `pub(crate)` once our MSRV allows it?
	pub trait TlsListElement {
	const SIZE_LEN: ListLength;
	}

	/// The length of the length prefix for a list.
	///
	/// The types that appear in lists are limited to three kinds of length prefixes:
	/// 1, 2, and 3 bytes. For the latter kind, we require a `TlsListElement` implementer
	/// to specify a maximum length.
	///
	// TODO: make this `pub(crate)` once our MSRV allows it?
	pub enum ListLength {
	U8,
	U16,
	U24 { max: usize },
	}