Enum ChannelCellHandler 

pub(crate) enum ChannelCellHandler {
    New(NewChannelHandler),
    Handshake(HandshakeChannelHandler),
    Open(OpenChannelHandler),
}

Channel cell handler which is always in three state.

This ALWAYS starts the handler at New. This can only be constructed from a ChannelType which forces it to start at New.

From the New state, it will automatically transition to the right state as information is attached to it (ex: link protocol version).

Variants

New(NewChannelHandler)

When a network connection opens to another endpoint, the channel is considered “New” and so we use this handler to start the handshake.

Handshake(HandshakeChannelHandler)

We opened and negotiated a VERSIONS cell. If successful, we transition to this cell handler with sole purpose to handle the handshake phase.

Open(OpenChannelHandler)

Once the handshake is successful, the channel is Open and we use this handler.

Implementations

impl ChannelCellHandler

pub(crate) fn channel_type(&self) -> ChannelType

Return the ChannelType of the inner handler.

pub(crate) fn set_link_version( &mut self, link_version: u16, ) -> Result<(), ChanError>

Set link protocol for this channel cell handler. This transition the handler into the handshake handler state.

An error is returned if the current handler is NOT the New one or if the link version is unknown.

pub(crate) fn set_open(&mut self) -> Result<(), ChanError>

This transition into the open handler state.

An error is returned if the current handler is NOT the Handshake one.

pub(crate) fn set_authenticated(&mut self) -> Result<(), ChanError>

Mark this handler as authenticated.

This can only happen during the Handshake process as a New handler can’t be authenticated from the start and an Open handler can only be opened after authentication.

pub(crate) fn take_send_log_digest(&mut self) -> Result<[u8; 32], ChanError>

The digest of bytes sent on this channel.

This should only ever be called once as it consumes the send log.

This will return an error if one of:

• The channel is not recording the send log.
• The send log digest has already been taken.
• This cell handler is not using a handshake handler.

pub(crate) fn take_recv_log_digest(&mut self) -> Result<[u8; 32], ChanError>

The digest of bytes received on this channel.

This should only ever be called once as it consumes the receive log.

This will return None if one of:

• The channel is not recording the receive log.
• The receive log digest has already been taken.
• This cell handler is not using a handshake handler.

Trait Implementations

impl Decoder for ChannelCellHandler

type Item = ChanCell<AnyChanMsg>

The type of items returned by decode

type Error = Error

The type of decoding errors.

fn decode( &mut self, src: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

Decode an item from the src BytesMut into an item

fn decode_eof( &mut self, src: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

Called when the input stream reaches EOF, signaling a last attempt to decode

impl Encoder for ChannelCellHandler

type Item<'a> = ChanCell<AnyChanMsg>

The type of items consumed by encode

type Error = Error

The type of encoding errors.

fn encode( &mut self, item: Self::Item<'_>, dst: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes an item into the BytesMut provided by dst.

impl From<ChannelType> for ChannelCellHandler

This is the only way to construct a ChannelCellHandler, from the channel type which will always start the handler at the New state.

fn from(ty: ChannelType) -> Self

Converts to this type from the input type.