Enum ConnectionState

#[non_exhaustive]
pub enum ConnectionState<'c, 'i, Data> {
    ReadTraffic(ReadTraffic<'c, 'i, Data>),
    PeerClosed,
    Closed,
    ReadEarlyData(ReadEarlyData<'c, 'i, Data>),
    EncodeTlsData(EncodeTlsData<'c, Data>),
    TransmitTlsData(TransmitTlsData<'c, Data>),
    BlockedHandshake,
    WriteTraffic(WriteTraffic<'c, Data>),
}

The state of the UnbufferedConnectionCommon object

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ReadTraffic(ReadTraffic<'c, 'i, Data>)

One, or more, application data records are available

See ReadTraffic for more details on how to use the enclosed object to access the received data.

PeerClosed

Connection has been cleanly closed by the peer.

This state is encountered at most once by each connection – it is “edge” triggered, rather than “level” triggered.

It delimits the data received from the peer, meaning you can be sure you have received all the data the peer sent.

No further application data will be received from the peer, so no further ReadTraffic states will be produced.

However, it is possible to send further application data via WriteTraffic states, or close the connection cleanly by calling WriteTraffic::queue_close_notify().

Closed

Connection has been cleanly closed by both us and the peer.

This is a terminal state. No other states will be produced for this connection.

ReadEarlyData(ReadEarlyData<'c, 'i, Data>)

One, or more, early (RTT-0) data records are available

EncodeTlsData(EncodeTlsData<'c, Data>)

A Handshake record is ready for encoding

Call EncodeTlsData::encode on the enclosed object, providing an outgoing_tls buffer to store the encoding

TransmitTlsData(TransmitTlsData<'c, Data>)

Previously encoded handshake records need to be transmitted

Transmit the contents of the outgoing_tls buffer that was passed to previous EncodeTlsData::encode calls to the peer.

After transmitting the contents, call TransmitTlsData::done on the enclosed object. The transmitted contents MUST not be sent to the peer more than once so they SHOULD be discarded at this point.

At some stages of the handshake process, it’s possible to send application-data alongside handshake records. Call TransmitTlsData::may_encrypt_app_data on the enclosed object to probe if that’s allowed.

BlockedHandshake

More TLS data is needed to continue with the handshake

Request more data from the peer and append the contents to the incoming_tls buffer that was passed to UnbufferedConnectionCommon::process_tls_records.

WriteTraffic(WriteTraffic<'c, Data>)

The handshake process has been completed.

WriteTraffic::encrypt can be called on the enclosed object to encrypt application data into an outgoing_tls buffer. Similarly, WriteTraffic::queue_close_notify can be used to encrypt a close_notify alert message into a buffer to signal the peer that the connection is being closed. Data written into outgoing_buffer by either method MAY be transmitted to the peer during this state.

Once this state has been reached, data MAY be requested from the peer and appended to an incoming_tls buffer that will be passed to a future UnbufferedConnectionCommon::process_tls_records invocation. When enough data has been appended to incoming_tls, UnbufferedConnectionCommon::process_tls_records will yield the ConnectionState::ReadTraffic state.

Trait Implementations

impl<Data> Debug for ConnectionState<'_, '_, Data>

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

Formats the value using the given formatter.

impl<'c, Data> From<EncodeTlsData<'c, Data>> for ConnectionState<'c, '_, Data>

fn from(v: EncodeTlsData<'c, Data>) -> ConnectionState<'c, '_, Data>

Converts to this type from the input type.

impl<'c, 'i, Data> From<ReadEarlyData<'c, 'i, Data>> for ConnectionState<'c, 'i, Data>

fn from(v: ReadEarlyData<'c, 'i, Data>) -> ConnectionState<'c, 'i, Data>

Converts to this type from the input type.

impl<'c, 'i, Data> From<ReadTraffic<'c, 'i, Data>> for ConnectionState<'c, 'i, Data>

fn from(v: ReadTraffic<'c, 'i, Data>) -> ConnectionState<'c, 'i, Data>

Converts to this type from the input type.

impl<'c, Data> From<TransmitTlsData<'c, Data>> for ConnectionState<'c, '_, Data>

fn from(v: TransmitTlsData<'c, Data>) -> ConnectionState<'c, '_, Data>

Converts to this type from the input type.