cstr16: add from_u8_with_nul

Author: phip1611

CHANGELOG.md

@@ -6,6 +6,7 @@
 - `DevicePath::to_boxed`, `DevicePath::to_owned`, and `DevicePath::as_bytes`
 - `DevicePathInstance::to_boxed`, `DevicePathInstance::to_owned`, and `DevicePathInstance::as_bytes`
 - `DevicePathNode::data`
+- `CStr16::from_u8_with_nul`.
 
 ### Changed
 

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

@@ -65,7 +65,7 @@ fn test_load_image(bt: &BootServices) {
             node.device_type() == DeviceType::MEDIA /* 0x4 */
                 && node.sub_type() == DeviceSubType::HARDWARE_VENDOR /* 0x4 */
         })
-        .map(|node| unsafe { CStr16::from_ptr(node.data().as_ptr().cast()) })
+        .map(|node| CStr16::from_u8_with_nul(node.data()).expect("should be valid CCtr16"))
         // to Rust string
         .map(|cstr16| cstr16.to_string().to_uppercase())
         .expect("should have file-path portion in device path");

uefi/src/data_types/strs.rs

@@ -22,6 +22,9 @@ pub enum FromSliceWithNulError {
 
     /// The slice was not null-terminated
     NotNulTerminated,
+
+    /// The buffer is broken. For example, not a multiple of 2 bytes.
+    BrokenBuffer,
 }
 
 /// Error returned by [`CStr16::from_unaligned_slice`].
@@ -211,10 +214,21 @@ impl CStr16 {
         Self::from_u16_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1))
     }
 
-    /// Creates a C string wrapper from a u16 slice
-    ///
-    /// Since not every u16 value is a valid UCS-2 code point, this function
-    /// must do a bit more validity checking than CStr::from_bytes_with_nul
+    /// Creates a `&CStr16` from a u8 slice, if the slice contains exactly
+    /// one terminating null-byte and all chars are valid UCS-2 chars.
+    pub fn from_u8_with_nul(slice: &[u8]) -> Result<&Self, FromSliceWithNulError> {
+        if slice.is_empty() {
+            return Err(FromSliceWithNulError::NotNulTerminated);
+        }
+        if slice.len() % 2 != 0 {
+            return Err(FromSliceWithNulError::BrokenBuffer);
+        }
+        let slice = unsafe { slice::from_raw_parts(slice.as_ptr().cast::<u16>(), slice.len() / 2) };
+        Self::from_u16_with_nul(slice)
+    }
+
+    /// Creates a `&CStr16` from a u16 slice, if the slice contains exactly
+    /// one terminating null-byte and all chars are valid UCS-2 chars.
     pub fn from_u16_with_nul(codes: &[u16]) -> Result<&Self, FromSliceWithNulError> {
         for (pos, &code) in codes.iter().enumerate() {
             match code.try_into() {
@@ -234,7 +248,7 @@ impl CStr16 {
         Err(FromSliceWithNulError::NotNulTerminated)
     }
 
-    /// Unsafely creates a C string wrapper from a u16 slice.
+    /// Unsafely creates a `&CStr16` from a u16 slice.
     ///
     /// # Safety
     ///
@@ -287,11 +301,13 @@ impl CStr16 {
         Self::from_u16_with_nul(&buf[..index + 1]).map_err(|err| match err {
             FromSliceWithNulError::InvalidChar(p) => FromStrWithBufError::InvalidChar(p),
             FromSliceWithNulError::InteriorNul(p) => FromStrWithBufError::InteriorNul(p),
-            FromSliceWithNulError::NotNulTerminated => unreachable!(),
+            FromSliceWithNulError::NotNulTerminated | FromSliceWithNulError::BrokenBuffer => {
+                unreachable!()
+            }
         })
     }
 
-    /// Create a [`CStr16`] from an [`UnalignedSlice`] using an aligned
+    /// Create a `&CStr16` from an [`UnalignedSlice`] using an aligned
     /// buffer for storage. The lifetime of the output is tied to `buf`,
     /// not `src`.
     pub fn from_unaligned_slice<'buf>(
@@ -313,6 +329,7 @@ impl CStr16 {
             FromSliceWithNulError::InvalidChar(v) => UnalignedCStr16Error::InvalidChar(v),
             FromSliceWithNulError::InteriorNul(v) => UnalignedCStr16Error::InteriorNul(v),
             FromSliceWithNulError::NotNulTerminated => UnalignedCStr16Error::NotNulTerminated,
+            FromSliceWithNulError::BrokenBuffer => UnalignedCStr16Error::BufferTooSmall,
         })
     }
 
@@ -562,6 +579,13 @@ mod tests {
         assert_eq!(<CStr8 as Borrow<[u8]>>::borrow(string), &[b'a', 0]);
     }
 
+    #[test]
+    fn test_cstr16_from_slice() {
+        let s1 = CStr16::from_u8_with_nul(&[65, 0, 66, 0, 67, 0, 0, 0]).unwrap();
+        let s2 = CStr16::from_u16_with_nul(&[65, 66, 67, 0]).unwrap();
+        assert_eq!(s1, s2)
+    }
+
     #[test]
     fn test_cstr16_num_bytes() {
         let s = CStr16::from_u16_with_nul(&[65, 66, 67, 0]).unwrap();