pub struct MessageDeframer {
last_error: Option<Error>,
buf: Vec<u8>,
joining_hs: Option<HandshakePayloadMeta>,
used: usize,
}
Expand description
This deframer works to reconstruct TLS messages from a stream of arbitrary-sized reads.
It buffers incoming data into a Vec
through read()
, and returns messages through pop()
.
QUIC connections will call push()
to append handshake payload data directly.
Fields§
§last_error: Option<Error>
Set if the peer is not talking TLS, but some other protocol. The caller should abort the connection, because the deframer cannot recover.
buf: Vec<u8>
Buffer of data read from the socket, in the process of being parsed into messages.
For buffer size management, checkout out the read()
method.
joining_hs: Option<HandshakePayloadMeta>
If we’re in the middle of joining a handshake payload, this is the metadata.
used: usize
What size prefix of buf
is used.
Implementations§
source§impl MessageDeframer
impl MessageDeframer
sourcepub fn pop(
&mut self,
record_layer: &mut RecordLayer,
) -> Result<Option<Deframed>, Error>
pub fn pop( &mut self, record_layer: &mut RecordLayer, ) -> Result<Option<Deframed>, Error>
Return any decrypted messages that the deframer has been able to parse.
Returns an Error
if the deframer failed to parse some message contents or if decryption
failed, Ok(None)
if no full message is buffered or if trial decryption failed, and
Ok(Some(_))
if a valid message was found and decrypted successfully.
sourcefn set_err(&mut self, err: impl Into<Error>) -> Error
fn set_err(&mut self, err: impl Into<Error>) -> Error
Fuses this deframer’s error and returns the set value.
Any future calls to pop
will return err
again.
sourcefn append_hs(
&mut self,
version: ProtocolVersion,
payload: &[u8],
end: usize,
quic: bool,
) -> Result<HandshakePayloadState, Error>
fn append_hs( &mut self, version: ProtocolVersion, payload: &[u8], end: usize, quic: bool, ) -> Result<HandshakePayloadState, Error>
Write the handshake message contents into the buffer and update the metadata.
Returns true if a complete message is found.
sourcepub fn read(&mut self, rd: &mut dyn Read) -> Result<usize>
pub fn read(&mut self, rd: &mut dyn Read) -> Result<usize>
Read some bytes from rd
, and add them to our internal buffer.
sourcefn prepare_read(&mut self) -> Result<(), &'static str>
fn prepare_read(&mut self) -> Result<(), &'static str>
Resize the internal buf
if necessary for reading more bytes.
sourcepub fn has_pending(&self) -> bool
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.