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

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.

Author: phip1611

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!";

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()

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.

uefi/src/proto/device_path/device_path_gen.rs

@@ -14,7 +14,7 @@ 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::proto::network::EfiIpAddr;
 use crate::{guid, Guid};
 use bitflags::bitflags;
 use core::mem::{size_of, size_of_val};
@@ -2412,7 +2412,7 @@ pub mod messaging {
     pub struct Dns {
         pub(super) header: DevicePathHeader,
         pub(super) address_type: device_path::messaging::DnsAddressType,
-        pub(super) addresses: [IpAddress],
+        pub(super) addresses: [EfiIpAddr],
     }
 
     impl Dns {
@@ -2424,10 +2424,10 @@ pub mod messaging {
 
         /// One or more instances of the DNS server address.
         #[must_use]
-        pub fn addresses(&self) -> UnalignedSlice<IpAddress> {
-            let ptr: *const [IpAddress] = addr_of!(self.addresses);
+        pub fn addresses(&self) -> UnalignedSlice<EfiIpAddr> {
+            let ptr: *const [EfiIpAddr] = addr_of!(self.addresses);
             let (ptr, len): (*const (), usize) = ptr_meta::to_raw_parts(ptr);
-            unsafe { UnalignedSlice::new(ptr.cast::<IpAddress>(), len) }
+            unsafe { UnalignedSlice::new(ptr.cast::<EfiIpAddr>(), len) }
         }
     }
 
@@ -2438,7 +2438,7 @@ pub mod messaging {
                 .field("addresses", {
                     let ptr = addr_of!(self.addresses);
                     let (ptr, len) = ptr_meta::to_raw_parts(ptr);
-                    let byte_len = size_of::<IpAddress>() * len;
+                    let byte_len = size_of::<EfiIpAddr>() * len;
                     unsafe { &slice::from_raw_parts(ptr.cast::<u8>(), byte_len) }
                 })
                 .finish()
@@ -2458,7 +2458,7 @@ pub mod messaging {
             let dst_size = size_of_val(node)
                 .checked_sub(static_size)
                 .ok_or(NodeConversionError::InvalidLength)?;
-            let elem_size = size_of::<IpAddress>();
+            let elem_size = size_of::<EfiIpAddr>();
             if dst_size % elem_size != 0 {
                 return Err(NodeConversionError::InvalidLength);
             }
@@ -5380,7 +5380,7 @@ pub mod build {
             /// Whether the addresses are IPv4 or IPv6.
             pub address_type: device_path::messaging::DnsAddressType,
             /// One or more instances of the DNS server address.
-            pub addresses: &'a [IpAddress],
+            pub addresses: &'a [EfiIpAddr],
         }
 
         unsafe impl BuildNode for Dns<'_> {

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(());
             }

uefi/src/proto/network/mod.rs

@@ -3,101 +3,16 @@
 //! 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;
+pub use uefi_raw::MacAddress as EfiMacAddr;