Added functionality to send data for forwarding to wireshark

Author: evoggy

Cargo.toml

@@ -30,6 +30,7 @@ tokio = { version = "1.6.1", features = ["rt", "rt-multi-thread","macros"] }
 serde_support = ["serde"]
 shared_radio = ["flume"]
 async = ["flume/async"]
+wireshark = []
 
 [package.metadata.docs.rs]
 all-features = true

src/capture.rs

@@ -0,0 +1,50 @@
+//! Wireshark packet capture support for Crazyradio
+//!
+//! This module provides a callback mechanism for capturing packets
+//! sent and received via the Crazyradio.
+
+use std::sync::{Mutex, OnceLock};
+
+/// Direction: transmit (to device)
+pub const DIRECTION_TX: u8 = 0;
+/// Direction: receive (from device)
+pub const DIRECTION_RX: u8 = 1;
+
+/// Packet capture callback type
+///
+/// Arguments: (direction, channel, address, radio_index, data)
+pub type CaptureCallback = Box<dyn Fn(u8, u8, &[u8; 5], u8, &[u8]) + Send + Sync>;
+
+/// Global capture callback
+static CAPTURE_CALLBACK: OnceLock<Mutex<Option<CaptureCallback>>> = OnceLock::new();
+
+/// Set the packet capture callback
+///
+/// This should be called once at initialization to enable packet capture.
+/// The callback will be invoked for every packet sent or received.
+pub fn set_callback(callback: CaptureCallback) {
+    let cb = CAPTURE_CALLBACK.get_or_init(|| Mutex::new(None));
+    if let Ok(mut guard) = cb.lock() {
+        *guard = Some(callback);
+    }
+}
+
+/// Clear the packet capture callback
+pub fn clear_callback() {
+    if let Some(cb) = CAPTURE_CALLBACK.get() {
+        if let Ok(mut guard) = cb.lock() {
+            *guard = None;
+        }
+    }
+}
+
+/// Send a packet to the capture callback (if set)
+pub(crate) fn capture_packet(direction: u8, channel: u8, address: &[u8; 5], radio_index: u8, data: &[u8]) {
+    if let Some(cb) = CAPTURE_CALLBACK.get() {
+        if let Ok(guard) = cb.lock() {
+            if let Some(ref callback) = *guard {
+                callback(direction, channel, address, radio_index, data);
+            }
+        }
+    }
+}

src/lib.rs

@@ -15,6 +15,9 @@ mod shared_radio;
 #[cfg(feature = "shared_radio")]
 pub use crate::shared_radio::SharedCrazyradio;
 
+#[cfg(feature = "wireshark")]
+pub mod capture;
+
 use core::time::Duration;
 #[cfg(feature = "serde_support")]
 use serde::{Deserialize, Serialize};
@@ -136,6 +139,10 @@ pub struct Crazyradio {
     address: [u8; 5],
     datarate: Datarate,
     ack_enable: bool,
+
+    /// Radio index (for capture identification)
+    #[cfg(feature = "wireshark")]
+    radio_index: u8,
 }
 
 impl Crazyradio {
@@ -200,6 +207,9 @@ impl Crazyradio {
             datarate: Datarate::Dr2M,
 
             ack_enable: true,
+
+            #[cfg(feature = "wireshark")]
+            radio_index: nth.unwrap_or(0) as u8,
         };
 
         cr.reset()?;
@@ -511,9 +521,18 @@ impl Crazyradio {
     ///                be truncated. The length of the ack payload is returned
     ///                in Ack::length.
     pub fn send_packet(&mut self, data: &[u8], ack_data: &mut [u8]) -> Result<Ack> {
-
-        if self.inline_mode {
-            self.send_inline(data, Some(ack_data))
+        // Capture TX packet
+        #[cfg(feature = "wireshark")]
+        capture::capture_packet(
+            capture::DIRECTION_TX,
+            self.channel.into(),
+            &self.address,
+            self.radio_index,
+            data,
+        );
+
+        let ack = if self.inline_mode {
+            self.send_inline(data, Some(ack_data))?
         } else {
             self.device_handle
                 .write_bulk(0x01, data, Duration::from_secs(1))?;
@@ -531,14 +550,27 @@ impl Crazyradio {
                     .copy_from_slice(&received_data[1..33]);
             }
 
-            Ok(Ack {
+            Ack {
                 received: received_data[0] & 0x01 != 0,
                 power_detector: received_data[0] & 0x02 != 0,
                 retry: ((received_data[0] & 0xf0) >> 4) as usize,
                 length: received - 1,
-            })
+            }
+        };
+
+        // Capture RX packet (ACK payload)
+        #[cfg(feature = "wireshark")]
+        if ack.received && ack.length > 0 {
+            capture::capture_packet(
+                capture::DIRECTION_RX,
+                self.channel.into(),
+                &self.address,
+                self.radio_index,
+                &ack_data[..ack.length],
+            );
         }
-        
+
+        Ok(ack)
     }
 
     /// Send a data packet without caring for Ack (for broadcast communication).
@@ -547,6 +579,16 @@ impl Crazyradio {
     ///
     ///  * `data`: Up to 32 bytes of data to be send.
     pub fn send_packet_no_ack(&mut self, data: &[u8]) -> Result<()> {
+        // Capture TX packet
+        #[cfg(feature = "wireshark")]
+        capture::capture_packet(
+            capture::DIRECTION_TX,
+            self.channel.into(),
+            &self.address,
+            self.radio_index,
+            data,
+        );
+
         if self.inline_mode {
             self.send_inline(data, None)?;
         } else {