Struct s2n_quic_core::packet::interceptor::DecoderBufferMut

pub struct DecoderBufferMut<'a> { /* private fields */ }

DecoderBufferMut is a panic-free, mutable byte buffer for decoding untrusted input

Implementations

impl<'a> DecoderBufferMut<'a>

pub fn new(bytes: &'a mut [u8]) -> DecoderBufferMut<'a>

Create a new DecoderBufferMut from a byte slice

pub fn freeze(self) -> DecoderBuffer<'a>

Freeze the mutable buffer into a DecoderBuffer

pub fn into_less_safe_slice(self) -> &'a mut [u8]

Move out the buffer’s slice. This should be used with caution, as it removes any panic protection this struct provides.

pub fn as_less_safe_slice_mut(&'a mut self) -> &'a mut [u8]

Mutably borrow the buffer’s slice. This should be used with caution, as it removes any panic protection this struct provides.

impl<'a> DecoderBufferMut<'a>

pub fn decode_slice( self, count: usize ) -> Result<(DecoderBufferMut<'a>, DecoderBufferMut<'a>), DecoderError>

Decode a slice of bytes by count, removing the slice from the current buffer

let mut data = [0, 1, 2, 3, 4];
let buffer = DecoderBufferMut::new(&mut data);

let (slice, buffer) = buffer.decode_slice(5).unwrap();
assert_eq!(slice, [0u8, 1, 2, 3, 4][..]);

assert!(buffer.is_empty());

pub fn decode<T>(self) -> Result<(T, DecoderBufferMut<'a>), DecoderError>

where T: DecoderValueMut<'a>,

Decode a value of type T, splitting the data from the current buffer

let mut data = [0, 1, 2, 3, 4, 5, 6];
let buffer = DecoderBufferMut::new(&mut data);

let (value, buffer) = buffer.decode::<u8>().unwrap();
assert_eq!(value, 0);

let (value, buffer) = buffer.decode::<u16>().unwrap();
assert_eq!(value, 258);

let (value, buffer) = buffer.decode::<u32>().unwrap();
assert_eq!(value, 50_595_078);

assert!(buffer.is_empty());

pub fn decode_slice_with_len_prefix<Length>( self ) -> Result<(DecoderBufferMut<'a>, DecoderBufferMut<'a>), DecoderError>

where Length: DecoderValueMut<'a> + TryInto<usize>,

Decode a slice prefixed by type Length, splitting the data from the current buffer. With a Length as encoded u8:

let mut data = [5, 0, 1, 2, 3, 4];
let buffer = DecoderBufferMut::new(&mut data);
let (slice, buffer) = buffer.decode_slice_with_len_prefix::<u8>().unwrap();
assert_eq!(slice, [0u8, 1, 2, 3, 4][..]);
assert!(buffer.is_empty())

With a Length as encoded u16:

let mut data = [0, 5, 0, 1, 2, 3, 4];
let buffer = DecoderBufferMut::new(&mut data);
let (slice, buffer) = buffer.decode_slice_with_len_prefix::<u16>().unwrap();
assert_eq!(slice, [0u8, 1, 2, 3, 4][..]);
assert!(buffer.is_empty())

pub fn decode_with_len_prefix<Length, T>( self ) -> Result<(T, DecoderBufferMut<'a>), DecoderError>

where Length: DecoderValueMut<'a> + TryInto<usize>, T: DecoderValueMut<'a>,

Decode a value of type T prefixed by type Length, splitting the data from the current buffer. With a Length as encoded u8 and T as u16:

let mut data = [2, 0, 1, 2, 3];
let buffer = DecoderBufferMut::new(&mut data);
let (value, buffer) = buffer.decode_with_len_prefix::<u8, u16>().unwrap();
assert_eq!(value, 1);
assert_eq!(buffer, [2, 3][..])

The DecoderValueMut implementation of T must consume the entire subslice otherwise an error will be returned.

let mut data = [3, 0, 1, 2];
let buffer = DecoderBufferMut::new(&mut data);
let result = buffer.decode_with_len_prefix::<u8, u16>();
assert!(result.is_err())

pub fn decode_parameterized<T>( self, parameter: <T as DecoderParameterizedValueMut<'a>>::Parameter ) -> Result<(T, DecoderBufferMut<'a>), DecoderError>

where T: DecoderParameterizedValueMut<'a>,

Decode a parameterized value of type T implementing DecoderParameterizedValueMut

pub fn skip(self, count: usize) -> Result<DecoderBufferMut<'a>, DecoderError>

Skip a count of bytes, discarding the bytes

let mut data = [0, 1, 2, 3, 4];
let buffer = DecoderBufferMut::new(&mut data);
let buffer = buffer.skip(3).unwrap();
assert_eq!(buffer, [3, 4][..]);

pub fn skip_with_len_prefix<Length>( self ) -> Result<DecoderBufferMut<'a>, DecoderError>

where Length: DecoderValueMut<'a> + TryInto<usize>,

Skip a number of bytes encoded as a length prefix of type Length With a Length encoded as u8:

let mut data = [5, 0, 1, 2, 3, 4];
let buffer = DecoderBufferMut::new(&mut data);
let buffer = buffer.skip_with_len_prefix::<u8>().unwrap();
assert!(buffer.is_empty());

pub fn skip_into_range( self, count: usize, original_buffer: &DecoderBufferMut<'_> ) -> Result<(CheckedRange, DecoderBufferMut<'a>), DecoderError>

Skip a count of bytes, returning a CheckedRange for later access

pub fn skip_into_range_with_len_prefix<Length>( self, original_buffer: &DecoderBufferMut<'_> ) -> Result<(CheckedRange, DecoderBufferMut<'a>), DecoderError>

where Length: DecoderValueMut<'a> + TryInto<usize>,

Skip a number of bytes encoded as a length prefix of type Length into a CheckedRange for later access

pub fn get_checked_range(&self, range: &CheckedRange) -> DecoderBuffer<'_>

Reads data from a CheckedRange

pub fn peek(&'a self) -> DecoderBuffer<'a>

Create a peeking DecoderBuffer from the current buffer view

let mut data = [0, 1];
let buffer = DecoderBufferMut::new(&mut data);

let peek = buffer.peek();
let (value, peek) = peek.decode::<u16>().unwrap();
assert_eq!(value, 1);
assert!(peek.is_empty());

// `buffer` still contains the previous view
assert_eq!(buffer, [0, 1][..]);

pub fn peek_byte(&self, index: usize) -> Result<u8, DecoderError>

Returns a single byte at index

let mut data = [0, 1, 2];
let buffer = DecoderBufferMut::new(&mut data);

assert_eq!(buffer.peek_byte(0).unwrap(), 0);
assert_eq!(buffer.peek_byte(1).unwrap(), 1);
assert_eq!(buffer.peek_byte(2).unwrap(), 2);

// `buffer` has not changed
assert_eq!(buffer, [0, 1, 2][..]);

pub fn peek_range( &self, range: Range<usize> ) -> Result<DecoderBuffer<'_>, DecoderError>

Returns a PeekBuffer by range

pub fn ensure_empty(&self) -> Result<(), DecoderError>

Returns an error if the buffer is not empty.

let mut data = [1];
let buffer = DecoderBufferMut::new(&mut data);

assert!(buffer.ensure_empty().is_err());
let (_, buffer) = buffer.decode::<u8>().unwrap();
assert!(buffer.ensure_empty().is_ok());

pub fn ensure_len(&self, len: usize) -> Result<(), DecoderError>

Returns an error if the buffer does not have at least len bytes.

let mut data = [0, 1, 2];
let buffer = DecoderBufferMut::new(&mut data);

assert!(buffer.ensure_len(2).is_ok());
assert!(buffer.ensure_len(5).is_err());

pub fn len(&self) -> usize

Returns the number of bytes in the buffer.

let mut data = [0, 1, 2];
let buffer = DecoderBufferMut::new(&mut data);

assert_eq!(buffer.len(), 3);
let (_, buffer) = buffer.decode::<u8>().unwrap();
assert_eq!(buffer.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the buffer has a length of 0.

let mut data = [1];
let buffer = DecoderBufferMut::new(&mut data);

assert!(!buffer.is_empty());
let (_, buffer) = buffer.decode::<u8>().unwrap();
assert!(buffer.is_empty());

pub fn as_less_safe_slice(&'a self) -> &'a [u8]

Borrows the buffer’s slice. This should be used with caution, as it removes any panic protection this struct provides.

Trait Implementations

impl<'a> Debug for DecoderBufferMut<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Decoder<'a> for DecoderBufferMut<'a>

fn decode<T: DecoderValue<'a> + DecoderValueMut<'a>>( self ) -> Result<(T, Self), DecoderError>

fn decode_slice(self, len: usize) -> Result<(Self, Self), DecoderError>

impl<'a> DecoderValueMut<'a> for DecoderBufferMut<'a>

fn decode_mut( buffer: DecoderBufferMut<'a> ) -> Result<(DecoderBufferMut<'a>, DecoderBufferMut<'a>), DecoderError>

impl EncoderValue for DecoderBufferMut<'_>

fn encode<E>(&self, encoder: &mut E)

where E: Encoder,

Encodes the value into the encoder

fn encoding_size(&self) -> usize

Returns the encoding size with no buffer constrains

fn encoding_size_for_encoder<E>(&self, _encoder: &E) -> usize

where E: Encoder,

Returns the encoding size for the given encoder’s capacity

fn encode_mut<E>(&mut self, encoder: &mut E)

where E: Encoder,

Encodes the value into the encoder, while potentially mutating the value itself

fn encode_with_len_prefix<Len, E>(&self, encoder: &mut E)

where Len: TryFrom<usize> + EncoderValue, E: Encoder, Self: Sized, <Len as TryFrom<usize>>::Error: Debug,

Encodes the value into the encoder with a prefix of Len

fn encode_to_vec(&self) -> Vec<u8>

impl<'a> From<&'a mut [u8]> for DecoderBufferMut<'a>

fn from(bytes: &'a mut [u8]) -> DecoderBufferMut<'a>

Converts to this type from the input type.

impl<'a> Hash for DecoderBufferMut<'a>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for DecoderBufferMut<'a>

fn cmp(&self, other: &DecoderBufferMut<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq<[u8]> for DecoderBufferMut<'a>

fn eq(&self, rhs: &[u8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq for DecoderBufferMut<'a>

fn eq(&self, other: &DecoderBufferMut<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for DecoderBufferMut<'a>

fn partial_cmp(&self, other: &DecoderBufferMut<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for DecoderBufferMut<'a>

impl<'a> StructuralPartialEq for DecoderBufferMut<'a>