Enum ConnectionError 

pub enum ConnectionError {
    Endpoint(EndpointError),
    Codec(CodecError),
    Transport(TransportError),
    VarInt(VarIntError),
    NoControlStream,
    UnexpectedEnd,
    StreamFinished,
    InvalidAddress(String),
    TlsConfig(String),
    DataStreamState(&'static str),
    ControlMessageNarrowing,
}

Errors from the draft-07 connection layer.

Variants

Endpoint(EndpointError)

Endpoint state machine error.

Codec(CodecError)

Wire codec error.

Transport(TransportError)

Transport-level error.

VarInt(VarIntError)

Variable-length integer decoding error.

NoControlStream

Control stream was not opened.

UnexpectedEnd

Stream ended before a complete message was read.

StreamFinished

Stream was finished by the peer.

InvalidAddress(String)

Invalid server address string.

TlsConfig(String)

TLS configuration error.

DataStreamState(&'static str)

Data stream used out of order: an object before its header, or an Object ID that does not advance on the last one written.

ControlMessageNarrowing

A control message this build decoded for draft-07 and then could not narrow to draft-07’s own message type.

Unreachable, and that is not the same as harmless. read_control decodes with this connection’s own draft, so the AnyControlMessage it hands back can only carry this draft’s variant — but the narrowing arm is compiled in every configuration anyway, under #[allow(unreachable_patterns)] rather than a cfg naming the other drafts, because such a list has to be edited in every draft module whenever a draft is added, and a copy that omits one leaves the match non-exhaustive.

Spelled as CodecError::UnknownMessageType(0) it would not stay inert: every draft’s codec_session_error_code answers that variant Some(PROTOCOL_VIOLATION). So the day the narrowing did fail, this build’s own defect would reach a caller as the peer sent a control message type this draft does not assign, and the session must be closed with a Protocol Violation — carrying 0x00 as the codepoint that proved it. A conformance report reading that publishes a named, well-evidenced accusation against a relay for something no relay did.

A variant of its own is what stops that. draft_specific_cause answers it LocalRefusal, the facade turns that into ErrorCause::Facade, and nothing downstream can read a rule out of a cause that says nothing reached the wire. What is pinned is the consequence rather than the unreachability: nothing pins the arm’s reachability, which is exactly why the consequence must not be an accusation.

Trait Implementations

impl Debug for ConnectionError

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

Formats the value using the given formatter.

impl Display for ConnectionError

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

Formats the value using the given formatter.

impl Error for ConnectionError

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<CodecError> for ConnectionError

fn from(source: CodecError) -> Self

Converts to this type from the input type.

impl From<ConnectionError> for AnyConnectionError

Available on crate feature draft07 only.

fn from(err: ConnectionError) -> Self

Converts to this type from the input type.

impl From<DialError> for ConnectionError

fn from(e: DialError) -> Self

Maps a dial failure onto the variants this error already carries, so InvalidAddress, TlsConfig and Transport are what a caller has to match on.

LocalSocket joins InvalidAddress, and that is the answer being kept

A socket this machine would not open has a variant of its own on DialError, and it still arrives here. Not laziness about the churn — InvalidAddress is one of the variants the facade reads as ErrorCause::Facade, which is_local answers true for, and a failed bind is this side’s by definition. Routing it to Transport would read better in prose and would publish this machine’s missing IPv6 stack as the relay’s doing.

The phase is not lost, only unread on this path. A caller measuring which stage of a dial died reads DialError::phase off the dial itself; a caller who arrived at this type named a host:port and asked for a connection, not for a measurement, and a public variant here for a distinction nothing on this path reads is churn with no reader, which is why this impl stays flat.

impl From<EndpointError> for ConnectionError

fn from(source: EndpointError) -> Self

Converts to this type from the input type.

impl From<TransportError> for ConnectionError

fn from(source: TransportError) -> Self

Converts to this type from the input type.

impl From<VarIntError> for ConnectionError

fn from(source: VarIntError) -> Self

Converts to this type from the input type.