uefi: remove duplicated types, use uefi-raw's IpAddress

phip1611 · phip1611 · commit 86aa5ce10470 · 2025-04-21T19:45:20.000+02:00
This does not use core::net::IpAddr in all possible public interfaces.
Although there is opportunity for that, this commit only makes `uefi`
compatible with the new `uefi-raw` type.
diff --git a/uefi-test-runner/src/proto/network/pxe.rs b/uefi-test-runner/src/proto/network/pxe.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use uefi::proto::network::pxe::{BaseCode, DhcpV4Packet, IpFilter, IpFilters, UdpOpFlags};
-use uefi::proto::network::IpAddress;
+use uefi::proto::network::EfiIpAddr;
 use uefi::{boot, CStr8};
 
 pub fn test() {
@@ -27,7 +27,7 @@ pub fn test() {
         assert!(base_code.mode().dhcp_ack_received());
         let dhcp_ack: &DhcpV4Packet = base_code.mode().dhcp_ack().as_ref();
         let server_ip = dhcp_ack.bootp_si_addr;
-        let server_ip = IpAddress::new_v4(server_ip);
+        let server_ip = EfiIpAddr::new_v4(server_ip);
 
         const EXAMPLE_FILE_NAME: &[u8] = b"example-file.txt\0";
         const EXAMPLE_FILE_CONTENT: &[u8] = b"Hello world!";
diff --git a/uefi-test-runner/src/proto/network/snp.rs b/uefi-test-runner/src/proto/network/snp.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use uefi::proto::network::snp::{InterruptStatus, ReceiveFlags, SimpleNetwork};
-use uefi::proto::network::MacAddress;
+use uefi::proto::network::EfiMacAddr;
 use uefi::{boot, Status};
 
 pub fn test() {
@@ -75,7 +75,7 @@ pub fn test() {
             \xa9\xe4\
             \x04\x01\x02\x03\x04";
 
-        let dest_addr = MacAddress([0xffu8; 32]);
+        let dest_addr = EfiMacAddr([0xffu8; 32]);
         assert!(!simple_network
             .get_interrupt_status()
             .unwrap()
diff --git a/uefi/CHANGELOG.md b/uefi/CHANGELOG.md
@@ -29,6 +29,11 @@
   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:** 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}`.
+  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.
diff --git a/uefi/src/proto/device_path/device_path_gen.rs b/uefi/src/proto/device_path/device_path_gen.rs
@@ -14,13 +14,13 @@ 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::mem::{size_of, size_of_val};
 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::*;
diff --git a/uefi/src/proto/network/ip4config2.rs b/uefi/src/proto/network/ip4config2.rs
@@ -7,15 +7,14 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::ffi::c_void;
-
+use core::net::Ipv4Addr;
 use uefi::boot::ScopedProtocol;
 use uefi::prelude::*;
 use uefi::proto::unsafe_protocol;
 use uefi::{print, println};
 use uefi_raw::protocol::network::ip4_config2::{
     Ip4Config2DataType, Ip4Config2InterfaceInfo, Ip4Config2Policy, Ip4Config2Protocol,
 };
-use uefi_raw::Ipv4Address;
 
 /// IP4 Config2 [`Protocol`]. Configure IPv4 networking.
 ///
@@ -101,29 +100,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 verbose {
                 print!("Network is already up: ");
-                Self::print_info(&info);
+                println!("addr v4: {}", info.station_addr);
             }
             return Ok(());
         }
@@ -142,7 +131,7 @@ impl Ip4Config2 {
             if info.station_addr != no_address {
                 if verbose {
                     print!(" OK: ");
-                    Self::print_info(&info);
+                    println!("addr v4: {}", info.station_addr);
                 }
                 return Ok(());
             }
diff --git a/uefi/src/proto/network/mod.rs b/uefi/src/proto/network/mod.rs
@@ -3,101 +3,15 @@
 //! Network access protocols.
 //!
 //! These protocols can be used to interact with network resources.
+//!
+//! To work with Mac and IP addresses, `uefi` uses with the types:
+//! - [`EfiIpAddr`] that is tightly integrated with the [`core::net::IpAddr`]
+//!   type,
+//! - [`EfiMacAddr`]
 
 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]
-    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.
+pub use uefi_raw::{IpAddress as EfiIpAddr, MacAddress as EfiMacAddr};
diff --git a/uefi/src/proto/network/pxe.rs b/uefi/src/proto/network/pxe.rs
diff --git a/uefi/src/proto/network/snp.rs b/uefi/src/proto/network/snp.rs
diff --git a/xtask/src/device_path/mod.rs b/xtask/src/device_path/mod.rs

-Original file line number
+Diff line change
 //! No interface function must be called until `SimpleNetwork.start` is successfully
 //! called first.
 -use super::{IpAddress, MacAddress};
 +use super::{EfiIpAddr, EfiMacAddr};
 use crate::data_types::Event;
 use crate::proto::unsafe_protocol;
 use crate::{Result, StatusExt};
 use core::ffi::c_void;
 +use core::net::IpAddr;
 use core::ptr;
 use core::ptr::NonNull;
 use uefi_raw::protocol::network::snp::SimpleNetworkProtocol;
         enable: ReceiveFlags,
         disable: ReceiveFlags,
         reset_mcast_filter: bool,
 -        mcast_filter: Option<&[MacAddress]>,
 +        mcast_filter: Option<&[EfiMacAddr]>,
     ) -> Result {
         let filter_count = mcast_filter.map(|filters| filters.len()).unwrap_or(0);
         let filters = mcast_filter
+    }
     /// Modify or reset the current station address, if supported.
 -    pub fn station_address(&self, reset: bool, new: Option<&MacAddress>) -> Result {
 +    pub fn station_address(&self, reset: bool, new: Option<&EfiMacAddr>) -> Result {
         unsafe {
             (self.0.station_address)(
                 &self.0,
+    }
     /// Convert a multicast IP address to a multicast HW MAC Address.
 -    pub fn mcast_ip_to_mac(&self, ipv6: bool, ip: IpAddress) -> Result<MacAddress> {
 -        let mut mac_address = MacAddress([0; 32]);
 +    pub fn mcast_ip_to_mac(&self, ipv6: bool, ip: IpAddr) -> Result<EfiMacAddr> {
 +        let mut mac_address = EfiMacAddr([0; 32]);
         let status = unsafe {
             (self.0.multicast_ip_to_mac)(
                 &self.0,
                 Boolean::from(ipv6),
 -                ip.as_raw_ptr(),
 +                EfiIpAddr::from(ip).as_ptr(),
                 &mut mac_address,
+            )
         };
         &self,
         header_size: usize,
         buffer: &[u8],
 -        src_addr: Option<MacAddress>,
 -        dest_addr: Option<MacAddress>,
 +        src_addr: Option<EfiMacAddr>,
 +        dest_addr: Option<EfiMacAddr>,
         protocol: Option<u16>,
     ) -> Result {
         unsafe {
         &self,
         buffer: &mut [u8],
         header_size: Option<&mut usize>,
 -        src_addr: Option<&mut MacAddress>,
 -        dest_addr: Option<&mut MacAddress>,
 +        src_addr: Option<&mut EfiMacAddr>,
 +        dest_addr: Option<&mut EfiMacAddr>,
         protocol: Option<&mut u16>,
     ) -> Result<usize> {
         let mut buffer_size = buffer.len();