errors: Copy DecodeError from netlink-core-utils

Signed-off-by: Enrique Llorente <ellorent@redhat.com>

Author: qinqon

src/buffer.rs

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use byteorder::{ByteOrder, NativeEndian};
-use netlink_packet_utils::DecodeError;
 
-use crate::{Field, Rest};
+use crate::{DecodeError, ErrorContext, Field, Rest};
 
 const LENGTH: Field = 0..4;
 const MESSAGE_TYPE: Field = 4..6;
@@ -158,7 +157,7 @@ impl<T: AsRef<[u8]>> NetlinkBuffer<T> {
     /// ```
     pub fn new_checked(buffer: T) -> Result<NetlinkBuffer<T>, DecodeError> {
         let packet = Self::new(buffer);
-        packet.check_buffer_length()?;
+        packet.check_buffer_length().context("invalid netlink buffer length")?;
         Ok(packet)
     }
 
@@ -331,7 +330,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> NetlinkBuffer<&'a T> {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> NetlinkBuffer<&'a mut T> {
+impl<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> NetlinkBuffer<&mut T> {
     /// Return a mutable pointer to the payload.
     ///
     /// # Panic

src/done.rs

@@ -3,9 +3,8 @@
 use std::mem::size_of;
 
 use byteorder::{ByteOrder, NativeEndian};
-use netlink_packet_utils::DecodeError;
 
-use crate::{Emitable, Field, Parseable, Rest};
+use crate::{DecodeError, Emitable, ErrorContext, Field, Parseable, Rest};
 
 const CODE: Field = 0..4;
 const EXTENDED_ACK: Rest = 4..;
@@ -29,7 +28,9 @@ impl<T: AsRef<[u8]>> DoneBuffer<T> {
 
     pub fn new_checked(buffer: T) -> Result<Self, DecodeError> {
         let packet = Self::new(buffer);
-        packet.check_buffer_length()?;
+        packet
+            .check_buffer_length()
+            .context("invalid DoneBuffer length")?;
         Ok(packet)
     }
 
@@ -61,7 +62,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> DoneBuffer<&'a T> {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> DoneBuffer<&'a mut T> {
+impl<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> DoneBuffer<&mut T> {
     /// Return a mutable pointer to the extended ack attributes.
     pub fn extended_ack_mut(&mut self) -> &mut [u8] {
         let data = self.buffer.as_mut();

src/error.rs

@@ -3,14 +3,92 @@
 use std::{fmt, io, mem::size_of, num::NonZeroI32};
 
 use byteorder::{ByteOrder, NativeEndian};
-use netlink_packet_utils::DecodeError;
 
 use crate::{Emitable, Field, Parseable, Rest};
 
 const CODE: Field = 0..4;
 const PAYLOAD: Rest = 4..;
 const ERROR_HEADER_LEN: usize = PAYLOAD.start;
 
+pub trait ErrorContext {
+    fn context(self, msg: &str) -> Self;
+}
+
+#[derive(Debug)]
+pub struct DecodeError {
+    msg: String,
+}
+
+impl ErrorContext for DecodeError {
+    fn context(self, msg: &str) -> Self {
+        Self {
+            msg: format!("{} caused by {}", msg, self.msg),
+        }
+    }
+}
+
+impl<T> ErrorContext for Result<T, DecodeError>
+where
+    T: Clone,
+{
+    fn context(self, msg: &str) -> Result<T, DecodeError> {
+        match self {
+            Ok(t) => Ok(t),
+            Err(e) => Err(e.context(msg)),
+        }
+    }
+}
+
+impl From<&str> for DecodeError {
+    fn from(msg: &str) -> Self {
+        Self {
+            msg: msg.to_string(),
+        }
+    }
+}
+
+impl From<String> for DecodeError {
+    fn from(msg: String) -> Self {
+        Self { msg }
+    }
+}
+
+impl From<std::string::FromUtf8Error> for DecodeError {
+    fn from(err: std::string::FromUtf8Error) -> Self {
+        Self {
+            msg: format!("Invalid UTF-8 sequence: {}", err),
+        }
+    }
+}
+
+impl std::fmt::Display for DecodeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
+impl std::error::Error for DecodeError {}
+
+impl DecodeError {
+    pub fn invalid_mac_address(received: usize) -> Self {
+        Self{
+            msg: format!("Invalid MAC address. Expected 6 bytes, received {received} bytes"),
+        }
+    }
+
+    pub fn invalid_ip_address(received: usize) -> Self {
+        Self{
+            msg: format!("Invalid IP address. Expected 4 or 16 bytes, received {received} bytes"),
+        }
+    }
+
+    pub fn invalid_number(expected: usize, received: usize) -> Self {
+        Self{
+            msg: format!("Invalid number. Expected {expected} bytes, received {received} bytes"),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
 pub struct ErrorBuffer<T> {
@@ -29,18 +107,21 @@ impl<T: AsRef<[u8]>> ErrorBuffer<T> {
 
     pub fn new_checked(buffer: T) -> Result<Self, DecodeError> {
         let packet = Self::new(buffer);
-        packet.check_buffer_length()?;
+        packet
+            .check_buffer_length()
+            .context("invalid ErrorBuffer length")?;
         Ok(packet)
     }
 
     fn check_buffer_length(&self) -> Result<(), DecodeError> {
         let len = self.buffer.as_ref().len();
         if len < ERROR_HEADER_LEN {
-            Err(format!(
-                "invalid ErrorBuffer: length is {len} but ErrorBuffer are \
+            Err(DecodeError {
+                msg: format!(
+                    "invalid ErrorBuffer: length is {len} but ErrorBuffer are \
                 at least {ERROR_HEADER_LEN} bytes"
-            )
-            .into())
+                ),
+            })
         } else {
             Ok(())
         }
@@ -65,7 +146,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> ErrorBuffer<&'a T> {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> ErrorBuffer<&'a mut T> {
+impl<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized> ErrorBuffer<&mut T> {
     /// Return a mutable pointer to the payload.
     pub fn payload_mut(&mut self) -> &mut [u8] {
         let data = self.buffer.as_mut();
@@ -199,8 +280,7 @@ mod tests {
     #[test]
     fn parse_nack() {
         // SAFETY: value is non-zero.
-        const ERROR_CODE: NonZeroI32 =
-            unsafe { NonZeroI32::new_unchecked(-1234) };
+        const ERROR_CODE: NonZeroI32 = NonZeroI32::new(-1234).unwrap();
         let mut bytes = vec![0, 0, 0, 0];
         NativeEndian::write_i32(&mut bytes, ERROR_CODE.get());
         let msg = ErrorBuffer::new_checked(&bytes)

src/header.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::DecodeError;
-
-use crate::{buffer::NETLINK_HEADER_LEN, Emitable, NetlinkBuffer, Parseable};
+use crate::{
+    buffer::NETLINK_HEADER_LEN, DecodeError, Emitable, NetlinkBuffer, Parseable,
+};
 
 /// A Netlink header representation. A netlink header has the following
 /// structure:
@@ -111,7 +111,7 @@ mod tests {
             port_number: 0,
         };
         assert_eq!(repr.buffer_len(), 16);
-        let mut buf = vec![0; 16];
+        let mut buf = [0; 16];
         repr.emit(&mut buf[..]);
         assert_eq!(&buf[..], &IP_LINK_SHOW_PKT[..16]);
     }

src/message.rs

@@ -2,13 +2,11 @@
 
 use std::fmt::Debug;
 
-use netlink_packet_utils::DecodeError;
-
 use crate::{
     payload::{NLMSG_DONE, NLMSG_ERROR, NLMSG_NOOP, NLMSG_OVERRUN},
-    DoneBuffer, DoneMessage, Emitable, ErrorBuffer, ErrorMessage,
-    NetlinkBuffer, NetlinkDeserializable, NetlinkHeader, NetlinkPayload,
-    NetlinkSerializable, Parseable,
+    DecodeError, DoneBuffer, DoneMessage, Emitable, ErrorBuffer, ErrorContext,
+    ErrorMessage, NetlinkBuffer, NetlinkDeserializable, NetlinkHeader,
+    NetlinkPayload, NetlinkSerializable, Parseable,
 };
 
 /// Represent a netlink message.
@@ -39,7 +37,8 @@ where
 {
     /// Parse the given buffer as a netlink message
     pub fn deserialize(buffer: &[u8]) -> Result<Self, DecodeError> {
-        let netlink_buffer = NetlinkBuffer::new_checked(&buffer)?;
+        let netlink_buffer = NetlinkBuffer::new_checked(&buffer)
+            .context("failed deserializing NetlinkMessage")?;
         <Self as Parseable<NetlinkBuffer<&&[u8]>>>::parse(&netlink_buffer)
     }
 }
@@ -93,27 +92,31 @@ where
         use self::NetlinkPayload::*;
 
         let header =
-            <NetlinkHeader as Parseable<NetlinkBuffer<&B>>>::parse(buf)?;
+            <NetlinkHeader as Parseable<NetlinkBuffer<&B>>>::parse(buf)
+                .context("failed parsing NetlinkHeader")?;
 
         let bytes = buf.payload();
         let payload = match header.message_type {
             NLMSG_ERROR => {
                 let msg = ErrorBuffer::new_checked(&bytes)
-                    .and_then(|buf| ErrorMessage::parse(&buf))?;
+                    .and_then(|buf| ErrorMessage::parse(&buf))
+                    .context("failed parsing NLMSG_ERROR")?;
                 Error(msg)
             }
             NLMSG_NOOP => Noop,
             NLMSG_DONE => {
                 let msg = DoneBuffer::new_checked(&bytes)
-                    .and_then(|buf| DoneMessage::parse(&buf))?;
+                    .and_then(|buf| DoneMessage::parse(&buf))
+                    .context("failed parsing NLMSG_DONE")?;
                 Done(msg)
             }
             NLMSG_OVERRUN => Overrun(bytes.to_vec()),
             message_type => match I::deserialize(&header, bytes) {
                 Err(e) => {
-                    return Err(DecodeError::Other(
-                            format!("Failed to parse message with type {message_type}: {e}").into()),
-                    );
+                    return Err(format!(
+                        "Failed to parse message with type {message_type}: {e}"
+                    )
+                    .into())
                 }
                 Ok(inner_msg) => InnerMessage(inner_msg),
             },
@@ -238,8 +241,7 @@ mod tests {
     #[test]
     fn test_error() {
         // SAFETY: value is non-zero.
-        const ERROR_CODE: NonZeroI32 =
-            unsafe { NonZeroI32::new_unchecked(-8765) };
+        const ERROR_CODE: NonZeroI32 = NonZeroI32::new(-8765).unwrap();
 
         let header = NetlinkHeader::default();
         let error_msg = ErrorMessage {