feat(network): support packet capture file creation

Allows creating packet capture files in the pcap format.

Author: cagatay-y

Cargo.toml

@@ -50,6 +50,7 @@ mman = []
 mmap = ["mman"] # Deprecated in favor of mman
 newlib = []
 nostd = []
+pcap = ["net", "smoltcp", "virtio-fs"]
 pci = ["virtio?/pci"]
 rtl8139 = ["net", "pci", "volatile/derive", "endian-num"]
 semihosting = ["dep:semihosting"]

src/executor/device.rs

@@ -14,6 +14,12 @@ use smoltcp::socket::dns;
 use smoltcp::wire::{EthernetAddress, HardwareAddress};
 #[cfg(not(feature = "dhcpv4"))]
 use smoltcp::wire::{IpCidr, Ipv4Address, Ipv4Cidr};
+#[cfg(feature = "pcap")]
+use {
+	crate::fs::File,
+	embedded_io::Write,
+	smoltcp::phy::{PcapMode, PcapSink, PcapWriter},
+};
 
 use super::network::{NetworkInterface, NetworkState};
 use crate::arch;
@@ -42,8 +48,7 @@ impl<'a> NetworkInterface<'a> {
 				feature = "rtl8139",
 				feature = "virtio-net",
 			))] {
-				#[cfg_attr(feature = "trace", expect(unused_mut))]
-				let Some(mut device) = NETWORK_DEVICE.lock().take() else {
+				let Some(device) = NETWORK_DEVICE.lock().take() else {
 					return NetworkState::InitializationFailed;
 				};
 			} else {
@@ -54,8 +59,26 @@ impl<'a> NetworkInterface<'a> {
 
 		let mac = device.get_mac_address();
 
-		#[cfg(feature = "trace")]
-		let mut device = Tracer::new(device, |timestamp, printer| trace!("{timestamp} {printer}"));
+		cfg_if! {
+			if #[cfg(feature = "trace")] {
+				let mut device =
+					Tracer::new(device, |timestamp, printer| trace!("{timestamp} {printer}"));
+			} else if #[cfg(feature = "pcap")] {
+				let mut device = PcapWriter::new(
+					device,
+					FileSink(
+						File::create(
+							format!("/root/{}.pcap", crate::executor::network::now().secs())
+								.as_str(),
+						)
+						.unwrap(),
+					),
+					PcapMode::Both,
+				);
+			} else {
+				let mut device = device;
+			}
+		}
 
 		let ethernet_addr = EthernetAddress(mac);
 		let hardware_addr = HardwareAddress::Ethernet(ethernet_addr);
@@ -130,3 +153,21 @@ impl<'a> NetworkInterface<'a> {
 		}))
 	}
 }
+
+#[cfg(feature = "pcap")]
+pub(in crate::executor) struct FileSink(File);
+
+#[cfg(feature = "pcap")]
+impl PcapSink for FileSink {
+	fn write(&mut self, data: &[u8]) {
+		if let Some(err) = self.0.write(data).err() {
+			error!("Error while writing to the packet capture: {err}");
+		}
+	}
+
+	fn flush(&mut self) {
+		if let Some(err) = self.0.flush().err() {
+			error!("Error while flushing the packet capture: {err}");
+		}
+	}
+}

src/executor/network.rs

@@ -45,7 +45,10 @@ pub(crate) enum NetworkState<'a> {
 	feature = "virtio-net",
 ))]
 pub(crate) fn network_handler() {
-	NIC.lock().as_nic_mut().unwrap().handle_interrupt();
+	// It is possible for us to receive interrupts before we are done with initializing the network interface.
+	if let Ok(nic) = NIC.lock().as_nic_mut() {
+		nic.handle_interrupt();
+	}
 }
 
 impl<'a> NetworkState<'a> {
@@ -63,13 +66,20 @@ static LOCAL_ENDPOINT: AtomicU16 = AtomicU16::new(0);
 pub(crate) static NIC: InterruptTicketMutex<NetworkState<'_>> =
 	InterruptTicketMutex::new(NetworkState::Missing);
 
+cfg_if::cfg_if! {
+	if #[cfg(feature = "trace")] {
+		type InterfaceDevice = smoltcp::phy::Tracer<NetworkDevice>;
+	} else if #[cfg(feature = "pcap")] {
+		type InterfaceDevice = smoltcp::phy::PcapWriter<NetworkDevice, crate::executor::device::FileSink>;
+	} else {
+		type InterfaceDevice = NetworkDevice;
+	}
+}
+
 pub(crate) struct NetworkInterface<'a> {
 	pub(super) iface: smoltcp::iface::Interface,
 	pub(super) sockets: SocketSet<'a>,
-	#[cfg(feature = "trace")]
-	pub(super) device: smoltcp::phy::Tracer<NetworkDevice>,
-	#[cfg(not(feature = "trace"))]
-	pub(super) device: NetworkDevice,
+	pub(super) device: InterfaceDevice,
 	#[cfg(feature = "dhcpv4")]
 	pub(super) dhcp_handle: SocketHandle,
 	#[cfg(feature = "dns")]
@@ -344,16 +354,22 @@ impl<'a> NetworkInterface<'a> {
 		feature = "virtio-net",
 	))]
 	fn handle_interrupt(&mut self) {
-		#[cfg(feature = "trace")]
-		self.device.get_mut().handle_interrupt();
-		#[cfg(not(feature = "trace"))]
-		self.device.handle_interrupt();
+		cfg_if::cfg_if! {
+			if #[cfg(any(feature = "trace", feature="pcap"))] {
+				self.device.get_mut().handle_interrupt();
+			} else {
+				self.device.handle_interrupt();
+			}
+		}
 	}
 
 	pub(crate) fn set_polling_mode(&mut self, value: bool) {
-		#[cfg(feature = "trace")]
-		self.device.get_mut().set_polling_mode(value);
-		#[cfg(not(feature = "trace"))]
-		self.device.set_polling_mode(value);
+		cfg_if::cfg_if! {
+			if #[cfg(any(feature = "trace", feature="pcap"))] {
+				self.device.get_mut().set_polling_mode(value);
+			} else {
+				self.device.set_polling_mode(value);
+			}
+		}
 	}
 }

src/lib.rs

@@ -139,10 +139,11 @@ extern "C" fn initd(_arg: usize) {
 
 	// Initialize Drivers
 	drivers::init();
+	// The filesystem needs to be initialized before network to allow writing packet captures to a file.
+	fs::init();
 	crate::executor::init();
 
 	syscalls::init();
-	fs::init();
 	#[cfg(feature = "shell")]
 	shell::init();