Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    DeviceOpen,
    InvalidRuleCombination,
    UninitializedFieldError,
    InvalidInterfaceName,
    InvalidAnchorName,
    InvalidPortRange,
    InvalidLabel,
    InvalidAddressFamily,
    InvalidDirection,
    InvalidTransportProtocol,
    StateAlreadyActive,
    AnchorDoesNotExist,
    Ioctl,
}

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.

DeviceOpen

Failed to open PF control file /dev/pf

InvalidRuleCombination

The firewall rule is invalidly configured

UninitializedFieldError

A required field on a builder was not set

InvalidInterfaceName

The supplied network interface name is not compatible with PF

InvalidAnchorName

The supplied anchor name in not compatible with PF

InvalidPortRange

The supplied port is an invalid range

InvalidLabel

The supplied rule label is not compatible with PF.

InvalidAddressFamily

The address family is invalid

InvalidDirection

The direction is invalid

InvalidTransportProtocol

The transport protocol is invalid

StateAlreadyActive

The target state was already active

AnchorDoesNotExist

This PF anchor does not exist

Ioctl

System returned an error during ioctl system call

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Hash for ErrorKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ErrorKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ErrorKind

impl Eq for ErrorKind

impl StructuralPartialEq for ErrorKind