DRAFT: Use thiserror for error types

Cargo.toml

@@ -21,7 +21,8 @@ byteorder = "1.3.2"
 libc = "0.2.66"
 log = { version = "0.4.20", features = ["std"] }
 netlink-packet-core = { version = "0.7.0" }
-netlink-packet-utils = { version = "0.5.2" }
+netlink-packet-utils = { path = "../netlink-packet-utils" }
+thiserror = "1.0.58"
 
 [[example]]
 name = "dump_packet_links"

src/address/attribute.rs

@@ -1,17 +1,14 @@
 // SPDX-License-Identifier: MIT
 
-use std::mem::size_of;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-
-use anyhow::Context;
+use crate::address::{AddressError, AddressFlags, CacheInfo, CacheInfoBuffer};
 use byteorder::{ByteOrder, NativeEndian};
 use netlink_packet_utils::{
     nla::{DefaultNla, Nla, NlaBuffer},
     parsers::{parse_string, parse_u32},
-    DecodeError, Emitable, Parseable,
+    Emitable, Parseable,
 };
-
-use crate::address::{AddressFlags, CacheInfo, CacheInfoBuffer};
+use std::mem::size_of;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 const IFA_ADDRESS: u16 = 1;
 const IFA_LOCAL: u16 = 2;
@@ -110,7 +107,9 @@ impl Nla for AddressAttribute {
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
     for AddressAttribute
 {
-    fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
+    type Error = AddressError;
+
+    fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, AddressError> {
         let payload = buf.value();
         Ok(match buf.kind() {
             IFA_ADDRESS => {
@@ -123,11 +122,10 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                     data.copy_from_slice(&payload[0..IPV6_ADDR_LEN]);
                     Self::Address(IpAddr::from(data))
                 } else {
-                    return Err(DecodeError::from(format!(
-                        "Invalid IFA_LOCAL, got unexpected length \
-                            of payload {:?}",
-                        payload
-                    )));
+                    return Err(AddressError::ParseAttributeInvalidPayload {
+                        kind: "IFA_ADDRESS",
+                        payload_length: payload.len(),
+                    });
                 }
             }
             IFA_LOCAL => {
@@ -140,27 +138,28 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                     data.copy_from_slice(&payload[0..IPV6_ADDR_LEN]);
                     Self::Local(IpAddr::from(data))
                 } else {
-                    return Err(DecodeError::from(format!(
-                        "Invalid IFA_LOCAL, got unexpected length \
-                        of payload {:?}",
-                        payload
-                    )));
+                    return Err(AddressError::ParseAttributeInvalidPayload {
+                        kind: "IFA_LOCAL",
+                        payload_length: payload.len(),
+                    });
                 }
             }
-            IFA_LABEL => Self::Label(
-                parse_string(payload).context("invalid IFA_LABEL value")?,
-            ),
+            IFA_LABEL => Self::Label(parse_string(payload).map_err(|err| {
+                AddressError::ParseAttribute {
+                    kind: "IFA_LABEL",
+                    err,
+                }
+            })?),
             IFA_BROADCAST => {
                 if payload.len() == IPV4_ADDR_LEN {
                     let mut data = [0u8; IPV4_ADDR_LEN];
                     data.copy_from_slice(&payload[0..IPV4_ADDR_LEN]);
                     Self::Broadcast(Ipv4Addr::from(data))
                 } else {
-                    return Err(DecodeError::from(format!(
-                        "Invalid IFA_BROADCAST, got unexpected length \
-                        of IPv4 address payload {:?}",
-                        payload
-                    )));
+                    return Err(AddressError::ParseAttributeInvalidPayload {
+                        kind: "IFA_BROADCAST",
+                        payload_length: payload.len(),
+                    });
                 }
             }
             IFA_ANYCAST => {
@@ -169,37 +168,45 @@ impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
                     data.copy_from_slice(&payload[0..IPV6_ADDR_LEN]);
                     Self::Anycast(Ipv6Addr::from(data))
                 } else {
-                    return Err(DecodeError::from(format!(
-                        "Invalid IFA_ANYCAST, got unexpected length \
-                        of IPv6 address payload {:?}",
-                        payload
-                    )));
+                    return Err(AddressError::ParseAttributeInvalidPayload {
+                        kind: "IFA_ANYCAST",
+                        payload_length: payload.len(),
+                    });
                 }
             }
             IFA_CACHEINFO => Self::CacheInfo(
-                CacheInfo::parse(&CacheInfoBuffer::new(payload))
-                    .context(format!("Invalid IFA_CACHEINFO {:?}", payload))?,
+                CacheInfo::parse(&CacheInfoBuffer::new(payload)).map_err(
+                    |err| AddressError::ParseAttribute {
+                        kind: "IFA_CACHEINFO",
+                        err,
+                    },
+                )?,
             ),
             IFA_MULTICAST => {
                 if payload.len() == IPV6_ADDR_LEN {
                     let mut data = [0u8; IPV6_ADDR_LEN];
                     data.copy_from_slice(&payload[0..IPV6_ADDR_LEN]);
                     Self::Multicast(Ipv6Addr::from(data))
                 } else {
-                    return Err(DecodeError::from(format!(
-                        "Invalid IFA_MULTICAST, got unexpected length \
-                        of IPv6 address payload {:?}",
-                        payload
-                    )));
+                    return Err(AddressError::ParseAttributeInvalidPayload {
+                        kind: "IFA_MULTICAST",
+                        payload_length: payload.len(),
+                    });
                 }
             }
             IFA_FLAGS => Self::Flags(AddressFlags::from_bits_retain(
-                parse_u32(payload).context("invalid IFA_FLAGS value")?,
+                parse_u32(payload).map_err(|err| {
+                    AddressError::ParseAttribute {
+                        kind: "IFA_FLAGS",
+                        err,
+                    }
+                })?,
             )),
-            kind => Self::Other(
-                DefaultNla::parse(buf)
-                    .context(format!("unknown NLA type {kind}"))?,
-            ),
+            kind => {
+                Self::Other(DefaultNla::parse(buf).map_err(|err| {
+                    AddressError::ParseUnknownNLA { kind, err }
+                })?)
+            }
         })
     }
 }

src/address/cache_info.rs

@@ -24,6 +24,8 @@ buffer!(CacheInfoBuffer(ADDRESSS_CACHE_INFO_LEN) {
 });
 
 impl<T: AsRef<[u8]>> Parseable<CacheInfoBuffer<T>> for CacheInfo {
+    type Error = DecodeError;
+
     fn parse(buf: &CacheInfoBuffer<T>) -> Result<Self, DecodeError> {
         Ok(CacheInfo {
             ifa_preferred: buf.ifa_preferred(),

src/address/error.rs

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+use netlink_packet_utils::{nla::NlaError, DecodeError};
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum AddressError {
+    #[error(
+        "Invalid {kind}, got unexpected length of payload: {payload_length}"
+    )]
+    ParseAttributeInvalidPayload {
+        kind: &'static str,
+        payload_length: usize,
+    },
+
+    #[error("Invalid {kind} value")]
+    ParseAttribute {
+        kind: &'static str,
+        err: DecodeError,
+    },
+
+    #[error("unknown NLA {kind}")]
+    ParseUnknownNLA { kind: u16, err: DecodeError },
+
+    #[error(transparent)]
+    NlaAttribute(#[from] NlaError),
+
+    #[error("Faield to parse address buffer: {0:?}")]
+    FailedBufferInit(DecodeError),
+}

src/address/message.rs

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: MIT
 
-use anyhow::Context;
+use crate::{
+    address::{
+        AddressAttribute, AddressError, AddressHeaderFlags, AddressScope,
+    },
+    AddressFamily,
+};
 use netlink_packet_utils::{
-    nla::{NlaBuffer, NlasIterator},
+    nla::{NlaBuffer, NlaError, NlasIterator},
     traits::{Emitable, Parseable},
     DecodeError,
 };
 
-use crate::{
-    address::{AddressAttribute, AddressHeaderFlags, AddressScope},
-    AddressFamily,
-};
-
 const ADDRESS_HEADER_LEN: usize = 8;
 
 buffer!(AddressMessageBuffer(ADDRESS_HEADER_LEN) {
@@ -26,7 +26,7 @@ buffer!(AddressMessageBuffer(ADDRESS_HEADER_LEN) {
 impl<'a, T: AsRef<[u8]> + ?Sized> AddressMessageBuffer<&'a T> {
     pub fn attributes(
         &self,
-    ) -> impl Iterator<Item = Result<NlaBuffer<&'a [u8]>, DecodeError>> {
+    ) -> impl Iterator<Item = Result<NlaBuffer<&'a [u8]>, NlaError>> {
         NlasIterator::new(self.payload())
     }
 }
@@ -76,7 +76,8 @@ impl Emitable for AddressMessage {
 }
 
 impl<T: AsRef<[u8]>> Parseable<AddressMessageBuffer<T>> for AddressHeader {
-    fn parse(buf: &AddressMessageBuffer<T>) -> Result<Self, DecodeError> {
+    type Error = ();
+    fn parse(buf: &AddressMessageBuffer<T>) -> Result<Self, ()> {
         Ok(Self {
             family: buf.family().into(),
             prefix_len: buf.prefix_len(),
@@ -90,20 +91,21 @@ impl<T: AsRef<[u8]>> Parseable<AddressMessageBuffer<T>> for AddressHeader {
 impl<'a, T: AsRef<[u8]> + 'a> Parseable<AddressMessageBuffer<&'a T>>
     for AddressMessage
 {
-    fn parse(buf: &AddressMessageBuffer<&'a T>) -> Result<Self, DecodeError> {
+    type Error = AddressError;
+    fn parse(buf: &AddressMessageBuffer<&'a T>) -> Result<Self, AddressError> {
         Ok(AddressMessage {
-            header: AddressHeader::parse(buf)
-                .context("failed to parse address message header")?,
-            attributes: Vec::<AddressAttribute>::parse(buf)
-                .context("failed to parse address message NLAs")?,
+            // ok to unwrap, we never fail parsing the header.
+            header: AddressHeader::parse(buf).unwrap(),
+            attributes: Vec::<AddressAttribute>::parse(buf)?,
         })
     }
 }
 
 impl<'a, T: AsRef<[u8]> + 'a> Parseable<AddressMessageBuffer<&'a T>>
     for Vec<AddressAttribute>
 {
-    fn parse(buf: &AddressMessageBuffer<&'a T>) -> Result<Self, DecodeError> {
+    type Error = AddressError;
+    fn parse(buf: &AddressMessageBuffer<&'a T>) -> Result<Self, AddressError> {
         let mut attributes = vec![];
         for nla_buf in buf.attributes() {
             attributes.push(AddressAttribute::parse(&nla_buf?)?);

src/address/mod.rs

@@ -4,6 +4,7 @@ mod addr_flags;
 mod addr_scope;
 mod attribute;
 mod cache_info;
+mod error;
 mod message;
 
 #[cfg(test)]
@@ -13,4 +14,5 @@ pub use self::addr_flags::{AddressFlags, AddressHeaderFlags};
 pub use self::addr_scope::AddressScope;
 pub use self::attribute::AddressAttribute;
 pub use self::cache_info::{CacheInfo, CacheInfoBuffer};
+pub use self::error::AddressError;
 pub use self::message::{AddressHeader, AddressMessage, AddressMessageBuffer};

src/link/af_spec/bridge.rs

@@ -52,6 +52,7 @@ impl nla::Nla for AfSpecBridge {
 }
 
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for AfSpecBridge {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         use self::AfSpecBridge::*;
 
@@ -80,6 +81,7 @@ pub(crate) struct VecAfSpecBridge(pub(crate) Vec<AfSpecBridge>);
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
     for VecAfSpecBridge
 {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let mut nlas = vec![];
         let err = "Invalid AF_INET NLA for IFLA_AF_SPEC(AF_BRIDGE)";

src/link/af_spec/inet.rs

@@ -27,6 +27,7 @@ pub(crate) struct VecAfSpecInet(pub(crate) Vec<AfSpecInet>);
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
     for VecAfSpecInet
 {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let mut nlas = vec![];
         let err = "Invalid AF_INET NLA for IFLA_AF_SPEC(AF_UNSPEC)";
@@ -65,6 +66,7 @@ impl nla::Nla for AfSpecInet {
 }
 
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for AfSpecInet {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         use self::AfSpecInet::*;
 
@@ -162,6 +164,7 @@ pub struct InetDevConf {
 }
 
 impl<T: AsRef<[u8]>> Parseable<InetDevConfBuffer<T>> for InetDevConf {
+    type Error = DecodeError;
     fn parse(buf: &InetDevConfBuffer<T>) -> Result<Self, DecodeError> {
         Ok(Self {
             forwarding: buf.forwarding(),

src/link/af_spec/inet6.rs

@@ -53,6 +53,7 @@ pub(crate) struct VecAfSpecInet6(pub(crate) Vec<AfSpecInet6>);
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
     for VecAfSpecInet6
 {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let mut nlas = vec![];
         let err = "Invalid AF_INET6 NLA for IFLA_AF_SPEC(AF_UNSPEC)";
@@ -111,6 +112,7 @@ impl Nla for AfSpecInet6 {
 }
 
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for AfSpecInet6 {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         use self::AfSpecInet6::*;
 

src/link/af_spec/inet6_cache.rs

@@ -24,6 +24,7 @@ buffer!(Inet6CacheInfoBuffer(LINK_INET6_CACHE_INFO_LEN) {
 });
 
 impl<T: AsRef<[u8]>> Parseable<Inet6CacheInfoBuffer<T>> for Inet6CacheInfo {
+    type Error = DecodeError;
     fn parse(buf: &Inet6CacheInfoBuffer<T>) -> Result<Self, DecodeError> {
         Ok(Self {
             max_reasm_len: buf.max_reasm_len(),

src/link/af_spec/inet6_devconf.rs

@@ -72,6 +72,7 @@ buffer!(Inet6DevConfBuffer(LINK_INET6_DEV_CONF_LEN) {
 });
 
 impl<T: AsRef<[u8]>> Parseable<Inet6DevConfBuffer<T>> for Inet6DevConf {
+    type Error = DecodeError;
     fn parse(buf: &Inet6DevConfBuffer<T>) -> Result<Self, DecodeError> {
         Ok(Self {
             forwarding: buf.forwarding(),

src/link/af_spec/inet6_icmp.rs

@@ -28,6 +28,7 @@ buffer!(Icmp6StatsBuffer(ICMP6_STATS_LEN) {
 });
 
 impl<T: AsRef<[u8]>> Parseable<Icmp6StatsBuffer<T>> for Icmp6Stats {
+    type Error = DecodeError;
     fn parse(buf: &Icmp6StatsBuffer<T>) -> Result<Self, DecodeError> {
         Ok(Self {
             num: buf.num(),

src/link/af_spec/inet6_stats.rs

@@ -88,6 +88,7 @@ pub struct Inet6Stats {
 }
 
 impl<T: AsRef<[u8]>> Parseable<Inet6StatsBuffer<T>> for Inet6Stats {
+    type Error = DecodeError;
     fn parse(buf: &Inet6StatsBuffer<T>) -> Result<Self, DecodeError> {
         Ok(Self {
             num: buf.num(),

src/link/af_spec/unspec.rs

@@ -48,6 +48,7 @@ pub(crate) struct VecAfSpecUnspec(pub(crate) Vec<AfSpecUnspec>);
 impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
     for VecAfSpecUnspec
 {
+    type Error = DecodeError;
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let mut nlas = vec![];
         let err = "Invalid NLA for IFLA_AF_SPEC(AF_UNSPEC)";