Struct ClientHelloPayload

pub(crate) struct ClientHelloPayload {
    pub(crate) client_version: ProtocolVersion,
    pub(crate) random: Random,
    pub(crate) session_id: SessionId,
    pub(crate) cipher_suites: Vec<CipherSuite>,
    pub(crate) compression_methods: Vec<Compression>,
    pub(crate) extensions: Box<ClientExtensions<'static>>,
}

Fields

client_version: ProtocolVersion

random: Random

session_id: SessionId

cipher_suites: Vec<CipherSuite>

compression_methods: Vec<Compression>

extensions: Box<ClientExtensions<'static>>

Implementations

impl ClientHelloPayload

pub(crate) fn ech_inner_encoding( &self, to_compress: Vec<ExtensionType>, ) -> Vec<u8>

pub(crate) fn payload_encode(&self, bytes: &mut Vec<u8>, purpose: Encoding)

pub(crate) fn has_keyshare_extension_with_duplicates(&self) -> bool

pub(crate) fn has_certificate_compression_extension_with_duplicates( &self, ) -> bool

Methods from Deref<Target = ClientExtensions<'static>>

const ALL_EXTENSIONS: &'static [ExtensionType]

fn read_one( &mut self, r: &mut Reader<'a>, unknown: impl FnMut(ExtensionType) -> Result<(), InvalidMessage>, ) -> Result<ExtensionType, InvalidMessage>

Reads one extension typ, length and body from r.

Unhandled extensions (according to read_extension_body() are inserted into unknown_extensions)

fn read_extension_body( &mut self, typ: ExtensionType, r: &mut Reader<'a>, ) -> Result<bool, InvalidMessage>

Reads one extension body for an extension named by typ.

Returns true if handled, false otherwise.

r is fully consumed if typ is unhandled.

fn encode_one(&self, typ: ExtensionType, output: &mut Vec<u8>)

Encode one extension body for typ into output.

Adds nothing to output if typ is absent from this struct, either because it is None or unhandled by this struct.

pub(crate) fn collect_used(&self) -> Vec<ExtensionType>

Return a list of extensions whose items are Some

pub(crate) fn clone_one(&mut self, source: &Self, typ: ExtensionType)

Clone the value of the extension identified by typ from source to self.

Does nothing if typ is not an extension handled by this object.

pub(crate) fn clear(&mut self, typ: ExtensionType)

Remove the extension identified by typ from self.

pub(crate) fn only_contains(&self, allowed: &[ExtensionType]) -> bool

Return true if all present extensions are named in allowed

pub(crate) fn contains_any(&self, exts: &[ExtensionType]) -> bool

Return true if any extension named in exts is present.

fn contains(&self, e: ExtensionType) -> bool

pub(crate) fn used_extensions_in_encoding_order(&self) -> Vec<ExtensionType>

fn order_insensitive_extensions_in_random_order(&self) -> Vec<ExtensionType>

Returns extensions which don’t need a specific order, in randomized order.

Extensions are encoded in three portions:

• First, extensions not otherwise dealt with by other cases. These are encoded in random order, controlled by self.order_seed, and this is the set of extensions returned by this function.

• Second, extensions named in self.contiguous_extensions, in the order given by that field.

• Lastly, any ECH and PSK extensions (in that order). These are required to be last by the standard.

Trait Implementations

impl Clone for ClientHelloPayload

fn clone(&self) -> ClientHelloPayload

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Codec<'_> for ClientHelloPayload

fn encode(&self, bytes: &mut Vec<u8>)

Function for encoding itself by appending itself to the provided vec of bytes.

fn read(r: &mut Reader<'_>) -> Result<Self, InvalidMessage>

Function for decoding itself from the provided reader will return Some if the decoding was successful or None if it was not.

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

Convenience function for encoding the implementation into a vec and returning it

fn read_bytes(bytes: &'a [u8]) -> Result<Self, InvalidMessage>

Function for wrapping a call to the read function in a Reader for the slice of bytes provided

impl Debug for ClientHelloPayload

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

Formats the value using the given formatter.

impl Deref for ClientHelloPayload

type Target = ClientExtensions<'static>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ClientHelloPayload

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.