Struct sshpuffin::ssh::deframe::SshMessageDeframer

pub struct SshMessageDeframer {
    pub frames: VecDeque<RawSshMessage>,
    pub desynced: bool,
    buf: Box<[u8; 35000]>,
    used: usize,
}

This deframer works to reconstruct SSH messages from arbitrary-sized reads, buffering as necessary. The input is read(), the output is the frames deque.

Fields

frames: VecDeque<RawSshMessage>

Completed frames for output.

desynced: bool

Set to true if the peer is not talking SSH, but some other protocol. The caller should abort the connection, because the deframer cannot recover.

buf: Box<[u8; 35000]>

A fixed-size buffer containing the currently-accumulating TLS message.

used: usize

What size prefix of buf is used.

Implementations

impl SshMessageDeframer

pub fn new() -> Self

pub fn read(&mut self, rd: &mut dyn Read) -> Result<usize>

Read some bytes from rd, and add them to our internal buffer. If this means our internal buffer contains full messages, decode them all.

pub fn has_pending(&self) -> bool

Returns true if we have messages for the caller to process, either whole messages in our output queue or partial messages in our buffer.

fn try_deframe_one(&mut self) -> BufferContents

Does our buf contain a full message? It does if it is big enough to contain a header, and that header has a length which falls within buf. If so, deframe it and place the message onto the frames output queue.

fn buf_consume(&mut self, taken: usize)

Trait Implementations

impl Default for SshMessageDeframer

fn default() -> Self

Returns the “default value” for a type.

impl ProtocolMessageDeframer<SshProtocolTypes> for SshMessageDeframer

type OpaqueProtocolMessage = RawSshMessage

fn pop_frame(&mut self) -> Option<RawSshMessage>

fn read(&mut self, rd: &mut dyn Read) -> Result<usize>