Take timestamp at capture level, refactor code

Author: zonque

src/app.rs

@@ -14,7 +14,7 @@ use std::{
 };
 use tokio::time;
 
-use crate::types::{ClockIdentity, ProcessedPacket};
+use crate::types::{ClockIdentity, ParsedPacket};
 
 use crate::{
     ptp::{PtpHost, PtpHostState, PtpTracker},
@@ -123,7 +123,7 @@ pub struct App {
     pub auto_scroll_packets: bool,
     pub visible_packet_height: usize,
     pub show_packet_modal: bool,
-    pub modal_packet: Option<ProcessedPacket>,
+    pub modal_packet: Option<ParsedPacket>,
     pub modal_scroll_offset: usize,
     pub modal_visible_height: usize,
     pub force_redraw: bool,
@@ -984,7 +984,7 @@ impl App {
         self.sort_ascending
     }
 
-    pub fn get_packet_history(&self) -> Vec<ProcessedPacket> {
+    pub fn get_packet_history(&self) -> Vec<ParsedPacket> {
         // Return packets from the currently selected host
         if let Some(ref selected_host_id) = self.selected_host_id {
             if let Some(history) = self.ptp_tracker.get_host_packet_history(*selected_host_id) {
@@ -1174,7 +1174,7 @@ impl App {
         self.visible_packet_height = height;
     }
 
-    pub fn get_selected_packet(&self) -> Option<ProcessedPacket> {
+    pub fn get_selected_packet(&self) -> Option<ParsedPacket> {
         let packets = self.get_packet_history();
         if self.selected_packet_index < packets.len() {
             Some(packets[self.selected_packet_index].clone())
@@ -1183,7 +1183,7 @@ impl App {
         }
     }
 
-    pub fn get_modal_packet(&self) -> Option<&ProcessedPacket> {
+    pub fn get_modal_packet(&self) -> Option<&ParsedPacket> {
         self.modal_packet.as_ref()
     }
 

src/ptp.rs

@@ -9,7 +9,7 @@ use crate::{
     bounded_vec::BoundedVec,
     types::{
         AnnounceMessage, ClockIdentity, DelayRespMessage, FollowUpMessage,
-        PDelayRespFollowUpMessage, PDelayRespMessage, ProcessedPacket, PtpClockAccuracy,
+        PDelayRespFollowUpMessage, PDelayRespMessage, ParsedPacket, PtpClockAccuracy,
         PtpClockClass, PtpCorrectionField, PtpHeader, PtpMessage, PtpTimestamp, PtpUtcOffset,
         PtpVersion, SyncMessage,
     },
@@ -395,7 +395,7 @@ pub struct PtpHost {
 
     pub state: PtpHostState,
     pub last_correction_field: Option<PtpCorrectionField>,
-    pub packet_history: BoundedVec<Rc<ProcessedPacket>>,
+    pub packet_history: BoundedVec<Rc<ParsedPacket>>,
 }
 
 impl PtpHost {
@@ -475,7 +475,7 @@ impl PtpHost {
         self.ip_addresses.keys().any(|ip| local_ips.contains(ip))
     }
 
-    pub fn add_packet(&mut self, packet: Rc<ProcessedPacket>) {
+    pub fn add_packet(&mut self, packet: Rc<ParsedPacket>) {
         self.packet_history.push(packet);
     }
 
@@ -487,7 +487,7 @@ impl PtpHost {
         }
     }
 
-    pub fn get_packet_history(&self) -> Vec<ProcessedPacket> {
+    pub fn get_packet_history(&self) -> Vec<ParsedPacket> {
         self.packet_history
             .items
             .iter()
@@ -573,7 +573,8 @@ impl PtpTracker {
             // Limit iterations to prevent blocking too long
             match self.raw_socket_receiver.try_recv() {
                 Some(raw_packet) => {
-                    self.handle_raw_packet(&raw_packet).await;
+                    let raw_packet_arc = std::sync::Arc::new(raw_packet);
+                    self.handle_raw_packet(raw_packet_arc).await;
                     self.last_packet = Instant::now();
                 }
                 None => {
@@ -584,23 +585,16 @@ impl PtpTracker {
         }
     }
 
-    async fn handle_raw_packet(&mut self, raw_packet: &crate::socket::RawPacket) {
+    async fn handle_raw_packet(&mut self, raw_packet: std::sync::Arc<crate::socket::RawPacket>) {
         let msg = match PtpMessage::try_from(raw_packet.ptp_payload.as_slice()) {
             Ok(m) => m,
             Err(_) => return, // Invalid message
         };
 
         // Create packet info for recording
-        let packet = Rc::new(ProcessedPacket {
-            ptp_message: msg,
-            timestamp: std::time::Instant::now(),
-            vlan_id: raw_packet.vlan_id,
-            source_addr: raw_packet.source_addr,
-            source_mac: raw_packet.source_mac,
-            dest_addr: raw_packet.dest_addr,
-            dest_mac: raw_packet.dest_mac,
-            interface: raw_packet.interface_name.clone(),
-            raw_packet_data: raw_packet.data.clone(),
+        let packet = Rc::new(ParsedPacket {
+            ptp: msg,
+            raw: raw_packet.clone(),
         });
 
         let sending_host = self
@@ -609,7 +603,10 @@ impl PtpTracker {
             .or_insert_with(|| PtpHost::new(msg.header().source_port_identity.clock_identity));
 
         // Add this IP address if it's not already known for this host
-        sending_host.add_ip_address(raw_packet.source_addr.ip(), packet.interface.clone());
+        sending_host.add_ip_address(
+            raw_packet.source_addr.ip(),
+            packet.raw.interface_name.clone(),
+        );
 
         sending_host.total_messages_sent_count += 1;
         sending_host.update_from_ptp_header(msg.header());
@@ -792,7 +789,7 @@ impl PtpTracker {
     pub fn get_host_packet_history(
         &self,
         clock_identity: ClockIdentity,
-    ) -> Option<Vec<ProcessedPacket>> {
+    ) -> Option<Vec<ParsedPacket>> {
         self.hosts
             .get(&clock_identity)
             .map(|host| host.get_packet_history())

src/socket.rs

@@ -4,10 +4,12 @@
 //! promiscuous mode support. Works on Linux, macOS, and Windows.
 
 use anyhow::Result;
-use pcap::{Capture, Device, Linktype};
+use libc::timeval;
+use pcap::{Capture, Device, Linktype, Packet};
 use socket2::{Domain, Protocol, Socket, Type};
 use std::io;
 use std::net::{IpAddr, Ipv4Addr};
+use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::mpsc;
 use tokio::time::Duration;
 
@@ -17,6 +19,7 @@ const PTP_MULTICAST_ADDR: &str = "224.0.1.129";
 
 #[derive(Debug, Clone)]
 pub struct RawPacket {
+    pub timestamp: std::time::SystemTime,
     pub data: Vec<u8>,
     pub source_addr: std::net::SocketAddr,
     pub source_mac: [u8; 6],
@@ -155,7 +158,15 @@ fn join_multicast_group(interface_name: &str, interface_addr: Ipv4Addr) -> Resul
     Ok(socket)
 }
 
-fn process_ethernet_packet(packet_data: &[u8], interface_name: &str) -> Option<RawPacket> {
+fn timeval_to_systemtime(tv: timeval) -> SystemTime {
+    // tv_sec is seconds since epoch, tv_usec is microseconds
+    let dur = Duration::new(tv.tv_sec as u64, (tv.tv_usec as u32) * 1000);
+    UNIX_EPOCH + dur
+}
+
+fn process_ethernet_packet(packet: &Packet, interface_name: &str) -> Option<RawPacket> {
+    let packet_data = packet.data;
+
     // Minimum Ethernet frame size check
     if packet_data.len() < 14 {
         return None;
@@ -251,6 +262,7 @@ fn process_ethernet_packet(packet_data: &[u8], interface_name: &str) -> Option<R
     let dest_addr = std::net::SocketAddr::V4(std::net::SocketAddrV4::new(dest_ip, dest_port));
 
     Some(RawPacket {
+        timestamp: timeval_to_systemtime(packet.header.ts),
         data: packet_data.to_vec(),
         source_addr,
         source_mac,
@@ -315,7 +327,7 @@ async fn capture_on_interface(
     loop {
         match cap.next_packet() {
             Ok(packet) => {
-                if let Some(raw_packet) = process_ethernet_packet(packet.data, &interface_name) {
+                if let Some(raw_packet) = process_ethernet_packet(&packet, &interface_name) {
                     if sender.send(raw_packet).is_err() {
                         // Receiver has been dropped, exit the loop
                         break;

src/types.rs

@@ -1068,16 +1068,9 @@ impl Display for PtpMessage {
 }
 
 #[derive(Debug, Clone)]
-pub struct ProcessedPacket {
-    pub ptp_message: PtpMessage,
-    pub timestamp: std::time::Instant,
-    pub source_addr: std::net::SocketAddr,
-    pub source_mac: [u8; 6],
-    pub dest_addr: std::net::SocketAddr,
-    pub dest_mac: [u8; 6],
-    pub vlan_id: Option<u16>,
-    pub interface: String,
-    pub raw_packet_data: Vec<u8>,
+pub struct ParsedPacket {
+    pub ptp: PtpMessage,
+    pub raw: std::sync::Arc<crate::socket::RawPacket>,
 }
 
 #[test]

src/ui.rs

@@ -9,7 +9,7 @@ use ratatui::{
 use crate::{
     app::{ActiveView, App, SortColumn, TreeNode},
     ptp::{PtpHost, PtpHostState},
-    types::{format_timestamp, ProcessedPacket, PtpClockAccuracy, PtpClockClass},
+    types::{format_timestamp, ParsedPacket, PtpClockAccuracy, PtpClockClass},
     version,
 };
 
@@ -1027,8 +1027,9 @@ fn render_scrollbar(
     }
 }
 
-fn format_instant(instant: std::time::Instant) -> String {
-    let elapsed = instant.elapsed();
+fn format_instant(system_time: std::time::SystemTime) -> String {
+    let now = std::time::SystemTime::now();
+    let elapsed = now.duration_since(system_time).unwrap_or_default();
 
     let elapsed_str = if elapsed.as_secs() < 1 {
         format!("{}ms", elapsed.as_millis())
@@ -1180,8 +1181,8 @@ fn render_packet_history(f: &mut Frame, area: Rect, app: &mut App) {
         .iter()
         .enumerate()
         .map(|(i, packet)| {
-            let time_str = format_instant(packet.timestamp);
-            let header = packet.ptp_message.header();
+            let time_str = format_instant(packet.raw.timestamp);
+            let header = packet.ptp.header();
 
             let row_style =
                 if matches!(app.active_view, ActiveView::PacketHistory) && i == selected_in_view {
@@ -1194,19 +1195,19 @@ fn render_packet_history(f: &mut Frame, area: Rect, app: &mut App) {
 
             Row::new(vec![
                 Cell::from(time_str),
-                Cell::from(match packet.vlan_id {
+                Cell::from(match packet.raw.vlan_id {
                     Some(id) => id.to_string(),
                     None => "-".to_string(),
                 }),
-                Cell::from(match packet.source_addr {
+                Cell::from(match packet.raw.source_addr {
                     std::net::SocketAddr::V4(a) => a.ip().to_string(),
                     _ => "-".to_string(),
                 }),
-                Cell::from(match packet.source_addr {
+                Cell::from(match packet.raw.source_addr {
                     std::net::SocketAddr::V4(a) => a.port().to_string(),
                     _ => "-".to_string(),
                 }),
-                Cell::from(packet.interface.clone()),
+                Cell::from(packet.raw.interface_name.clone()),
                 Cell::from(header.version.to_string()),
                 Cell::from(Span::styled(
                     header.message_type.to_string(),
@@ -1218,7 +1219,7 @@ fn render_packet_history(f: &mut Frame, area: Rect, app: &mut App) {
                 Cell::from(header.flags.short()),
                 Cell::from(header.correction_field.to_string()),
                 Cell::from(header.log_message_interval.to_string()),
-                Cell::from(packet.ptp_message.to_string()),
+                Cell::from(packet.ptp.to_string()),
             ])
             .style(row_style)
         })
@@ -1290,7 +1291,7 @@ fn render_packet_modal(f: &mut Frame, area: Rect, app: &mut App) {
         // Modal title
         let title = format!(
             "Packet Details - Seq {} (ESC to close)",
-            packet.ptp_message.header().sequence_id
+            packet.ptp.header().sequence_id
         );
 
         // Get theme reference before mutable operations
@@ -1314,12 +1315,12 @@ fn render_packet_modal(f: &mut Frame, area: Rect, app: &mut App) {
 fn render_packet_details_with_hexdump(
     f: &mut Frame,
     area: Rect,
-    packet: &ProcessedPacket,
+    packet: &ParsedPacket,
     theme: &crate::themes::Theme,
     app: &mut App,
 ) {
-    let header = packet.ptp_message.header();
-    let time_str = format_instant(packet.timestamp);
+    let header = packet.ptp.header();
+    let time_str = format_instant(packet.raw.timestamp);
 
     // Define the width for label alignment (same as host details)
     const LABEL_WIDTH: usize = 30;
@@ -1336,48 +1337,56 @@ fn render_packet_details_with_hexdump(
         )]),
         create_aligned_field(
             "Source Address:",
-            packet.source_addr.to_string(),
+            packet.raw.source_addr.to_string(),
             LABEL_WIDTH,
             theme,
         ),
         create_aligned_field(
             "Source MAC:",
             format!(
                 "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
-                packet.source_mac[0],
-                packet.source_mac[1],
-                packet.source_mac[2],
-                packet.source_mac[3],
-                packet.source_mac[4],
-                packet.source_mac[5]
+                packet.raw.source_mac[0],
+                packet.raw.source_mac[1],
+                packet.raw.source_mac[2],
+                packet.raw.source_mac[3],
+                packet.raw.source_mac[4],
+                packet.raw.source_mac[5]
             ),
             LABEL_WIDTH,
             theme,
         ),
         create_aligned_field(
             "Dest Address:",
-            packet.dest_addr.to_string(),
+            packet.raw.dest_addr.to_string(),
             LABEL_WIDTH,
             theme,
         ),
         create_aligned_field(
             "Dest MAC:",
             format!(
                 "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
-                packet.dest_mac[0],
-                packet.dest_mac[1],
-                packet.dest_mac[2],
-                packet.dest_mac[3],
-                packet.dest_mac[4],
-                packet.dest_mac[5]
+                packet.raw.dest_mac[0],
+                packet.raw.dest_mac[1],
+                packet.raw.dest_mac[2],
+                packet.raw.dest_mac[3],
+                packet.raw.dest_mac[4],
+                packet.raw.dest_mac[5]
             ),
             LABEL_WIDTH,
             theme,
         ),
-        create_aligned_field("Interface:", packet.interface.clone(), LABEL_WIDTH, theme),
+        create_aligned_field(
+            "Interface:",
+            packet.raw.interface_name.clone(),
+            LABEL_WIDTH,
+            theme,
+        ),
         create_aligned_field(
             "VLAN ID:",
-            packet.vlan_id.map_or("-".to_string(), |id| id.to_string()),
+            packet
+                .raw
+                .vlan_id
+                .map_or("-".to_string(), |id| id.to_string()),
             LABEL_WIDTH,
             theme,
         ),
@@ -1443,7 +1452,7 @@ fn render_packet_details_with_hexdump(
     ];
 
     // Add detailed message fields
-    let message_details = packet.ptp_message.details();
+    let message_details = packet.ptp.details();
     if !message_details.is_empty() {
         for (field_name, field_value) in message_details.iter() {
             all_lines.push(Line::from(vec![
@@ -1485,7 +1494,7 @@ fn render_packet_details_with_hexdump(
     }
 
     // Add hexdump section at the end
-    let raw_data = &packet.raw_packet_data;
+    let raw_data = &packet.raw.data;
     all_lines.extend(vec![
         Line::from(""),
         Line::from(vec![