fixup! NFLOG MVP support

src/netfilter.rs

@@ -8,50 +8,13 @@
 use std::ffi::CString;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use byteorder::{ByteOrder, NativeEndian, NetworkEndian};
 use libc::c_int;
 
 use crate::consts::netfilter::{LogCopyMode, NfLogAttr, NfLogCfg};
 use crate::err::{DeError, SerError};
 use crate::nlattr::Nlattr;
 use crate::{Nl, StreamReadBuffer, StreamWriteBuffer};
 
-fn ntohs(n: u16) -> u16 {
-    let mut data = [0; 2];
-    NetworkEndian::write_u16(&mut data, n);
-    NativeEndian::read_u16(&data)
-}
-
-fn htons(n: u16) -> u16 {
-    let mut data = [0; 2];
-    NativeEndian::write_u16(&mut data, n);
-    NetworkEndian::read_u16(&data)
-}
-
-fn ntohl(n: u32) -> u32 {
-    let mut data = [0; 4];
-    NetworkEndian::write_u32(&mut data, n);
-    NativeEndian::read_u32(&data)
-}
-
-fn htonl(n: u32) -> u32 {
-    let mut data = [0; 4];
-    NativeEndian::write_u32(&mut data, n);
-    NetworkEndian::read_u32(&data)
-}
-
-fn ntohll(n: u64) -> u64 {
-    let mut data = [0; 8];
-    NetworkEndian::write_u64(&mut data, n);
-    NativeEndian::read_u64(&data)
-}
-
-fn htonll(n: u64) -> u64 {
-    let mut data = [0; 8];
-    NativeEndian::write_u64(&mut data, n);
-    NetworkEndian::read_u64(&data)
-}
-
 type Nlattrs = Vec<Nlattr<NfLogAttr, Vec<u8>>>;
 
 #[derive(Copy, Clone, Debug)]
@@ -62,13 +25,13 @@ struct Timestamp {
 
 impl Nl for Timestamp {
     fn serialize(&self, m: &mut StreamWriteBuffer) -> Result<(), SerError> {
-        htonll(self.secs).serialize(m)?;
-        htonll(self.usecs).serialize(m)?;
+        u64::to_be(self.secs).serialize(m)?;
+        u64::to_be(self.usecs).serialize(m)?;
         Ok(())
     }
     fn deserialize<B: AsRef<[u8]>>(m: &mut StreamReadBuffer<B>) -> Result<Self, DeError> {
-        let secs = ntohll(u64::deserialize(m)?);
-        let usecs = ntohll(u64::deserialize(m)?);
+        let secs = u64::from_be(u64::deserialize(m)?);
+        let usecs = u64::from_be(u64::deserialize(m)?);
         Ok(Self { secs, usecs })
     }
     fn size(&self) -> usize {
@@ -164,7 +127,7 @@ impl Nl for LogPacket {
     }
     fn deserialize<B: AsRef<[u8]>>(m: &mut StreamReadBuffer<B>) -> Result<Self, DeError> {
         let hint = m.take_size_hint().map(|h| h.saturating_sub(4));
-        let hw_protocol = ntohs(Nl::deserialize(m)?);
+        let hw_protocol = u16::from_be(Nl::deserialize(m)?);
         let hook = Nl::deserialize(m)?;
         let _pad: u8 = Nl::deserialize(m)?;
         m.set_size_hint(hint.unwrap_or_default());
@@ -183,7 +146,7 @@ impl Nl for LogPacket {
                 }
                 NfLogAttr::Hwaddr => {
                     let mut buffer = StreamReadBuffer::new(&attr.payload);
-                    let len = ntohs(u16::deserialize(&mut buffer)?);
+                    let len = u16::from_be(u16::deserialize(&mut buffer)?);
                     let mut hwaddr = attr.payload;
                     // Drop the len and padding
                     hwaddr.drain(..4);
@@ -201,18 +164,20 @@ impl Nl for LogPacket {
                     bytes.retain(|b| *b != 0);
                     result.prefix = CString::new(bytes).expect("Leftover null byte");
                 }
-                NfLogAttr::IfindexIndev => result.ifindex_in = Some(ntohl(attr.get_payload_as()?)),
+                NfLogAttr::IfindexIndev => {
+                    result.ifindex_in = Some(u32::from_be(attr.get_payload_as()?))
+                }
                 NfLogAttr::IfindexOutdev => {
-                    result.ifindex_out = Some(ntohl(attr.get_payload_as()?))
+                    result.ifindex_out = Some(u32::from_be(attr.get_payload_as()?))
                 }
                 NfLogAttr::IfindexPhyindev => {
-                    result.ifindex_physin = Some(ntohl(attr.get_payload_as()?))
+                    result.ifindex_physin = Some(u32::from_be(attr.get_payload_as()?))
                 }
                 NfLogAttr::IfindexPhyoutdev => {
-                    result.ifindex_physout = Some(ntohl(attr.get_payload_as()?))
+                    result.ifindex_physout = Some(u32::from_be(attr.get_payload_as()?))
                 }
-                NfLogAttr::Uid => result.uid = Some(ntohl(attr.get_payload_as()?)),
-                NfLogAttr::Gid => result.gid = Some(ntohl(attr.get_payload_as()?)),
+                NfLogAttr::Uid => result.uid = Some(u32::from_be(attr.get_payload_as()?)),
+                NfLogAttr::Gid => result.gid = Some(u32::from_be(attr.get_payload_as()?)),
                 _ => (),
             }
         }
@@ -271,7 +236,7 @@ impl Nl for LogConfigReq {
         self.family.serialize(m)?;
         // protocol version
         0u8.serialize(m)?;
-        htons(self.group).serialize(m)?;
+        u16::to_be(self.group).serialize(m)?;
         self.attrs.serialize(m)?;
         self.pad(m)?;
         Ok(())
@@ -298,14 +263,14 @@ pub struct LogConfigMode {
 
 impl Nl for LogConfigMode {
     fn serialize(&self, m: &mut StreamWriteBuffer) -> Result<(), SerError> {
-        htonl(self.copy_range).serialize(m)?;
+        u32::to_be(self.copy_range).serialize(m)?;
         self.copy_mode.serialize(m)?;
         // A padding
         0u8.serialize(m)?;
         Ok(())
     }
     fn deserialize<B: AsRef<[u8]>>(m: &mut StreamReadBuffer<B>) -> Result<Self, DeError> {
-        let copy_range = ntohl(u32::deserialize(m)?);
+        let copy_range = u32::from_be(u32::deserialize(m)?);
         let copy_mode = LogCopyMode::deserialize(m)?;
         // A padding
         u8::deserialize(m)?;