Enum Error 

pub enum Error {
    PacketTooLarge(usize),
    FrameTooLarge(usize),
    FrameDecodingFailed(DecodeError),
    SendFailed(Error),
    RecvFailed(Error),
    Terminated,
    SessionReset,
    InvalidAttestation,
    HandshakeFailed(String),
    EncryptionFailed(String),
}

Things that can go wrong in the wire transport.

Variants

PacketTooLarge(usize)

A message exceeds the sending bound MAX_MESSAGE_SIZE.

The size is the unencrypted message length. Refusal happens before sealing, leaving the session and its encryption sequence unchanged.

FrameTooLarge(usize)

An encoded frame exceeds MAX_FRAME_SIZE.

On receive, the size counts bytes observed so far; the full frame may be larger. On send, the size is the required worst-case COBS encoding buffer. Receiving an oversized frame ends any active session; its remainder is discarded through the delimiter before another frame can be read.

FrameDecodingFailed(DecodeError)

A delimited frame is not valid COBS.

It may have carried an encrypted message, so skipping it ends any active session. A reconnecting client discards malformed stale frames while waiting for its fresh reply.

SendFailed(Error)

Writing a frame failed, possibly while setting its deadline or flushing.

std::io::ErrorKind::TimedOut reports an expired output budget or a timeout the adapter returned. The adapter may already have accepted part or all of the frame. The affected session or handshake cannot continue. This error does not close the byte stream.

RecvFailed(Error)

An adapter read or read deadline configuration failed.

Idle read timeouts and interrupted reads are retried internally. Configuration failures are returned immediately, as is expiry of an overall handshake deadline. The client ends its session; the server leaves its binding in place so the caller can decide whether to retry or disconnect. Neither side closes the stream because of this error.

Terminated

Reading reached EOF or a sender’s transport owner was already released.

Local closure also produces EOF once buffered frames have been consumed. This does not guarantee that a concurrent shutdown has finished.

SessionReset

The session ended through a reset.

The client returns it after the server’s empty frame notification, without closing the stream, so the client can reconnect. The transport server reports a session’s end through Event::Disconnected instead. The protocol server closes its session with this error on that event, and when a replacement closes its predecessor.

InvalidAttestation

The presented CWT could not be decoded as hardware or emulator claims.

This checks the token’s shape. The client’s Verifier decides whether to trust a well-formed attestation.

HandshakeFailed(String)

A handshake message could not be constructed, decoded or authenticated, or the client’s verifier rejected the attestation.

No new session is established by this attempt. The error does not close the byte stream.

EncryptionFailed(String)

A received packet could not be decrypted, or a send or receive has no current session.

Invalid incoming packets end the session. Refusing an obsolete sender leaves any replacement session unaffected.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(error: Error) -> Self

Wraps a transport error in an Arc so pending promises can share it.