Drop UnalignedCStr16 in favor of UnalignedSlice

This should mostly be transparent to callers. An `UnalignedSlice<u16>`
slice provides the same `to_cstr16` and `to_cstring16` methods that
`UnalignedCStr16` did.

Author: nicholasbishop

CHANGELOG.md

@@ -24,6 +24,12 @@
 - The `Revision` type now implements `Display` with correct formatting
   for all UEFI versions. The custom `Debug` impl has been removed and
   replaced with a derived `Debug` impl.
+  
+### Removed
+
+- Removed `UnalignedCStr16`; use `UnalignedSlice` instead. An
+  `UnalignedSlice<u16>` can be converted to a string with `to_cstr16` or
+  `to_cstring16`.
 
 ## uefi-macros - [Unreleased]
 

src/data_types/mod.rs

@@ -129,8 +129,7 @@ mod enums;
 
 mod strs;
 pub use self::strs::{
-    CStr16, CStr8, EqStrUntilNul, FromSliceWithNulError, FromStrWithBufError, UnalignedCStr16,
-    UnalignedCStr16Error,
+    CStr16, CStr8, EqStrUntilNul, FromSliceWithNulError, FromStrWithBufError, UnalignedCStr16Error,
 };
 
 #[cfg(feature = "exts")]

src/data_types/strs.rs

@@ -2,12 +2,12 @@ use super::chars::{Char16, Char8, NUL_16, NUL_8};
 use super::UnalignedSlice;
 use core::fmt;
 use core::iter::Iterator;
-use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use core::result::Result;
 use core::slice;
+
 #[cfg(feature = "exts")]
-use {super::CString16, crate::alloc_api::vec::Vec};
+use super::CString16;
 
 /// Errors which can occur during checked `[uN]` -> `CStrN` conversions
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -22,7 +22,7 @@ pub enum FromSliceWithNulError {
     NotNulTerminated,
 }
 
-/// Error returned by [`UnalignedCStr16::to_cstr16`].
+/// Error returned by [`CStr16::from_unaligned_slice`].
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum UnalignedCStr16Error {
     /// An invalid character was encountered.
@@ -404,113 +404,6 @@ impl PartialEq<CString16> for &CStr16 {
     }
 }
 
-/// An unaligned UCS-2 null-terminated string.
-///
-/// This wrapper type can be used with UEFI strings that are inside a
-/// [`repr(packed)`] struct. Creating a reference to a packed field is
-/// not allowed because it might not be properly aligned, so a
-/// [`CStr16`] can't be directly constructed. `UnalignedCStr16` instead
-/// takes a pointer to the unaligned field, which is allowed. The
-/// resulting unaligned string cannot be used directly, but must be
-/// converted to an aligned form first with [`to_cstr16`] or
-/// [`to_cstring16`].
-///
-/// [`repr(packed)`]: https://doc.rust-lang.org/nomicon/other-reprs.html#reprpacked
-/// [`to_cstr16`]: Self::to_cstr16
-/// [`to_cstring16`]: Self::to_cstring16
-#[derive(Debug)]
-pub struct UnalignedCStr16<'a> {
-    data: *const u16,
-    len: usize,
-    _phantom_lifetime: PhantomData<&'a ()>,
-}
-
-// While it's not unsafe to have an empty `UnalignedCStr16`, there's not
-// much point either since the string wouldn't be valid without a null
-// terminator. So skip adding an `is_empty` method.
-#[allow(clippy::len_without_is_empty)]
-impl<'a> UnalignedCStr16<'a> {
-    /// Create an `UnalignedCStr16` from a `*const u16` pointer. The
-    /// pointer must be valid but can be unaligned. The `len` parameter
-    /// is the number of `u16` characters in the string (not the number
-    /// of bytes), including the trailing null.
-    ///
-    /// The `_lifetime` parameter is used to make it easy to set an
-    /// appropriate lifetime for `'a`. The caller should pass in a
-    /// reference to something tied to the lifetime of `data`. (The
-    /// `data` parameter cannot itself be a reference because the
-    /// pointer is allowed to be unaligned.)
-    ///
-    /// # Safety
-    ///
-    /// The `data` pointer cannot be dangling, and must remain valid for
-    /// the lifetime of `'a`. There must be at least `len` `u16`
-    /// elements starting with the the first character pointed to by
-    /// `data`. These restrictions allow all other methods on
-    /// `UnalignedCStr16` to be safe.
-    pub unsafe fn new<T: ?Sized>(_lifetime: &'a T, data: *const u16, len: usize) -> Self {
-        Self {
-            data,
-            len,
-            _phantom_lifetime: PhantomData,
-        }
-    }
-
-    /// Number of `u16` elements in the string, including the trailing null.
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Copy the data to an aligned buffer. Panics if the length of
-    /// `dst` is not exactly the same as `self.len()`. Otherwise the
-    /// function always succeeds, and initializes all elements of `dst`.
-    pub fn copy_to(&self, dst: &mut [MaybeUninit<u16>]) {
-        if dst.len() != self.len {
-            panic!("incorrect buffer length");
-        }
-
-        for (i, elem) in dst.iter_mut().enumerate() {
-            unsafe { elem.write(self.data.add(i).read_unaligned()) };
-        }
-    }
-
-    /// Convert to a [`CStr16`] using an aligned buffer for storage. The
-    /// lifetime of the output is tied to `buf`, not `self`.
-    pub fn to_cstr16<'buf>(
-        &self,
-        buf: &'buf mut [MaybeUninit<u16>],
-    ) -> Result<&'buf CStr16, UnalignedCStr16Error> {
-        // The input `buf` might be longer than needed, so get a
-        // subslice of the required length.
-        let buf = buf
-            .get_mut(..self.len())
-            .ok_or(UnalignedCStr16Error::BufferTooSmall)?;
-
-        self.copy_to(buf);
-        let buf = unsafe {
-            // Safety: `copy_buf` fully initializes the slice.
-            MaybeUninit::slice_assume_init_ref(buf)
-        };
-        CStr16::from_u16_with_nul(buf).map_err(|e| match e {
-            FromSliceWithNulError::InvalidChar(v) => UnalignedCStr16Error::InvalidChar(v),
-            FromSliceWithNulError::InteriorNul(v) => UnalignedCStr16Error::InteriorNul(v),
-            FromSliceWithNulError::NotNulTerminated => UnalignedCStr16Error::NotNulTerminated,
-        })
-    }
-
-    /// Convert to a [`CString16`]. Requires the `exts` feature.
-    #[cfg(feature = "exts")]
-    pub fn to_cstring16(&self) -> Result<CString16, FromSliceWithNulError> {
-        let len = self.len();
-        let mut v = Vec::with_capacity(len);
-        unsafe {
-            self.copy_to(v.spare_capacity_mut());
-            v.set_len(len);
-        }
-        CString16::try_from(v)
-    }
-}
-
 impl<'a> UnalignedSlice<'a, u16> {
     /// Create a [`CStr16`] from an [`UnalignedSlice`] using an aligned
     /// buffer for storage. The lifetime of the output is tied to `buf`,
@@ -618,8 +511,8 @@ mod tests {
             ptr.add(3).write_unaligned(b't'.into());
             ptr.add(4).write_unaligned(b'\0'.into());
 
-            // Create the `UnalignedCStr16`.
-            UnalignedCStr16::new(&buf, ptr, 5)
+            // Create the `UnalignedSlice`.
+            UnalignedSlice::new(ptr, 5)
         };
 
         // Test `to_cstr16()` with too small of a buffer.

src/proto/device_path/mod.rs

@@ -68,7 +68,7 @@
 
 pub mod text;
 
-use crate::data_types::UnalignedCStr16;
+use crate::data_types::UnalignedSlice;
 use crate::proto::{Protocol, ProtocolPointer};
 use crate::{unsafe_guid, Guid};
 use core::ffi::c_void;
@@ -578,18 +578,18 @@ pub struct FilePathMediaDevicePath {
 }
 
 impl FilePathMediaDevicePath {
-    /// Get the path. An [`UnalignedCStr16`] is returned since this is a
+    /// Get the path. An [`UnalignedSlice`] is returned since this is a
     /// packed struct.
-    pub fn path_name(&self) -> UnalignedCStr16<'_> {
-        // Safety: creating this `UnalignedCStr16` is safe because the
+    pub fn path_name(&self) -> UnalignedSlice<u16> {
+        // Safety: creating this `UnalignedSlice` is safe because the
         // `path_name` pointer is valid (although potentially
         // unaligned), and the lifetime of the output is tied to `self`,
         // so there's no possibility of use-after-free.
         unsafe {
             // Use `addr_of` to avoid creating an unaligned reference.
             let ptr: *const [u16] = ptr::addr_of!(self.path_name);
             let (ptr, len): (*const (), usize) = ptr.to_raw_parts();
-            UnalignedCStr16::new(self, ptr.cast::<u16>(), len)
+            UnalignedSlice::new(ptr.cast::<u16>(), len)
         }
     }
 }