xdp 0.7.3

AF_XDP socket support without C dependencies
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Errors that can be returned by various calls in this crate

pub use crate::{packet::PacketError, socket::SocketError};
use std::fmt;

/// Errors that can occur when using this crate
pub enum Error {
    /// A configuration error
    Cfg(ConfigError),
    /// A packet error
    Packet(PacketError),
    /// A socket error
    Socket(SocketError),
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::Cfg(err) => err.source(),
            Self::Packet(err) => err.source(),
            Self::Socket(err) => err.source(),
        }
    }
}

impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Cfg(cerr) => {
                write!(f, "configuration error: {cerr:?}")
            }
            Self::Packet(ferr) => {
                write!(f, "packet error: {ferr:?}")
            }
            Self::Socket(serr) => {
                write!(f, "socket error: {serr:?}")
            }
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Cfg(cerr) => {
                write!(f, "configuration error: {cerr}")
            }
            Self::Packet(ferr) => {
                write!(f, "packet error: {ferr}")
            }
            Self::Socket(serr) => {
                write!(f, "socket error: {serr}")
            }
        }
    }
}

impl From<ConfigError> for Error {
    fn from(value: ConfigError) -> Self {
        Self::Cfg(value)
    }
}

impl From<SocketError> for Error {
    fn from(value: SocketError) -> Self {
        Self::Socket(value)
    }
}

impl From<PacketError> for Error {
    fn from(value: PacketError) -> Self {
        Self::Packet(value)
    }
}

/// A configuration error
#[derive(Debug)]
pub struct ConfigError {
    /// The name of the setting/field
    pub name: &'static str,
    /// The error
    pub kind: ConfigErrorKind,
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} is invalid: ", self.name)?;

        match &self.kind {
            ConfigErrorKind::Zero => f.write_str("cannot be zero"),
            ConfigErrorKind::NonPowerOf2 => f.write_str("must be a power of 2"),
            ConfigErrorKind::OutOfRange { size, range } => {
                write!(f, "value '{size}' was out of range '{range:?}")
            }
            ConfigErrorKind::MustSendOrRecv => {
                f.write_str("the socket must a tx ring or rx ring or both")
            }
        }
    }
}

impl std::error::Error for ConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

/// Different configuration errors that can occur
#[derive(Debug)]
pub enum ConfigErrorKind {
    /// Many configuration options for buffer/ring sizes require non-zero values
    Zero,
    /// Many configuration options for buffer/ring sizes require powers of 2
    NonPowerOf2,
    /// A value was out of range
    OutOfRange {
        /// The size requested by the user
        size: usize,
        /// The valid range that size did not fall within
        range: std::ops::Range<usize>,
    },
    /// It is invalid for an XDP socket to have neither a [`crate::TxRing`] nor
    /// a [`crate::RxRing`] it must have one or both
    MustSendOrRecv,
}