Enum IoErrorKind 

#[non_exhaustive]
pub enum IoErrorKind {
    TimedOut,
    Interrupted,
    PermissionDenied,
    ConnectionRefused,
    NetworkUnreachable,
    WouldBlock,
    Truncated,
    Other,
}

Portable I/O error kinds surfaced by transport implementations.

This is a deliberately small vocabulary — anything that does not fit maps to IoErrorKind::Other. The enum is #[non_exhaustive] so new kinds can be added without a breaking change. Kept local to this crate (rather than re-exporting embedded_io::ErrorKind) so our public API does not move when embedded_io bumps major versions.

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.

TimedOut

The operation timed out.

Interrupted

The operation was interrupted and can be retried.

PermissionDenied

The caller lacks permission for the operation.

ConnectionRefused

A remote peer actively refused the connection / destination was unreachable.

NetworkUnreachable

The network layer rejected the operation (routing, MTU, etc.).

WouldBlock

A non-blocking call would have blocked. Transient — caller should retry or wait for readiness rather than treating as fatal.

Truncated

An inbound datagram was truncated because it exceeded the receive buffer. The datagram is discarded; the socket loop survives.

Backends that receive this signal MUST drop the datagram and continue polling — it does NOT count toward the consecutive-error kill cap. This variant is distinct from Self::Other so that genuine I/O errors are still counted as potentially-fatal.

Other

Any error that does not fit a more specific variant.

Implementations

impl IoErrorKind

pub fn is_transient_recv(self) -> bool

Returns true if a recv-loop error of this kind is a transient condition that should not count toward a “kill the loop after N consecutive errors” cap. Includes:

• Self::ConnectionRefused — a peer’s ICMP port-unreachable reply is normal noise on a SOME/IP host that probes services that are not yet available;
• Self::NetworkUnreachable — a routing blip during interface migration is recoverable;
• Self::WouldBlock — by definition, retry-on-readiness;
• Self::Interrupted — a signal interrupted the syscall;
• Self::TimedOut — caller-driven timeout, not a socket failure;
• Self::Truncated — an inbound datagram was truncated because it exceeded the receive buffer; the datagram is dropped and the loop continues (distinct from Self::Other so genuine I/O errors are still counted as potentially-fatal).

All other kinds (including Self::Other) are treated as potentially-fatal and DO count toward the cap.

Trait Implementations

impl Clone for IoErrorKind

fn clone(&self) -> IoErrorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for IoErrorKind

impl Debug for IoErrorKind

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

Formats the value using the given formatter.

impl Display for IoErrorKind

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

Formats the value using the given formatter.

impl Eq for IoErrorKind

impl Error for IoErrorKind

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 PartialEq for IoErrorKind

fn eq(&self, other: &IoErrorKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for IoErrorKind