nla: Copy from utils

Signed-off-by: Enrique Llorente <[email protected]>

Author: qinqon

src/buffer.rs

@@ -2,7 +2,7 @@
 
 use byteorder::{ByteOrder, NativeEndian};
 
-use crate::{Field, Rest, DecodeError, ErrorContext};
+use crate::{DecodeError, ErrorContext, Field, Rest};
 
 const LENGTH: Field = 0..4;
 const MESSAGE_TYPE: Field = 4..6;

src/done.rs

@@ -4,7 +4,7 @@ use std::mem::size_of;
 
 use byteorder::{ByteOrder, NativeEndian};
 
-use crate::{Emitable, Field, Parseable, Rest, DecodeError, ErrorContext};
+use crate::{DecodeError, Emitable, ErrorContext, Field, Parseable, Rest};
 
 const CODE: Field = 0..4;
 const EXTENDED_ACK: Rest = 4..;

src/error.rs

@@ -10,7 +10,6 @@ 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;
 }
@@ -40,24 +39,21 @@ where
     }
 }
 
-
-impl From<&str> for DecodeError{
+impl From<&str> for DecodeError {
     fn from(msg: &str) -> Self {
         Self {
             msg: msg.to_string(),
         }
     }
 }
 
-impl From<String> for DecodeError{
+impl From<String> for DecodeError {
     fn from(msg: String) -> Self {
-        Self {
-            msg: msg,
-        }
+        Self { msg: msg }
     }
 }
 
-impl From<std::string::FromUtf8Error> for DecodeError{
+impl From<std::string::FromUtf8Error> for DecodeError {
     fn from(err: std::string::FromUtf8Error) -> Self {
         Self {
             msg: format!("Invalid UTF-8 sequence: {}", err),
@@ -85,12 +81,30 @@ impl DecodeError {
             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)]
@@ -118,10 +132,12 @@ impl<T: AsRef<[u8]>> ErrorBuffer<T> {
     fn check_buffer_length(&self) -> Result<(), DecodeError> {
         let len = self.buffer.as_ref().len();
         if len < ERROR_HEADER_LEN {
-            Err(DecodeError{msg: format!(
-                "invalid ErrorBuffer: length is {len} but ErrorBuffer are \
-                at least {ERROR_HEADER_LEN} bytes")
-                })
+            Err(DecodeError {
+                msg: format!(
+                    "invalid ErrorBuffer: length is {len} but ErrorBuffer are \
+                at least {ERROR_HEADER_LEN} bytes"
+                ),
+            })
         } else {
             Ok(())
         }

src/header.rs

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-
-use crate::{buffer::NETLINK_HEADER_LEN, Emitable, NetlinkBuffer, Parseable, DecodeError};
+use crate::{
+    buffer::NETLINK_HEADER_LEN, DecodeError, Emitable, NetlinkBuffer, Parseable,
+};
 
 /// A Netlink header representation. A netlink header has the following
 /// structure:

src/lib.rs

@@ -271,5 +271,8 @@ pub use self::constants::*;
 pub mod parsers;
 pub use self::parsers::*;
 
+pub mod nla;
+pub use self::nla::*;
+
 #[macro_use]
 mod macros;

src/message.rs

@@ -4,9 +4,9 @@ use std::fmt::Debug;
 
 use crate::{
     payload::{NLMSG_DONE, NLMSG_ERROR, NLMSG_NOOP, NLMSG_OVERRUN},
-    DoneBuffer, DoneMessage, Emitable, ErrorBuffer, ErrorMessage,
-    NetlinkBuffer, NetlinkDeserializable, NetlinkHeader, NetlinkPayload,
-    NetlinkSerializable, Parseable, DecodeError, ErrorContext,
+    DecodeError, DoneBuffer, DoneMessage, Emitable, ErrorBuffer, ErrorContext,
+    ErrorMessage, NetlinkBuffer, NetlinkDeserializable, NetlinkHeader,
+    NetlinkPayload, NetlinkSerializable, Parseable,
 };
 
 /// Represent a netlink message.
@@ -37,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).context("TODO")?;
+        let netlink_buffer =
+            NetlinkBuffer::new_checked(&buffer).context("TODO")?;
         <Self as Parseable<NetlinkBuffer<&&[u8]>>>::parse(&netlink_buffer)
     }
 }
@@ -91,31 +92,34 @@ where
         use self::NetlinkPayload::*;
 
         let header =
-            <NetlinkHeader as Parseable<NetlinkBuffer<&B>>>::parse(buf).context("TODO")?;
+            <NetlinkHeader as Parseable<NetlinkBuffer<&B>>>::parse(buf)
+                .context("TODO")?;
 
         let bytes = buf.payload();
-        let payload = match header.message_type {
-            NLMSG_ERROR => {
-                let msg = ErrorBuffer::new_checked(&bytes)
-                    .and_then(|buf| ErrorMessage::parse(&buf)).context("TODO")?;
-                Error(msg)
-            }
-            NLMSG_NOOP => Noop,
-            NLMSG_DONE => {
-                let msg = DoneBuffer::new_checked(&bytes)
-                    .and_then(|buf| DoneMessage::parse(&buf)).context("TODO")?;
-                Done(msg)
-            }
-            NLMSG_OVERRUN => Overrun(bytes.to_vec()),
-            message_type => match I::deserialize(&header, bytes) {
-                Err(e) => {
-                    return Err(
-                            format!("Failed to parse message with type {message_type}: {e}").into()
-                    )
+        let payload =
+            match header.message_type {
+                NLMSG_ERROR => {
+                    let msg = ErrorBuffer::new_checked(&bytes)
+                        .and_then(|buf| ErrorMessage::parse(&buf))
+                        .context("TODO")?;
+                    Error(msg)
                 }
-                Ok(inner_msg) => InnerMessage(inner_msg),
-            },
-        };
+                NLMSG_NOOP => Noop,
+                NLMSG_DONE => {
+                    let msg = DoneBuffer::new_checked(&bytes)
+                        .and_then(|buf| DoneMessage::parse(&buf))
+                        .context("TODO")?;
+                    Done(msg)
+                }
+                NLMSG_OVERRUN => Overrun(bytes.to_vec()),
+                message_type => match I::deserialize(&header, bytes) {
+                    Err(e) => return Err(format!(
+                        "Failed to parse message with type {message_type}: {e}"
+                    )
+                    .into()),
+                    Ok(inner_msg) => InnerMessage(inner_msg),
+                },
+            };
         Ok(NetlinkMessage { header, payload })
     }
 }