Struct MessageChunk 

pub struct MessageChunk {
    pub data: Vec<u8>,
}

A chunk holds a message or a portion of a message, if the message has been split into multiple chunks. The chunk’s data may be signed and encrypted. To extract the message requires all the chunks to be available in sequence so they can be formed back into the message.

Fields

data: Vec<u8>

All of the chunk’s data including headers, payload, padding, signature

Implementations

impl MessageChunk

pub fn new( sequence_number: u32, request_id: u32, message_type: MessageChunkType, is_final: MessageIsFinalType, secure_channel: &SecureChannel, data: &[u8], ) -> Result<MessageChunk, Error>

Create a new message chunk.

pub fn body_size_from_message_size( message_type: MessageChunkType, secure_channel: &SecureChannel, max_chunk_size: usize, ) -> Result<usize, Error>

Calculates the body size that fit inside of a message chunk of a particular size. This requires calculating the size of the header, the signature, padding etc. and deducting it to reveal the message size

pub fn message_header( &self, decoding_options: &DecodingOptions, ) -> Result<MessageChunkHeader, Error>

Decode the message header from the inner data.

pub fn is_open_secure_channel(&self, decoding_options: &DecodingOptions) -> bool

Check if this message is an OpenSecureChannel request.

pub fn chunk_info( &self, secure_channel: &SecureChannel, ) -> Result<ChunkInfo, Error>

Decode info about this chunk.

Trait Implementations

impl Debug for MessageChunk

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

Formats the value using the given formatter.

impl SimpleBinaryDecodable for MessageChunk

fn decode<S>( in_stream: &mut S, decoding_options: &DecodingOptions, ) -> Result<MessageChunk, Error>

where S: Read + ?Sized,

Decode Self from the byte stream.

impl SimpleBinaryEncodable for MessageChunk

fn byte_len(&self) -> usize

This may be called prior to writing to ensure the correct amount of space is available.

fn encode<S>(&self, stream: &mut S) -> Result<(), Error>

where S: Write + ?Sized,

Encodes the instance to the write stream.

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

Convenience method for encoding a message straight into an array of bytes. It is preferable to reuse buffers than to call this so it should be reserved for tests and trivial code.