uefi-raw

Author: phip1611

uefi-raw/src/lib.rs

@@ -113,6 +113,9 @@ impl From<Boolean> for bool {
 /// type is defined in the same way as edk2 for compatibility with C code. Note
 /// that this is an **untagged union**, so there's no way to tell which type of
 /// address an `IpAddress` value contains without additional context.
+///
+/// For convenience, this type is tightly integrated with the Rust standard
+/// library types [`IpAddr`], [`Ipv4Addr`], and [`IpV6Addr`].
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub union IpAddress {
@@ -162,14 +165,48 @@ impl IpAddress {
     pub fn as_ptr_mut(&mut self) -> *mut Self {
         core::ptr::addr_of_mut!(*self)
     }
+
+    /// Transforms this EFI type to the Rust standard libraries type.
+    ///
+    /// # Arguments
+    /// - `is_ipv6`: Whether the internal data should be interpreted as IPv6 or
+    ///   IPv4 address.
+    pub fn to_ip_addr(self, is_ipv6: bool) -> IpAddr {
+        if is_ipv6 {
+            IpAddr::V6(Ipv6Addr::from(unsafe { self.v6.octets() }))
+        } else {
+            IpAddr::V4(Ipv4Addr::from(unsafe { self.v4.octets() }))
+        }
+    }
+
+    /// Returns the underlying data as [`Ipv4Addr`], if only the first four
+    /// octets are used.
+    ///
+    /// # Safety
+    /// This function is not unsafe memory-wise but callers need to ensure with
+    /// additional context that the IP is indeed an IPv4 address.
+    pub unsafe fn as_ipv4(&self) -> Result<Ipv4Addr, Ipv6Addr> {
+        let extra = self.octets()[4..].iter().any(|&x| x != 0);
+        if extra {
+            Ok(Ipv4Addr::from(unsafe { self.v4.octets() }))
+        } else {
+            Err(Ipv6Addr::from(unsafe { self.v6.octets() }))
+        }
+    }
+
+    /// Returns the underlying data as [`Ipv6Addr`].
+    ///
+    /// # Safety
+    /// This function is not unsafe memory-wise but callers need to ensure with
+    /// additional context that the IP is indeed an IPv6 address.
+    pub unsafe fn as_ipv6(&self) -> Ipv6Addr {
+        Ipv6Addr::from(unsafe { self.v6.octets() })
+    }
 }
 
 impl Debug for IpAddress {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        // The type is an untagged union, so we don't know whether it contains
-        // an IPv4 or IPv6 address. It's also not safe to just print the whole
-        // 16 bytes, since they might not all be initialized.
-        f.debug_struct("IpAddress").finish()
+        f.debug_tuple("IpAddress").field(&self.octets()).finish()
     }
 }
 
@@ -207,6 +244,14 @@ impl From<&IpAddr> for IpAddress {
     }
 }
 
+impl From<[u8; 4]> for IpAddress {
+    fn from(value: [u8; 4]) -> Self {
+        Self {
+            v4: Ipv4Addr::from(value),
+        }
+    }
+}
+
 impl From<[u8; 16]> for IpAddress {
     fn from(value: [u8; 16]) -> Self {
         Self {
@@ -299,17 +344,29 @@ mod tests {
         unsafe { assert_eq!(ip.v4.octets(), [192, 168, 42, 73]) }
     }
 
-    /// Test conversion from `core::net::IpAddr` to `IpvAddress`.
-    ///
-    /// Note that conversion in the other direction is not possible.
+    /// Test conversion from [`IpAddr`] to [`IpAddress`].
     #[test]
     fn test_ip_addr_conversion() {
-        let core_addr = IpAddr::V4(Ipv4Addr::from(TEST_IPV4));
-        let uefi_addr = IpAddress::from(core_addr);
-        assert_eq!(unsafe { uefi_addr.v4.octets() }, TEST_IPV4);
+        // Reference: std types
+        let core_ipv4 = IpAddr::from(TEST_IPV4);
+        let core_ipv6 = IpAddr::from(TEST_IPV6);
+
+        // Test From [u8; N] constructors
+        assert_eq!(IpAddress::from(TEST_IPV4).octets()[0..4], TEST_IPV4);
+        assert_eq!(IpAddress::from(TEST_IPV6).octets(), TEST_IPV6);
+        {
+            let bytes: [u8; 16] = IpAddress::from(TEST_IPV6).into();
+            assert_eq!(bytes, TEST_IPV6);
+        }
+
+        // Test from std type constructors
+        let efi_ipv4 = IpAddress::from(core_ipv4);
+        assert_eq!(efi_ipv4.octets()[0..4], TEST_IPV4);
+        assert_eq!(unsafe { efi_ipv4.as_ipv4().unwrap() }, core_ipv4);
 
-        let core_addr = IpAddr::V6(Ipv6Addr::from(TEST_IPV6));
-        let uefi_addr = IpAddress::from(core_addr);
-        assert_eq!(unsafe { uefi_addr.v6.octets() }, TEST_IPV6);
+        let efi_ipv6 = IpAddress::from(core_ipv6);
+        assert_eq!(efi_ipv6.octets(), TEST_IPV6);
+        assert_eq!(unsafe { efi_ipv4.as_ipv4().unwrap_err() }, core_ipv6);
+        assert_eq!(unsafe { efi_ipv4.as_ipv6() }, core_ipv6);
     }
 }