XXX make device paths suck less

Author: phip1611

uefi-test-runner/src/boot/mod.rs

@@ -54,6 +54,25 @@ fn test_load_image(bt: &BootServices) {
     // provide us with the file-path portion of the device path.
     let image_device_path: &DevicePath = &image_device_path_protocol;
 
+    // XXX TEMPORARy
+    {
+        log::debug!(
+            "{:#?}",
+            image_device_path
+                .to_text_by_node(bt)
+            // CString16 -> Rust String
+                .unwrap()
+                .iter()
+                .map(|(a, b)| (a, b.to_string()))
+                .collect::<alloc::vec::Vec<_>>()
+        );
+        log::debug!("{:#?}", image_device_path.to_text(bt).unwrap()
+            // CString16 -> Rust String
+                .iter()
+                .map(|a| a.to_string())
+                .collect::<alloc::vec::Vec<_>>());
+    }
+
     // Get the file-path portion of the device path which is typically behind
     // device path node (0x4, 0x4).
     // TODO we need an abstraction in the UEFI crate for this.

uefi/src/proto/device_path/mod.rs

@@ -77,16 +77,28 @@ pub mod build;
 pub mod text;
 
 mod device_path_gen;
+
 pub use device_path_gen::{
     acpi, bios_boot_spec, end, hardware, media, messaging, DevicePathNodeEnum,
 };
+#[cfg(feature = "alloc")]
+use {alloc::vec::Vec, uefi::CString16};
 
 use crate::proto::{unsafe_protocol, ProtocolPointer};
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Formatter};
 use core::mem;
 use core::ops::Deref;
 use ptr_meta::Pointee;
+use uefi::data_types::FromSliceWithNulError;
+use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
+use uefi::CStr16;
+
+use crate::prelude::BootServices;
+use crate::proto::device_path::text::DevicePathToText;
+use crate::table::boot::{OpenProtocolParams, SearchType};
+use crate::table::{Boot, Table};
+use uefi::table::boot::OpenProtocolAttributes;
 
 opaque_type! {
     /// Opaque type that should be used to represent a pointer to a
@@ -187,6 +199,18 @@ impl DevicePathNode {
     pub fn as_enum(&self) -> Result<DevicePathNodeEnum, NodeConversionError> {
         DevicePathNodeEnum::try_from(self)
     }
+
+    /// If the device path node is of type (0x4, 0x4), it returns the underlying
+    /// data as [`CStr16`].
+    pub fn data_as_filename(&self) -> Option<Result<&CStr16, FromSliceWithNulError>> {
+        if self.device_type() == DeviceType::MEDIA
+            && self.sub_type() == DeviceSubType::HARDWARE_VENDOR
+        {
+            Some(CStr16::from_u8_with_nul(self.data()))
+        } else {
+            None
+        }
+    }
 }
 
 impl Debug for DevicePathNode {
@@ -332,6 +356,75 @@ impl DevicePath {
             stop_condition: StopCondition::EndEntireNode,
         }
     }
+
+    #[cfg(feature = "alloc")]
+    pub fn to_text_by_node(
+        &self,
+        bs: &BootServices,
+    ) -> crate::Result<Vec<(&DevicePathNode, CString16)>> {
+        use uefi::Identify;
+        let &handle = bs
+            .locate_handle_buffer(SearchType::ByProtocol(&DevicePathToText::GUID))
+            .unwrap()
+            .first()
+            .unwrap();
+
+        let to_text_protocol = unsafe {
+            bs.open_protocol::<DevicePathToText>(
+                OpenProtocolParams {
+                    handle,
+                    agent: bs.image_handle(),
+                    controller: None,
+                },
+                OpenProtocolAttributes::GetProtocol,
+            )
+        }
+        .unwrap();
+
+        Ok(self
+            .node_iter()
+            .map(|node| {
+                let cstr16 = to_text_protocol
+                    .convert_device_node_to_text(
+                        bs,
+                        node,
+                        DisplayOnly(false),
+                        AllowShortcuts(false),
+                    )
+                    .unwrap();
+                let cstr16 = &*cstr16;
+                (node, CString16::from(cstr16))
+            })
+            .collect())
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn to_text(&self, bs: &BootServices) -> crate::Result<CString16> {
+        use uefi::Identify;
+        let &handle = bs
+            .locate_handle_buffer(SearchType::ByProtocol(&DevicePathToText::GUID))
+            .unwrap()
+            .first()
+            .unwrap();
+
+        let to_text_protocol = unsafe {
+            bs.open_protocol::<DevicePathToText>(
+                OpenProtocolParams {
+                    handle,
+                    agent: bs.image_handle(),
+                    controller: None,
+                },
+                OpenProtocolAttributes::GetProtocol,
+            )
+        }
+        .unwrap();
+
+        let cstr16 = to_text_protocol
+            .convert_device_path_to_text(bs, self, DisplayOnly(false), AllowShortcuts(false))
+            .unwrap();
+        let cstr16 = &*cstr16;
+        Ok(CString16::from(cstr16))
+    }
 }
 
 impl Debug for DevicePath {