uefi: adapt to new uefi-raw types

They are aliased to EfiIpAddr and EfiMacAddr to be better separable
from core::net::Ipv4Addr and IPv6Addr, as well as "real" MacAddress types
from crates such as smoltcp.

This commit just makes uefi compatible with the latest changes. In the
next step, we switch to core::net types in the public interface.

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/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

@@ -9,95 +9,5 @@ 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;