uefi: use core::net-types in public API + remove duplications

Author: phip1611

uefi-test-runner/src/proto/network/pxe.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use uefi::proto::network::IpAddress;
+use core::net::{IpAddr, Ipv4Addr};
 use uefi::proto::network::pxe::{BaseCode, DhcpV4Packet, IpFilter, IpFilters, UdpOpFlags};
 use uefi::{CStr8, boot};
 
@@ -30,7 +30,7 @@ pub fn test() {
         info!("DHCP: Server IP: {:?}", dhcp_ack.bootp_si_addr);
         info!("DHCP: Client IP: {:?}", dhcp_ack.bootp_yi_addr);
 
-        let server_ip = IpAddress::new_v4(dhcp_ack.bootp_si_addr);
+        let server_ip = IpAddr::V4(Ipv4Addr::from(dhcp_ack.bootp_si_addr));
 
         const EXAMPLE_FILE_NAME: &[u8] = b"example-file.txt\0";
         const EXAMPLE_FILE_CONTENT: &[u8] = b"Hello world!";
@@ -88,7 +88,7 @@ pub fn test() {
         let mut read_result = Ok(0);
         for i in 0..5 {
             read_result = base_code.udp_read(
-                UdpOpFlags::USE_FILTER,
+                UdpOpFlags::ANY_SRC_PORT | UdpOpFlags::ANY_SRC_IP | UdpOpFlags::ANY_DEST_PORT | UdpOpFlags::ANY_DEST_IP,
                 Some(&mut dest_ip),
                 Some(&mut dest_port),
                 Some(&mut src_ip),

uefi-test-runner/src/proto/network/snp.rs

@@ -6,9 +6,9 @@ use smoltcp::wire::{
     ETHERNET_HEADER_LEN, EthernetFrame, IPV4_HEADER_LEN, Ipv4Packet, UDP_HEADER_LEN, UdpPacket,
 };
 use uefi::boot::ScopedProtocol;
-use uefi::proto::network::MacAddress;
 use uefi::proto::network::snp::{InterruptStatus, ReceiveFlags, SimpleNetwork};
 use uefi::{Status, boot};
+use uefi_raw::MacAddress as EfiMacAddr;
 use uefi_raw::protocol::network::snp::NetworkState;
 
 /// The MAC address configured for the interface.
@@ -53,8 +53,8 @@ fn receive(simple_network: &mut SimpleNetwork, buffer: &mut [u8]) -> uefi::Resul
     // Wait for a bit to ensure that the previous packet has been processed.
     boot::stall(Duration::from_millis(500));
 
-    let mut recv_src_mac = MacAddress([0; 32]);
-    let mut recv_dst_mac = MacAddress([0; 32]);
+    let mut recv_src_mac = EfiMacAddr([0; 32]);
+    let mut recv_dst_mac = EfiMacAddr([0; 32]);
     let mut recv_ethernet_protocol = 0;
 
     let res = simple_network.receive(

uefi/CHANGELOG.md

@@ -30,6 +30,9 @@
   getting stabilized in stable Rust.
   - Removed `File::get_boxed_info_in`
   - Removed `Directory::read_entry_boxed_in`
+- All protocols behind `uefi::net` now only use `core::net` types in their
+  public API. This especially affects the SNP and PXE protocols. This makes
+  writing networking code much simpler.
 
 # uefi - 0.35.0 (2025-05-04)
 
@@ -63,6 +66,15 @@
   defaults to the recommended value of `MemoryType::LOADER_DATA`.
 - **Breaking:** Removed duplication in `DevicePathHeader`. Instead of public fields,
   there is now a public constructor combined with public getters.
+- **Breaking:** All public APIs related to networking now use
+  `core::net::{IpAddr, Ipv4Addr, Ipv6Addr}`, i.e., the types from the standard
+  library.
+- **Breaking:** Removed type `IpAddress`. Instead, a new alias `EfiIpAddr` is
+  exported which forwards to the new `IpAddress` type in `uefi-raw`. That type
+  is tightly integrated with `core::net::{IpAddr, Ipv4Addr, Ipv6Addr}` via
+  various `From/Into` implementations. This simplifies working with IP addresses
+  significantly.
+- **Breaking:** For consistency, `MacAddress` was renamed to `EfiMacAddr`.
 - `boot::memory_map()` will never return `Status::BUFFER_TOO_SMALL` from now on,
   as this is considered a hard internal error where users can't do anything
   about it anyway. It will panic instead.

uefi/src/proto/device_path/device_path_gen.rs

@@ -14,12 +14,12 @@ use crate::polyfill::maybe_uninit_slice_as_mut_ptr;
 use crate::proto::device_path::{
     self, DevicePathHeader, DevicePathNode, DeviceSubType, DeviceType, NodeConversionError,
 };
-use crate::proto::network::IpAddress;
 use crate::{Guid, guid};
 use bitflags::bitflags;
 use core::ptr::addr_of;
 use core::{fmt, slice};
 use ptr_meta::Pointee;
+use uefi_raw::IpAddress;
 /// Device path nodes for [`DeviceType::END`].
 pub mod end {
     use super::*;

uefi/src/proto/network/ip4config2.rs

@@ -7,13 +7,13 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::ffi::c_void;
+use core::net::Ipv4Addr;
 use core::time::Duration;
 
 use uefi::boot::ScopedProtocol;
 use uefi::prelude::*;
 use uefi::proto::unsafe_protocol;
 use uefi::{print, println};
-use uefi_raw::Ipv4Address;
 use uefi_raw::protocol::network::ip4_config2::{
     Ip4Config2DataType, Ip4Config2InterfaceInfo, Ip4Config2Policy, Ip4Config2Protocol,
 };
@@ -102,29 +102,19 @@ impl Ip4Config2 {
         })
     }
 
-    fn print_info(info: &Ip4Config2InterfaceInfo) {
-        println!(
-            "addr v4: {}.{}.{}.{}",
-            info.station_addr.0[0],
-            info.station_addr.0[1],
-            info.station_addr.0[2],
-            info.station_addr.0[3],
-        );
-    }
-
     /// Bring up network interface.  Does nothing in case the network
     /// is already set up.  Otherwise turns on DHCP and waits until an
     /// IPv4 address has been assigned.  Reports progress on the
     /// console if verbose is set to true.  Returns TIMEOUT error in
     /// case DHCP configuration does not finish within 30 seconds.
     pub fn ifup(&mut self, verbose: bool) -> uefi::Result<()> {
-        let no_address = Ipv4Address::default();
+        let no_address = Ipv4Addr::from_bits(0);
 
         let info = self.get_interface_info()?;
-        if info.station_addr != no_address {
+        if info.station_addr != no_address.into() {
             if verbose {
                 print!("Network is already up: ");
-                Self::print_info(&info);
+                println!("addr v4: {}", info.station_addr);
             }
             return Ok(());
         }
@@ -140,10 +130,10 @@ impl Ip4Config2 {
             }
             boot::stall(Duration::from_secs(1));
             let info = self.get_interface_info()?;
-            if info.station_addr != no_address {
+            if info.station_addr != no_address.into() {
                 if verbose {
                     print!(" OK: ");
-                    Self::print_info(&info);
+                    println!("addr v4: {}", info.station_addr);
                 }
                 return Ok(());
             }

uefi/src/proto/network/mod.rs

@@ -3,101 +3,20 @@
 //! Network access protocols.
 //!
 //! These protocols can be used to interact with network resources.
+//!
+//! All high-level wrappers will accept [`core::net`] types:
+//! - [`IpAddr`]
+//! - [`Ipv4Addr`]
+//! - [`Ipv6Addr`]
+//!
+//! The only exception is [`uefi_raw::MacAddress`] which doesn't have a
+//! corresponding type in the standard library.
+//!
+//! [`IpAddr`]: core::net::IpAddr
+//! [`Ipv4Addr`]: core::net::Ipv4Addr
+//! [`Ipv6Addr`]: core::net::Ipv6Addr
 
 pub mod http;
 pub mod ip4config2;
 pub mod pxe;
 pub mod snp;
-
-pub use uefi_raw::MacAddress;
-
-/// Represents an IPv4/v6 address.
-///
-/// Corresponds to the `EFI_IP_ADDRESS` type in the C API.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[repr(C, align(4))]
-pub struct IpAddress(pub [u8; 16]);
-
-impl IpAddress {
-    /// Construct a new IPv4 address.
-    #[must_use]
-    pub const fn new_v4(ip_addr: [u8; 4]) -> Self {
-        let mut buffer = [0; 16];
-        buffer[0] = ip_addr[0];
-        buffer[1] = ip_addr[1];
-        buffer[2] = ip_addr[2];
-        buffer[3] = ip_addr[3];
-        Self(buffer)
-    }
-
-    /// Construct a new IPv6 address.
-    #[must_use]
-    pub const fn new_v6(ip_addr: [u8; 16]) -> Self {
-        Self(ip_addr)
-    }
-
-    /// Construct from a `uefi_raw::IpAddress` union.
-    ///
-    /// # Safety
-    ///
-    /// `is_ipv6` must accurately reflect how the union was initialized.
-    #[must_use]
-    const unsafe fn from_raw(ip_addr: uefi_raw::IpAddress, is_ipv6: bool) -> Self {
-        if is_ipv6 {
-            Self::new_v6(unsafe { ip_addr.v6.0 })
-        } else {
-            Self::new_v4(unsafe { ip_addr.v4.0 })
-        }
-    }
-
-    #[must_use]
-    const fn as_raw_ptr(&self) -> *const uefi_raw::IpAddress {
-        // The uefi-raw type is defined differently, but the layout is
-        // compatible.
-        self.0.as_ptr().cast()
-    }
-
-    #[must_use]
-    const fn as_raw_ptr_mut(&mut self) -> *mut uefi_raw::IpAddress {
-        // The uefi-raw type is defined differently, but the layout is
-        // compatible.
-        self.0.as_mut_ptr().cast()
-    }
-}
-
-impl From<core::net::Ipv4Addr> for IpAddress {
-    fn from(t: core::net::Ipv4Addr) -> Self {
-        Self::new_v4(t.octets())
-    }
-}
-
-impl From<IpAddress> for core::net::Ipv4Addr {
-    fn from(IpAddress(o): IpAddress) -> Self {
-        Self::from([o[0], o[1], o[2], o[3]])
-    }
-}
-
-impl From<core::net::Ipv6Addr> for IpAddress {
-    fn from(t: core::net::Ipv6Addr) -> Self {
-        Self::new_v6(t.octets())
-    }
-}
-
-impl From<IpAddress> for core::net::Ipv6Addr {
-    fn from(value: IpAddress) -> Self {
-        Self::from(value.0)
-    }
-}
-
-impl From<core::net::IpAddr> for IpAddress {
-    fn from(t: core::net::IpAddr) -> Self {
-        match t {
-            core::net::IpAddr::V4(a) => a.into(),
-            core::net::IpAddr::V6(a) => a.into(),
-        }
-    }
-}
-
-// NOTE: We cannot impl From<IpAddress> for core::net::IpAddr
-// because IpAddress is a raw union, with nothing indicating
-// whether it should be considered v4 or v6.