fix interior null checking on windows

whelp!

Author: nagisa

src/as_filename.rs

@@ -16,6 +16,7 @@ pub trait AsFilename {
         sealed: SealedFilename,
         function: impl FnOnce(*const u16) -> Result<R, crate::Error>,
     ) -> Result<R, crate::Error>;
+
     #[cfg(unix)]
     #[doc(hidden)]
     fn posix_filename<R>(
@@ -32,7 +33,11 @@ impl AsFilename for &str {
         _seal: SealedFilename,
         function: impl FnOnce(*const u16) -> Result<R, Error>,
     ) -> Result<R, Error> {
-        let utf16: alloc::vec::Vec<u16> = self.encode_utf16().chain(Some(0)).collect();
+        let utf16: alloc::vec::Vec<u16> = if crate::util::check_null_bytes(self.as_bytes())? {
+            self.encode_utf16().collect()
+        } else {
+            self.encode_utf16().chain(Some(0)).collect()
+        };
         function(utf16.as_ptr())
     }
 
@@ -110,10 +115,14 @@ mod std {
             _seal: SealedFilename,
             function: impl FnOnce(*const u16) -> Result<R, Error>,
         ) -> Result<R, Error> {
-            let wide: alloc::vec::Vec<u16> = std::os::windows::ffi::OsStrExt::encode_wide(self)
-                .chain(Some(0))
-                .collect();
-            function(wide.as_ptr())
+            use std::os::windows::ffi::OsStrExt;
+            let bytes = self.as_encoded_bytes();
+            let utf16: alloc::vec::Vec<u16> = if crate::util::check_null_bytes(bytes)? {
+                self.encode_wide().collect()
+            } else {
+                self.encode_wide().chain(Some(0)).collect()
+            };
+            function(utf16.as_ptr())
         }
 
         #[cfg(unix)]

tests/functions.rs

@@ -72,33 +72,34 @@ fn test_id_u32() {
 #[cfg(feature = "std")]
 #[test]
 fn test_as_filename_osstring() {
-    as_filename_test::<std::ffi::OsString>(lib_path().into_os_string());
+    as_filename_test::<std::ffi::OsString>(lib_path().into_os_string(), "potato\0beetroot".into());
 }
 
 #[cfg(feature = "std")]
 #[test]
 fn test_as_filename_osstr() {
-    as_filename_test::<&std::ffi::OsStr>(lib_path().as_os_str());
+    let with_nulls = std::ffi::OsStr::new("hazelnut\0peanut");
+    as_filename_test::<&std::ffi::OsStr>(lib_path().as_os_str(), with_nulls);
 }
 
 #[cfg(feature = "std")]
 #[test]
 fn test_as_filename_pathbuf() {
-    as_filename_test::<std::path::PathBuf>(lib_path());
+    as_filename_test::<std::path::PathBuf>(lib_path(), "orange\0grape".into());
 }
 
 #[cfg(feature = "std")]
 #[test]
 fn test_as_filename_path() {
-    as_filename_test::<&std::path::Path>(&*lib_path());
+    as_filename_test::<&std::path::Path>(&*lib_path(), std::path::Path::new("peach\0mango"));
 }
 
 #[cfg(feature = "std")]
 #[test]
 fn test_as_filename_str() {
     let path = lib_path();
     if let Some(p) = path.to_str() {
-        as_filename_test::<&str>(p);
+        as_filename_test::<&str>(p, "kiwi\0peach\0");
     }
 }
 
@@ -107,14 +108,18 @@ fn test_as_filename_str() {
 fn test_as_filename_string() {
     let path = lib_path();
     if let Some(p) = path.to_str() {
-        as_filename_test::<String>(p.to_string());
+        as_filename_test::<String>(p.to_string(), "apple\0banana".to_string());
     }
 }
 
 #[cfg(feature = "std")]
-fn as_filename_test<T: libloading::AsFilename>(path: T) {
+fn as_filename_test<T: libloading::AsFilename>(path: T, with_interior_nulls: T) {
     make_helpers();
     unsafe {
+        assert!(matches!(
+            Library::new(with_interior_nulls).unwrap_err(),
+            libloading::Error::InteriorZeroElements,
+        ));
         let lib = Library::new(path).unwrap();
         let f: Symbol<unsafe extern "C" fn(u32) -> u32> = lib.get(b"test_identity_u32\0").unwrap();
         assert_eq!(42, f(42));
@@ -126,13 +131,15 @@ fn as_filename_test<T: libloading::AsFilename>(path: T) {
 fn test_as_symbol_name_string() {
     as_symbol_name_test::<String>("test_identity_u32".to_string());
     as_symbol_name_test::<String>("test_identity_u32\0".to_string());
+    as_symbol_name_test_interior_nulls::<String>("test_iden\0tity_u32".to_string());
 }
 
 #[cfg(feature = "std")]
 #[test]
 fn test_as_symbol_name_str() {
     as_symbol_name_test::<&str>("test_identity_u32");
     as_symbol_name_test::<&str>("test_identity_u32\0");
+    as_symbol_name_test_interior_nulls::<&str>("test_iden\0tity_u32\0");
 }
 
 #[cfg(feature = "std")]
@@ -153,6 +160,9 @@ fn test_as_symbol_name_bytes() {
     as_symbol_name_test::<&[u8]>(b"test_identity_u32");
     as_symbol_name_test::<&[u8]>(b"test_identity_u32\0");
     as_symbol_name_test::<&[u8; 18]>(b"test_identity_u32\0");
+    as_symbol_name_test_interior_nulls::<&[u8]>(b"test_identity\0_u32");
+    as_symbol_name_test_interior_nulls::<&[u8]>(b"test\0_identity_u32");
+    as_symbol_name_test_interior_nulls::<&[u8; 19]>(b"test_iden\0tity_u32\0");
 }
 
 #[cfg(feature = "std")]
@@ -165,6 +175,18 @@ fn as_symbol_name_test<T: libloading::AsSymbolName>(symbol: T) {
     }
 }
 
+#[cfg(feature = "std")]
+fn as_symbol_name_test_interior_nulls<T: libloading::AsSymbolName>(symbol: T) {
+    make_helpers();
+    unsafe {
+        let lib = Library::new(lib_path()).unwrap();
+        assert!(matches!(
+            lib.get::<unsafe extern "C" fn(u32) -> u32>(symbol),
+            Err(libloading::Error::InteriorZeroElements),
+        ));
+    }
+}
+
 #[test]
 #[cfg(feature = "std")]
 fn test_try_into_ptr() {