uefi-raw: IpAddress: remove type duplications; use core::net types

This simplifies things as we have less types to work with. The overall
convenience is improved and people will be less confused with the
automated imports suggested by their IDE.

As the core::Net types are ABI compatible, and it is unlikely that they
will ever change in core, we should go for this simplification.

Author: phip1611

uefi-raw/CHANGELOG.md

@@ -17,6 +17,9 @@
 - Added  `DevicePathProtocol::length()` properly constructing the `u16` value
 
 ## Changed
+- **Breaking:** Types `Ipv4Address` and `Ipv6Address` have been removed. They
+  were replaced by `core::net::Ipv4Addr` and `core::net::Ipv6Addr`, as they are
+  ABI compatible. This mainly affects the `IpAddress` wrapper type.
 - `DevicePathProtocol` now derives
   `Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash`
 

uefi-raw/src/lib.rs

@@ -38,6 +38,7 @@ pub use uguid::{guid, Guid};
 
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Formatter};
+use core::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 /// Handle to an event structure.
 pub type Event = *mut c_void;
@@ -106,40 +107,6 @@ impl From<Boolean> for bool {
     }
 }
 
-/// An IPv4 internet protocol address.
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
-#[repr(transparent)]
-pub struct Ipv4Address(pub [u8; 4]);
-
-impl From<core::net::Ipv4Addr> for Ipv4Address {
-    fn from(ip: core::net::Ipv4Addr) -> Self {
-        Self(ip.octets())
-    }
-}
-
-impl From<Ipv4Address> for core::net::Ipv4Addr {
-    fn from(ip: Ipv4Address) -> Self {
-        Self::from(ip.0)
-    }
-}
-
-/// An IPv6 internet protocol address.
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
-#[repr(transparent)]
-pub struct Ipv6Address(pub [u8; 16]);
-
-impl From<core::net::Ipv6Addr> for Ipv6Address {
-    fn from(ip: core::net::Ipv6Addr) -> Self {
-        Self(ip.octets())
-    }
-}
-
-impl From<Ipv6Address> for core::net::Ipv6Addr {
-    fn from(ip: Ipv6Address) -> Self {
-        Self::from(ip.0)
-    }
-}
-
 /// An IPv4 or IPv6 internet protocol address.
 ///
 /// Corresponds to the `EFI_IP_ADDRESS` type in the UEFI specification. This
@@ -150,10 +117,10 @@ impl From<Ipv6Address> for core::net::Ipv6Addr {
 #[repr(C)]
 pub union IpAddress {
     /// An IPv4 internet protocol address.
-    pub v4: Ipv4Address,
+    pub v4: Ipv4Addr,
 
     /// An IPv6 internet protocol address.
-    pub v6: Ipv6Address,
+    pub v6: Ipv6Addr,
 
     /// This member serves to align the whole type to 4 bytes as required by
     /// the spec. Note that this is slightly different from `repr(align(4))`,
@@ -164,17 +131,17 @@ pub union IpAddress {
 impl IpAddress {
     /// Construct a new IPv4 address.
     #[must_use]
-    pub const fn new_v4(ip_addr: [u8; 4]) -> Self {
+    pub fn new_v4(ip_addr: [u8; 4]) -> Self {
         Self {
-            v4: Ipv4Address(ip_addr),
+            v4: Ipv4Addr::from(ip_addr),
         }
     }
 
     /// Construct a new IPv6 address.
     #[must_use]
-    pub const fn new_v6(ip_addr: [u8; 16]) -> Self {
+    pub fn new_v6(ip_addr: [u8; 16]) -> Self {
         Self {
-            v6: Ipv6Address(ip_addr),
+            v6: Ipv6Addr::from(ip_addr),
         }
     }
 }
@@ -190,18 +157,20 @@ impl Debug for IpAddress {
 
 impl Default for IpAddress {
     fn default() -> Self {
-        Self { _align_helper: [0u32; 4] }
+        Self {
+            _align_helper: [0u32; 4],
+        }
     }
 }
 
-impl From<core::net::IpAddr> for IpAddress {
-    fn from(t: core::net::IpAddr) -> Self {
+impl From<IpAddr> for IpAddress {
+    fn from(t: IpAddr) -> Self {
         match t {
-            core::net::IpAddr::V4(ip) => Self {
-                v4: Ipv4Address::from(ip),
+            IpAddr::V4(ip) => Self {
+                v4: Ipv4Addr::from(ip),
             },
-            core::net::IpAddr::V6(ip) => Self {
-                v6: Ipv6Address::from(ip),
+            IpAddr::V6(ip) => Self {
+                v6: Ipv6Addr::from(ip),
             },
         }
     }
@@ -261,33 +230,27 @@ mod tests {
         assert!(bool::from(Boolean(0b11111111)));
     }
 
-    /// Test round-trip conversion between `Ipv4Address` and `core::net::Ipv4Addr`.
-    #[test]
-    fn test_ip_addr4_conversion() {
-        let uefi_addr = Ipv4Address(TEST_IPV4);
-        let core_addr = core::net::Ipv4Addr::from(uefi_addr);
-        assert_eq!(uefi_addr, Ipv4Address::from(core_addr));
-    }
-
-    /// Test round-trip conversion between `Ipv6Address` and `core::net::Ipv6Addr`.
+    /// We test that the core::net-types are ABI compatible with the EFI types.
+    /// As long as this is the case, we can reuse core functionality and
+    /// prevent type duplication.
     #[test]
-    fn test_ip_addr6_conversion() {
-        let uefi_addr = Ipv6Address(TEST_IPV6);
-        let core_addr = core::net::Ipv6Addr::from(uefi_addr);
-        assert_eq!(uefi_addr, Ipv6Address::from(core_addr));
+    fn net_abi() {
+        assert_eq!(size_of::<Ipv4Addr>(), 4);
+        assert_eq!(align_of::<Ipv4Addr>(), 1);
+        assert_eq!(size_of::<Ipv6Addr>(), 16);
+        assert_eq!(align_of::<Ipv6Addr>(), 1);
     }
-
     /// Test conversion from `core::net::IpAddr` to `IpvAddress`.
     ///
     /// Note that conversion in the other direction is not possible.
     #[test]
     fn test_ip_addr_conversion() {
-        let core_addr = core::net::IpAddr::V4(core::net::Ipv4Addr::from(TEST_IPV4));
+        let core_addr = IpAddr::V4(core::net::Ipv4Addr::from(TEST_IPV4));
         let uefi_addr = IpAddress::from(core_addr);
-        assert_eq!(unsafe { uefi_addr.v4.0 }, TEST_IPV4);
+        assert_eq!(unsafe { uefi_addr.v4.octets() }, TEST_IPV4);
 
-        let core_addr = core::net::IpAddr::V6(core::net::Ipv6Addr::from(TEST_IPV6));
+        let core_addr = IpAddr::V6(core::net::Ipv6Addr::from(TEST_IPV6));
         let uefi_addr = IpAddress::from(core_addr);
-        assert_eq!(unsafe { uefi_addr.v6.0 }, TEST_IPV6);
+        assert_eq!(unsafe { uefi_addr.v6.octets() }, TEST_IPV6);
     }
 }

uefi-raw/src/protocol/network/dhcp4.rs

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::{guid, Boolean, Char8, Event, Guid, Ipv4Address, MacAddress, Status};
+use crate::{guid, Boolean, Char8, Event, Guid, MacAddress, Status};
 use core::ffi::c_void;
+use core::net::Ipv4Addr;
 
 newtype_enum! {
     pub enum Dhcp4Event: i32 => {
@@ -58,10 +59,10 @@ pub struct Dhcp4Header {
     pub xid: u32,
     pub seconds: u16,
     pub reserved: u16,
-    pub client_addr: Ipv4Address,
-    pub your_addr: Ipv4Address,
-    pub server_addr: Ipv4Address,
-    pub gateway_addr: Ipv4Address,
+    pub client_addr: Ipv4Addr,
+    pub your_addr: Ipv4Addr,
+    pub server_addr: Ipv4Addr,
+    pub gateway_addr: Ipv4Addr,
     pub client_hw_addr: [u8; 16],
     pub server_name: [Char8; 64],
     pub boot_file_name: [Char8; 128],
@@ -86,7 +87,7 @@ pub struct Dhcp4ConfigData {
     pub discover_timeout: *mut u32,
     pub request_try_count: u32,
     pub request_timeout: *mut u32,
-    pub client_address: Ipv4Address,
+    pub client_address: Ipv4Addr,
     pub callback: Option<
         unsafe extern "efiapi" fn(
             this: *mut Dhcp4Protocol,
@@ -107,20 +108,20 @@ pub struct Dhcp4ConfigData {
 pub struct Dhcp4ModeData {
     pub state: Dhcp4State,
     pub config_data: Dhcp4ConfigData,
-    pub client_address: Ipv4Address,
+    pub client_address: Ipv4Addr,
     pub client_mac_address: MacAddress,
-    pub server_address: Ipv4Address,
-    pub router_address: Ipv4Address,
-    pub subnet_mask: Ipv4Address,
+    pub server_address: Ipv4Addr,
+    pub router_address: Ipv4Addr,
+    pub subnet_mask: Ipv4Addr,
     pub lease_time: u32,
     pub reply_packet: *const Dhcp4Packet,
 }
 
 #[derive(Debug)]
 #[repr(C)]
 pub struct Dhcp4ListenPoint {
-    pub listen_address: Ipv4Address,
-    pub subnet_mask: Ipv4Address,
+    pub listen_address: Ipv4Addr,
+    pub subnet_mask: Ipv4Addr,
     pub listen_port: u16,
 }
 
@@ -129,9 +130,9 @@ pub struct Dhcp4ListenPoint {
 pub struct Dhcp4TransmitReceiveToken {
     pub status: Status,
     pub completion_event: Event,
-    pub remote_address: Ipv4Address,
+    pub remote_address: Ipv4Addr,
     pub remote_port: u16,
-    pub gateway_address: Ipv4Address,
+    pub gateway_address: Ipv4Addr,
     pub listen_point_count: u32,
     pub listen_points: *mut Dhcp4ListenPoint,
     pub timeout_value: u32,

uefi-raw/src/protocol/network/http.rs

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::{guid, Boolean, Char16, Char8, Event, Guid, Ipv4Address, Ipv6Address, Status};
+use crate::{guid, Boolean, Char16, Char8, Event, Guid, Status};
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Formatter};
+use core::net::{Ipv4Addr, Ipv6Addr};
 use core::ptr;
 
 #[derive(Debug, Default)]
@@ -23,19 +24,30 @@ newtype_enum! {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(C)]
 pub struct HttpV4AccessPoint {
     pub use_default_addr: Boolean,
-    pub local_address: Ipv4Address,
-    pub local_subnet: Ipv4Address,
+    pub local_address: Ipv4Addr,
+    pub local_subnet: Ipv4Addr,
     pub local_port: u16,
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
+impl Default for HttpV4AccessPoint {
+    fn default() -> Self {
+        Self {
+            use_default_addr: Default::default(),
+            local_address: Ipv4Addr::from([0; 4]),
+            local_subnet: Ipv4Addr::from([0; 4]),
+            local_port: 0,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(C)]
 pub struct HttpV6AccessPoint {
-    pub local_address: Ipv6Address,
+    pub local_address: Ipv6Addr,
     pub local_port: u16,
 }
 

uefi-raw/src/protocol/network/ip4.rs

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::Ipv4Address;
+use core::net::Ipv4Addr;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(C)]
 pub struct Ip4RouteTable {
-    pub subnet_addr: Ipv4Address,
-    pub subnet_mask: Ipv4Address,
-    pub gateway_addr: Ipv4Address,
+    pub subnet_addr: Ipv4Addr,
+    pub subnet_mask: Ipv4Addr,
+    pub gateway_addr: Ipv4Addr,
 }

uefi-raw/src/protocol/network/ip4_config2.rs

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::protocol::network::ip4::Ip4RouteTable;
-use crate::{guid, Char16, Event, Guid, Ipv4Address, MacAddress, Status};
+use crate::{guid, Char16, Event, Guid, MacAddress, Status};
 use core::ffi::c_void;
+use core::net::Ipv4Addr;
 
 newtype_enum! {
     pub enum Ip4Config2DataType: i32 => {
@@ -22,8 +23,8 @@ pub struct Ip4Config2InterfaceInfo {
     pub if_type: u8,
     pub hw_addr_size: u32,
     pub hw_addr: MacAddress,
-    pub station_addr: Ipv4Address,
-    pub subnet_mask: Ipv4Address,
+    pub station_addr: Ipv4Addr,
+    pub subnet_mask: Ipv4Addr,
     pub route_table_size: u32,
     pub route_table: *mut Ip4RouteTable,
 }
@@ -39,8 +40,8 @@ newtype_enum! {
 #[derive(Debug)]
 #[repr(C)]
 pub struct Ip4Config2ManualAddress {
-    pub address: Ipv4Address,
-    pub subnet_mask: Ipv4Address,
+    pub address: Ipv4Addr,
+    pub subnet_mask: Ipv4Addr,
 }
 
 #[derive(Debug)]