Struct opcua_server::prelude::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, StatusCode>

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

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_limits: &DecodingLimits
) -> Result<MessageChunkHeader, StatusCode>

pub fn security_header(
    &self,
    decoding_limits: &DecodingLimits
) -> Result<SecurityHeader, StatusCode>

pub fn is_open_secure_channel(&self, decoding_limits: &DecodingLimits) -> bool

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

Trait Implementations

impl BinaryEncoder<MessageChunk> for MessageChunk

fn byte_len(&self) -> usize

Returns the exact byte length of the structure as it would be if encode were called. This may be called prior to writing to ensure the correct amount of space is available.

fn encode<S>(&self, stream: &mut S) -> Result<usize, StatusCode> where
    S: Write, 

Encodes the instance to the write stream.

fn decode<S>(
    in_stream: &mut S,
    decoding_limits: &DecodingLimits
) -> Result<MessageChunk, StatusCode> where
    S: Read, 

Decodes an instance from the read stream. The decoding limits are restrictions set by the server / client on the length of strings, arrays etc. If these limits are exceeded the implementation should return with a BadDecodingError as soon as possible.

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

impl Debug for MessageChunk

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

Formats the value using the given formatter.