tpacketv3: Use type definitions from libc crate

All relevant type definitions and constants are now available in libc
crate, thus use those instead of providing our own.

Author: jtt

luomu-tpacketv3/src/if_packet.rs

@@ -8,7 +8,6 @@ use std::time::{Duration, SystemTime};
 
 use luomu_libpcap::PcapFilter;
 
-mod if_packet;
 mod ringbuf;
 mod socket;
 
@@ -35,20 +34,20 @@ pub enum FanoutMode {
 
 impl FanoutMode {
     // Get the actual numeric code for this fanout mode
-    fn val(self) -> libc::c_int {
+    fn val(self) -> u32 {
         match self {
-            FanoutMode::HASH(_) => if_packet::PACKET_FANOUT_HASH,
-            FanoutMode::LB(_) => if_packet::PACKET_FANOUT_LB,
-            FanoutMode::ROLLOVER(_) => if_packet::PACKET_FANOUT_ROLLOVER,
-            FanoutMode::RND(_) => if_packet::PACKET_FANOUT_RND,
-            FanoutMode::QM(_) => if_packet::PACKET_FANOUT_QM,
-            FanoutMode::CBPF(_) => if_packet::PACKET_FANOUT_CBPF,
-            FanoutMode::EBPF(_) => if_packet::PACKET_FANOUT_EBPF,
-            FanoutMode::CPU(_) => if_packet::PACKET_FANOUT_CPU,
+            FanoutMode::HASH(_) => libc::PACKET_FANOUT_HASH,
+            FanoutMode::LB(_) => libc::PACKET_FANOUT_LB,
+            FanoutMode::ROLLOVER(_) => libc::PACKET_FANOUT_ROLLOVER,
+            FanoutMode::RND(_) => libc::PACKET_FANOUT_RND,
+            FanoutMode::QM(_) => libc::PACKET_FANOUT_QM,
+            FanoutMode::CBPF(_) => libc::PACKET_FANOUT_CBPF,
+            FanoutMode::EBPF(_) => libc::PACKET_FANOUT_EBPF,
+            FanoutMode::CPU(_) => libc::PACKET_FANOUT_CPU,
         }
     }
 
-    fn arg(self) -> i32 {
+    fn arg(self) -> u32 {
         let group_id = match self {
             FanoutMode::HASH(v)
             | FanoutMode::LB(v)
@@ -60,7 +59,7 @@ impl FanoutMode {
             | FanoutMode::CPU(v) => v,
         };
 
-        i32::from(group_id) | (self.val() << 16)
+        u32::from(group_id) | (self.val() << 16)
     }
 }
 
@@ -139,13 +138,13 @@ pub fn reader<'a>(
 
     // set version to tpacket_v3
     let opt = socket::OptValue {
-        val: if_packet::TPACKET_V3,
+        val: libc::tpacket_versions::TPACKET_V3,
     };
     tracing::trace!("Setting packet version");
     sock.setopt(&socket::Option::PacketVersion(opt))
         .map_err(|e| format!("packet version sockopt failed: {e}"))?;
 
-    let req = if_packet::tpacket_req3 {
+    let req = libc::tpacket_req3 {
         tp_block_size: parameters.block_size,
         tp_block_nr: parameters.block_count,
         tp_frame_size: parameters.frame_size,
@@ -260,7 +259,7 @@ impl<'a> Reader<'a> {
     /// packets captured (first element) and dropped (second element) or
     /// Err if stats could not be read.
     pub fn stats(&self) -> Result<(u32, u32), String> {
-        let t_stats = if_packet::tpacket_stats_v3 {
+        let t_stats = libc::tpacket_stats_v3 {
             tp_packets: 0,
             tp_drops: 0,
             tp_freeze_q_cnt: 0,

luomu-tpacketv3/src/lib.rs

@@ -1,19 +1,18 @@
-use crate::if_packet;
 use std::fmt;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 /// Descriptor for single packet within a block in mmapped ringbuffer
 pub struct PacketDescriptor<'a> {
     ptr: *mut u8,
-    hdr: &'a if_packet::tpacket3_hdr,
+    hdr: &'a libc::tpacket3_hdr,
 }
 
 impl<'a> PacketDescriptor<'a> {
     #[allow(clippy::cast_ptr_alignment)]
     pub fn get_next(self) -> PacketDescriptor<'a> {
         let next_offset = isize::try_from(self.hdr.tp_next_offset).unwrap_or(isize::MAX);
         let next_ptr = unsafe { self.ptr.offset(next_offset) };
-        let next_hdr_ptr = next_ptr as *const if_packet::tpacket3_hdr;
+        let next_hdr_ptr = next_ptr as *const libc::tpacket3_hdr;
         PacketDescriptor {
             ptr: next_ptr,
             hdr: unsafe { next_hdr_ptr.as_ref().unwrap() },
@@ -32,11 +31,11 @@ impl<'a> PacketDescriptor<'a> {
     }
 
     pub fn has_vlan_tci(&self) -> bool {
-        (self.hdr.tp_status & if_packet::TP_STATUS_VLAN_VALID) == if_packet::TP_STATUS_VLAN_VALID
+        (self.hdr.tp_status & libc::TP_STATUS_VLAN_VALID) == libc::TP_STATUS_VLAN_VALID
     }
 
     pub fn has_vlan_tpid(&self) -> bool {
-        (self.hdr.tp_status & if_packet::TP_STATUS_VLAN_TPID_VALID) == if_packet::TP_STATUS_VLAN_TPID_VALID
+        (self.hdr.tp_status & libc::TP_STATUS_VLAN_TPID_VALID) == libc::TP_STATUS_VLAN_TPID_VALID
     }
 
     pub fn get_vlan_tci(&self) -> u32 {
@@ -51,7 +50,7 @@ impl<'a> PacketDescriptor<'a> {
 impl From<*mut u8> for PacketDescriptor<'_> {
     #[allow(clippy::cast_ptr_alignment)]
     fn from(ptr: *mut u8) -> Self {
-        let hdr_ptr = ptr as *const if_packet::tpacket3_hdr;
+        let hdr_ptr = ptr as *const libc::tpacket3_hdr;
         let hdr = unsafe { hdr_ptr.as_ref().unwrap() };
         PacketDescriptor { ptr, hdr }
     }
@@ -64,35 +63,40 @@ impl From<*mut u8> for PacketDescriptor<'_> {
 /// needs to be called to indicate kernel that it free to use this block again
 #[derive(Debug)]
 pub struct BlockDescriptor<'a> {
-    ptr: *mut u8,                                // pointer to the start of the data
-    desc: &'a mut if_packet::tpacket_block_desc, // the actual block descriptor
+    ptr: *mut u8,                           // pointer to the start of the data
+    desc: &'a mut libc::tpacket_block_desc, // the actual block descriptor
 }
 
 unsafe impl Send for BlockDescriptor<'_> {}
 
 impl<'a> BlockDescriptor<'a> {
+    // Returns reference to block header
+    fn block_header(&self) -> &libc::tpacket_hdr_v1 {
+        unsafe { &self.desc.hdr.bh1 }
+    }
+
     pub fn flush(&mut self) {
-        self.desc.hdr.block_status = if_packet::TP_STATUS_KERNEL;
+        self.desc.hdr.bh1.block_status = libc::TP_STATUS_KERNEL;
     }
 
     pub fn is_ready(&self) -> bool {
-        self.desc.hdr.block_status & if_packet::TP_STATUS_USER != 0
+        self.block_header().block_status & libc::TP_STATUS_USER != 0
     }
 
     pub fn get_number_of_packets(&self) -> u32 {
-        self.desc.hdr.num_packets
+        self.block_header().num_pkts
     }
 
     pub fn get_first_packet(&self) -> PacketDescriptor<'a> {
-        let offset = isize::try_from(self.desc.hdr.offset_to_first_pkt).unwrap_or(isize::MAX);
+        let offset = isize::try_from(self.block_header().offset_to_first_pkt).unwrap_or(isize::MAX);
         unsafe { self.ptr.offset(offset) }.into()
     }
 }
 
 impl From<*mut u8> for BlockDescriptor<'_> {
     #[allow(clippy::cast_ptr_alignment)]
     fn from(ptr: *mut u8) -> Self {
-        let desc_ptr = ptr.cast::<if_packet::tpacket_block_desc>();
+        let desc_ptr = ptr.cast::<libc::tpacket_block_desc>();
 
         BlockDescriptor {
             ptr,

luomu-tpacketv3/src/ringbuf.rs

@@ -3,10 +3,6 @@ use std::time::Duration;
 
 use luomu_libpcap::PcapFilter;
 
-use crate::if_packet;
-
-const SO_ATTACH_FILTER: libc::c_int = libc::SO_ATTACH_FILTER;
-
 pub fn htons(val: u16) -> u16 {
     val.to_be()
 }
@@ -48,12 +44,12 @@ impl<T> Option<T> {
 
     fn name(&self) -> libc::c_int {
         match self {
-            Option::PacketVersion(_) => if_packet::PACKET_VERSION,
-            Option::PacketRxRing(_) => if_packet::PACKET_RX_RING,
-            Option::PacketAddMembership(_) => if_packet::PACKET_ADD_MEMBERSHIP,
-            Option::PacketStatistics(_) => if_packet::PACKET_STATISTICS,
-            Option::PacketFanout(_) => if_packet::PACKET_FANOUT,
-            Option::SocketAttachFilter(_) => SO_ATTACH_FILTER,
+            Option::PacketVersion(_) => libc::PACKET_VERSION,
+            Option::PacketRxRing(_) => libc::PACKET_RX_RING,
+            Option::PacketAddMembership(_) => libc::PACKET_ADD_MEMBERSHIP,
+            Option::PacketStatistics(_) => libc::PACKET_STATISTICS,
+            Option::PacketFanout(_) => libc::PACKET_FANOUT,
+            Option::SocketAttachFilter(_) => libc::SO_ATTACH_FILTER,
         }
     }