Copy netlink-packet-utils code to netlink-packet-core

Cargo.toml

@@ -14,7 +14,6 @@ description = "netlink packet types"
 [dependencies]
 anyhow = "1.0.31"
 byteorder = "1.3.2"
-netlink-packet-utils = "0.6.0"
 
 [dev-dependencies]
 netlink-packet-route = "0.13.0"

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,110 @@
 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"),
+        }
+    }
+
+    pub fn nla_buffer_too_small(buffer_len: usize, nla_len: usize) -> Self {
+        Self{
+            msg: format!("buffer has length {buffer_len}, but an NLA header is {nla_len} bytes"),
+        }
+    }
+
+    pub fn nla_length_mismatch(buffer_len: usize, nla_len: usize) -> Self {
+        Self{
+            msg: format!("buffer has length: {buffer_len}, but the NLA is {nla_len} bytes"),
+        }
+    }
+
+    pub fn nla_invalid_length(buffer_len: usize, nla_len: usize) -> Self {
+        Self{
+            msg: format!("NLA has invalid length: {nla_len} (should be at least {buffer_len} bytes)"),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
 pub struct ErrorBuffer<T> {
@@ -29,18 +125,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 +164,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 +298,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/lib.rs

@@ -268,5 +268,11 @@ pub use self::message::*;
 pub mod constants;
 pub use self::constants::*;
 
-pub(crate) use self::utils::traits::*;
-pub(crate) use netlink_packet_utils as utils;
+pub mod nla;
+pub use self::nla::*;
+
+pub mod parsers;
+pub use self::parsers::*;
+
+#[macro_use]
+mod macros;