xxx

Author: phip1611

Diff for: Cargo.lock

@@ -8,11 +8,19 @@ edition = "2021"
 [dependencies]
 uefi-raw = { path = "../uefi-raw" }
 uefi = { path = "../uefi", features = ["alloc", "global_allocator", "panic_handler", "logger", "qemu"] }
-
 log.workspace = true
-
 qemu-exit = "3.0.0"
 
+[dependencies.smoltcp]
+version = "0.12.0"
+default-features = false
+features = [
+  "proto-ipv4",
+  "socket-udp",
+  # "medium-ip",
+  "medium-ethernet"
+]
+
 [features]
 # Enable the debug support protocol test.
 debug_support = []

Diff for: uefi-test-runner/Cargo.toml

@@ -3,9 +3,161 @@
 pub fn test() {
     info!("Testing Network protocols");
 
-    pxe::test();
-    snp::test();
+    // Test idempotence of network stuff
+    for _ in 0..2 {
+        #[cfg(feature = "pxe")]
+        //pxe::test();
+        snp::test();
+    }
 }
 
+#[cfg(feature = "pxe")]
 mod pxe;
 mod snp;
+
+/// This module provides helpers to work directly on UDP, IPv4, and Ethernet
+/// packets.
+mod wire_helper {
+    use alloc::vec::Vec;
+    use smoltcp::wire;
+    use smoltcp::wire::{EthernetAddress, EthernetFrame, EthernetProtocol, EthernetRepr, IpProtocol, Ipv4Packet, UdpPacket, ETHERNET_HEADER_LEN, IPV4_HEADER_LEN, UDP_HEADER_LEN};
+
+    /// Creates a minimal yet valid UDP packet in the provided buffer together
+    /// with the payload.
+    fn create_udp_packet<'a>(
+        buffer: &'a mut [u8],
+        src_addr: wire::Ipv4Address,
+        dst_addr: wire::Ipv4Address,
+        src_port: u16,
+        dst_port: u16,
+        payload: &[u8],
+    ) -> UdpPacket<&'a mut [u8]> {
+        let mut packet = UdpPacket::new_unchecked(buffer);
+        packet.set_src_port(src_port);
+        packet.set_dst_port(dst_port);
+        packet.set_len((UDP_HEADER_LEN + payload.len()) as u16);
+        packet.payload_mut().copy_from_slice(payload);
+
+        packet.fill_checksum(&src_addr.into(), &dst_addr.into());
+        packet.verify_checksum(&src_addr.into(), &dst_addr.into());
+        packet.check_len().unwrap();
+        packet
+    }
+
+    /// Creates a minimal yet valid IPv4 packet in the provided buffer together
+    /// with the payload. The IPv4 packet that contains all data in a single
+    /// packet (not fragmented).
+    fn create_ipv4_packet<'a>(
+        buffer: &'a mut [u8],
+        src_addr: smoltcp::wire::Ipv4Address,
+        dst_addr: smoltcp::wire::Ipv4Address,
+        payload: &[u8],
+    ) -> Ipv4Packet<&'a mut [u8]> {
+        let mut packet = Ipv4Packet::new_unchecked(buffer);
+        packet.set_version(4);
+        packet.set_header_len(IPV4_HEADER_LEN as u8);
+        packet.set_dscp(0 /* QOS */);
+        packet.set_total_len((IPV4_HEADER_LEN + payload.len()) as u16);
+        packet.set_ident(42);
+        packet.set_dont_frag(true);
+        packet.set_frag_offset(0);
+        packet.set_hop_limit(42 /*TTL */);
+        packet.set_next_header(IpProtocol::Udp);
+        packet.set_src_addr(src_addr);
+        packet.set_dst_addr(dst_addr);
+        packet.payload_mut().copy_from_slice(payload);
+
+        packet.fill_checksum();
+        packet.verify_checksum();
+        packet.check_len().unwrap();
+        packet
+    }
+
+    /// Creates a minimal yet valid Ethernet frame (packet) in the provided
+    /// buffer together with the payload.
+    fn create_ethernet_frame<'a>(
+        buffer: &'a mut [u8],
+        src_addr: EthernetAddress,
+        dst_addr: EthernetAddress,
+        payload: &[u8],
+    ) -> EthernetFrame<&'a mut [u8]> {
+        let mut packet = EthernetFrame::new_unchecked(buffer);
+        packet.set_src_addr(src_addr);
+        packet.set_dst_addr(dst_addr);
+        packet.set_ethertype(EthernetProtocol::Ipv4);
+        packet.payload_mut().copy_from_slice(payload);
+
+        packet.check_len().unwrap();
+        packet
+    }
+
+    /// Embeds an arbitrary payload into a minimal yet valid
+    /// `EthernetFrame(IPv4Packet(UdpPacket(Payload)))` packet structure.
+    ///
+    /// The encoded structure is returned as [`Vec`].
+    pub fn create_udp_ipv4_ethernet_packet(
+        src_addr_ipv4: wire::Ipv4Address,
+        dst_addr_ipv4: wire::Ipv4Address,
+        src_addr_mac: EthernetAddress,
+        dst_addr_mac: EthernetAddress,
+        payload: &[u8],
+    ) -> Vec<u8> {
+        let total_len = ETHERNET_HEADER_LEN + IPV4_HEADER_LEN + UDP_HEADER_LEN + payload.len();
+        assert!(total_len <= 1500 /* default Max Ethernet frame size */);
+
+        // udp packet with embedded payload
+        let udp_packet = {
+            let len = UDP_HEADER_LEN + payload.len();
+            let mut buf = vec![0_u8; len];
+            create_udp_packet(
+                &mut buf,
+                src_addr_ipv4.clone(),
+                dst_addr_ipv4.clone(),
+                0x1337,
+                0x1337,
+                &payload,
+            );
+            buf
+        };
+
+        // ipv4 packet with embedded udp packet
+        let ipv4_packet = {
+            let len = IPV4_HEADER_LEN + udp_packet.len();
+            let mut buf = vec![0_u8; len];
+            create_ipv4_packet(
+                &mut buf,
+                src_addr_ipv4.clone(),
+                dst_addr_ipv4.clone(),
+                &udp_packet,
+            );
+            buf
+        };
+
+        // ethernet frame with embedded ipv4 packet
+        let ethernet_frame = {
+            let len = ETHERNET_HEADER_LEN + ipv4_packet.len();
+            let mut buf = vec![0_u8; len];
+            log::debug!("ethernet frame before: {:#?}", &buf);
+            create_ethernet_frame(&mut buf, src_addr_mac.clone(), dst_addr_mac, &ipv4_packet);
+            log::debug!("ethernet frame after: {:#?}", &buf);
+            buf
+        };
+        assert_eq!(ethernet_frame.len(), total_len);
+        let repr = EthernetRepr::parse(&EthernetFrame::new_unchecked(&ethernet_frame)).unwrap();
+        log::debug!("ethernet repr: {:#?}", repr);
+
+        ethernet_frame
+    }
+
+    /// Returns the actual payload from a UDP packet.
+    pub fn get_payload_from_udp_ipv4_frame(frame: &[u8]) -> &[u8] {
+        log::debug!("frame lan = {}", frame.len());
+        let frame = EthernetFrame::new_checked(frame).unwrap();
+        log::debug!("payload = {:?}", &frame.payload()[0..30]);
+        let ipv4_packet = Ipv4Packet::new_unchecked(&frame.payload()[1..]);
+        log::debug!("ipv4: {}", ipv4_packet);
+        log::debug!("total_len={}", ipv4_packet.total_len());
+        let udp_packet = UdpPacket::new_checked(ipv4_packet.payload()).unwrap();
+        udp_packet.payload()
+    }
+}