Use netlink-packet-core 0.8.1

Cargo.toml

@@ -12,10 +12,7 @@ repository = "https://github.com/rust-netlink/netlink-packet-netfilter"
 description = "netlink packet types for the netfilter subprotocol"
 
 [dependencies]
-anyhow = "1.0.32"
-byteorder = "1.3.4"
-netlink-packet-core = { version = "0.7.0" }
-netlink-packet-utils = { version = "0.5.1" }
+netlink-packet-core = { version = "0.8.1" }
 bitflags = "2.3"
 libc = "0.2.77"
 derive_more = "0.99.16"

src/buffer.rs

@@ -7,11 +7,9 @@ use crate::{
     },
     nflog::NfLogMessage,
 };
-use anyhow::Context;
-use netlink_packet_utils::{
-    buffer,
-    nla::{DefaultNla, NlaBuffer, NlasIterator},
-    DecodeError, Parseable, ParseableParametrized,
+use netlink_packet_core::{
+    buffer, fields, DecodeError, DefaultNla, ErrorContext, NlaBuffer,
+    NlasIterator, Parseable, ParseableParametrized,
 };
 
 buffer!(NetfilterBuffer(NETFILTER_HEADER_LEN) {
@@ -30,11 +28,10 @@ impl<'a, T: AsRef<[u8]> + ?Sized> NetfilterBuffer<&'a T> {
     where
         F: Fn(NlaBuffer<&[u8]>) -> Result<U, DecodeError>,
     {
-        Ok(self
-            .nlas()
+        self.nlas()
             .map(|buf| f(buf?))
             .collect::<Result<Vec<_>, _>>()
-            .context("failed to parse NLAs")?)
+            .context("failed to parse NLAs")
     }
 
     pub fn default_nlas(&self) -> Result<Vec<DefaultNla>, DecodeError> {

src/constants.rs

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: MIT
 
-pub use netlink_packet_core::constants::*;
-
 pub const AF_UNSPEC: u8 = libc::AF_UNSPEC as u8;
 pub const AF_UNIX: u8 = libc::AF_UNIX as u8;
 pub const AF_LOCAL: u8 = libc::AF_LOCAL as u8;

src/message.rs

@@ -1,11 +1,9 @@
 // SPDX-License-Identifier: MIT
 
 use netlink_packet_core::{
+    buffer, fields, getter, setter, DecodeError, DefaultNla, Emitable,
     NetlinkDeserializable, NetlinkHeader, NetlinkPayload, NetlinkSerializable,
-};
-use netlink_packet_utils::{
-    buffer, nla::DefaultNla, DecodeError, Emitable, Parseable,
-    ParseableParametrized,
+    Parseable, ParseableParametrized,
 };
 
 use crate::{buffer::NetfilterBuffer, nflog::NfLogMessage};

src/nflog/message.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::{
-    nla::DefaultNla, DecodeError, Emitable, Parseable, ParseableParametrized,
+use netlink_packet_core::{
+    DecodeError, DefaultNla, Emitable, Parseable, ParseableParametrized,
 };
 
 use crate::{

src/nflog/nlas/config/config_cmd.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::nla::Nla;
+use netlink_packet_core::Nla;
 
 const NFULA_CFG_CMD: u16 = libc::NFULA_CFG_CMD as u16;
 const NFULNL_CFG_CMD_NONE: u8 = libc::NFULNL_CFG_CMD_NONE as u8;

src/nflog/nlas/config/config_flags.rs

@@ -3,8 +3,7 @@
 use std::mem::size_of;
 
 use bitflags::bitflags;
-use byteorder::{BigEndian, ByteOrder};
-use netlink_packet_utils::nla::Nla;
+use netlink_packet_core::{emit_u16_be, Nla};
 
 const NFULA_CFG_FLAGS: u16 = libc::NFULA_CFG_FLAGS as u16;
 
@@ -34,6 +33,6 @@ impl Nla for ConfigFlags {
     }
 
     fn emit_value(&self, buffer: &mut [u8]) {
-        BigEndian::write_u16(buffer, self.bits());
+        emit_u16_be(buffer, self.bits()).unwrap();
     }
 }

src/nflog/nlas/config/config_mode.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::{buffer, errors::DecodeError, nla::Nla, Parseable};
+use netlink_packet_core::{
+    buffer, fields, getter, setter, DecodeError, Nla, Parseable,
+};
 
 const NFULA_CFG_MODE: u16 = libc::NFULA_CFG_MODE as u16;
 const NFULNL_COPY_NONE: u8 = libc::NFULNL_COPY_NONE as u8;

src/nflog/nlas/config/nla.rs

@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: MIT
 
-use anyhow::Context;
-use byteorder::{BigEndian, ByteOrder};
 use derive_more::{From, IsVariant};
-use netlink_packet_utils::{
-    nla::{DefaultNla, Nla, NlaBuffer},
-    parsers::{parse_u16_be, parse_u32_be, parse_u8},
-    DecodeError, Parseable,
+use netlink_packet_core::{
+    emit_u32_be, parse_u16_be, parse_u32_be, parse_u8, DecodeError, DefaultNla,
+    ErrorContext, Nla, NlaBuffer, Parseable,
 };
 
 use crate::{
@@ -63,11 +60,11 @@ impl Nla for ConfigNla {
             ConfigNla::Cmd(attr) => attr.emit_value(buffer),
             ConfigNla::Mode(attr) => attr.emit_value(buffer),
             ConfigNla::NlBufSiz(buf_siz) => {
-                BigEndian::write_u32(buffer, *buf_siz)
+                emit_u32_be(buffer, *buf_siz).unwrap();
             }
             ConfigNla::Timeout(attr) => attr.emit_value(buffer),
             ConfigNla::QThresh(q_thresh) => {
-                BigEndian::write_u32(buffer, *q_thresh)
+                emit_u32_be(buffer, *q_thresh).unwrap();
             }
             ConfigNla::Flags(attr) => attr.emit_value(buffer),
             ConfigNla::Other(attr) => attr.emit_value(buffer),

src/nflog/nlas/config/timeout.rs

@@ -2,8 +2,7 @@
 
 use std::{convert::TryInto, mem::size_of, time::Duration};
 
-use byteorder::{BigEndian, ByteOrder};
-use netlink_packet_utils::nla::Nla;
+use netlink_packet_core::{emit_u32_be, Nla};
 
 const NFULA_CFG_TIMEOUT: u16 = libc::NFULA_CFG_TIMEOUT as u16;
 
@@ -36,6 +35,6 @@ impl Nla for Timeout {
     }
 
     fn emit_value(&self, buffer: &mut [u8]) {
-        BigEndian::write_u32(buffer, self.hundredth);
+        emit_u32_be(buffer, self.hundredth).unwrap();
     }
 }

src/nflog/nlas/packet/hw_addr.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::{buffer, nla::Nla, DecodeError, Parseable};
+use netlink_packet_core::{
+    buffer, fields, getter, setter, DecodeError, Nla, Parseable,
+};
 
 use crate::constants::NFULA_HWADDR;
 

src/nflog/nlas/packet/nla.rs

@@ -2,14 +2,10 @@
 
 use std::ffi::{CStr, CString};
 
-use anyhow::Context;
-use byteorder::{BigEndian, ByteOrder};
 use derive_more::{From, IsVariant};
-
-use netlink_packet_utils::{
-    nla::{DefaultNla, Nla, NlaBuffer},
-    parsers::{parse_u16_be, parse_u32_be},
-    DecodeError, Parseable,
+use netlink_packet_core::{
+    emit_u16_be, emit_u32_be, parse_u16_be, parse_u32_be, DecodeError,
+    DefaultNla, ErrorContext, Nla, NlaBuffer, Parseable,
 };
 
 use crate::{
@@ -102,33 +98,45 @@ impl Nla for PacketNla {
     fn emit_value(&self, buffer: &mut [u8]) {
         match self {
             PacketNla::PacketHdr(attr) => attr.emit_value(buffer),
-            PacketNla::Mark(value) => BigEndian::write_u32(buffer, *value),
+            PacketNla::Mark(value) => {
+                emit_u32_be(buffer, *value).unwrap();
+            }
             PacketNla::Timestamp(attr) => attr.emit_value(buffer),
             PacketNla::IfIndexInDev(value) => {
-                BigEndian::write_u32(buffer, *value)
+                emit_u32_be(buffer, *value).unwrap();
             }
             PacketNla::IfIndexOutDev(value) => {
-                BigEndian::write_u32(buffer, *value)
+                emit_u32_be(buffer, *value).unwrap();
             }
             PacketNla::IfIndexPhysInDev(value) => {
-                BigEndian::write_u32(buffer, *value)
+                emit_u32_be(buffer, *value).unwrap();
             }
             PacketNla::IfIndexPhysOutDev(value) => {
-                BigEndian::write_u32(buffer, *value)
+                emit_u32_be(buffer, *value).unwrap();
             }
             PacketNla::HwAddr(attr) => attr.emit_value(buffer),
             PacketNla::Payload(vec) => buffer.copy_from_slice(vec),
             PacketNla::Prefix(cstring) => {
                 buffer.copy_from_slice(cstring.as_bytes_with_nul())
             }
-            PacketNla::Uid(value) => BigEndian::write_u32(buffer, *value),
-            PacketNla::Seq(value) => BigEndian::write_u32(buffer, *value),
-            PacketNla::SeqGlobal(value) => BigEndian::write_u32(buffer, *value),
-            PacketNla::Gid(value) => BigEndian::write_u32(buffer, *value),
-            PacketNla::HwType(value) => BigEndian::write_u16(buffer, *value),
+            PacketNla::Uid(value) => {
+                emit_u32_be(buffer, *value).unwrap();
+            }
+            PacketNla::Seq(value) => {
+                emit_u32_be(buffer, *value).unwrap();
+            }
+            PacketNla::SeqGlobal(value) => {
+                emit_u32_be(buffer, *value).unwrap();
+            }
+            PacketNla::Gid(value) => {
+                emit_u32_be(buffer, *value).unwrap();
+            }
+            PacketNla::HwType(value) => {
+                emit_u16_be(buffer, *value).unwrap();
+            }
             PacketNla::HwHeader(vec) => buffer.copy_from_slice(vec),
             PacketNla::HwHeaderLen(value) => {
-                BigEndian::write_u16(buffer, *value)
+                emit_u16_be(buffer, *value).unwrap();
             }
             PacketNla::Other(attr) => attr.emit_value(buffer),
         }
@@ -180,6 +188,7 @@ impl<'buffer, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'buffer T>>
             NFULA_PAYLOAD => PacketNla::Payload(payload.to_vec()),
             NFULA_PREFIX => PacketNla::Prefix(
                 CStr::from_bytes_with_nul(payload)
+                    .map_err(|e| DecodeError::from(e.to_string()))
                     .context("invalid NFULA_PREFIX value")?
                     .to_owned(),
             ),

src/nflog/nlas/packet/packet_hdr.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::{buffer, nla::Nla, DecodeError, Parseable};
+use netlink_packet_core::{
+    buffer, fields, getter, setter, DecodeError, Nla, Parseable,
+};
 
 const PACKET_HDR_LEN: usize = 4;
 pub const NFULA_PACKET_HDR: u16 = libc::NFULA_PACKET_HDR as u16;

src/nflog/nlas/packet/timestamp.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-use netlink_packet_utils::{buffer, nla::Nla, DecodeError, Parseable};
+use netlink_packet_core::{
+    buffer, fields, getter, setter, DecodeError, Nla, Parseable,
+};
 
 use crate::constants::NFULA_TIMESTAMP;