fix: allow for [u8] as filename (#775)

* use bytes direclty

* cargo fmt

* fix

* also on read

* add as bytes

* fmt

Author: Its-Just-Nans

src/read.rs

@@ -78,7 +78,7 @@ pub(crate) fn make_writable_dir_all<T: AsRef<Path>>(outpath: T) -> Result<(), Zi
 pub(crate) fn make_symlink_impl<T>(
     outpath: &Path,
     target_str: &str,
-    _existing_files: &IndexMap<Box<str>, T>,
+    _existing_files: &IndexMap<Box<[u8]>, T>,
 ) -> ZipResult<()> {
     std::os::unix::fs::symlink(Path::new(&target_str), outpath)?;
     Ok(())
@@ -88,10 +88,11 @@ pub(crate) fn make_symlink_impl<T>(
 pub(crate) fn make_symlink_impl<T>(
     outpath: &Path,
     target_str: &str,
-    existing_files: &IndexMap<Box<str>, T>,
+    existing_files: &IndexMap<Box<[u8]>, T>,
 ) -> ZipResult<()> {
     let target = Path::new(OsStr::new(&target_str));
-    let target_is_dir_from_archive = existing_files.contains_key(target_str) && is_dir(target_str);
+    let target_is_dir_from_archive =
+        existing_files.contains_key(target_str.as_bytes()) && is_dir(target_str);
     let target_is_dir = if target_is_dir_from_archive {
         true
     } else if let Ok(meta) = std::fs::metadata(target) {
@@ -111,7 +112,7 @@ pub(crate) fn make_symlink_impl<T>(
 pub(crate) fn make_symlink<T>(
     outpath: &Path,
     target: &[u8],
-    #[cfg_attr(not(any(windows, unix)), allow(unused))] existing_files: &IndexMap<Box<str>, T>,
+    #[cfg_attr(not(any(windows, unix)), allow(unused))] existing_files: &IndexMap<Box<[u8]>, T>,
 ) -> ZipResult<()> {
     let Ok(target_str) = std::str::from_utf8(target) else {
         return Err(invalid!("Invalid UTF-8 as symlink target"));
@@ -123,7 +124,7 @@ pub(crate) fn make_symlink<T>(
 pub(crate) fn make_symlink<T>(
     outpath: &Path,
     target: &[u8],
-    #[cfg_attr(not(any(windows, unix)), allow(unused))] existing_files: &IndexMap<Box<str>, T>,
+    #[cfg_attr(not(any(windows, unix)), allow(unused))] existing_files: &IndexMap<Box<[u8]>, T>,
 ) -> ZipResult<()> {
     let Ok(_) = std::str::from_utf8(target) else {
         return Err(invalid!("Invalid UTF-8 as symlink target"));
@@ -217,7 +218,7 @@ impl<R: Read + Seek> ZipArchive<R> {
     pub(crate) fn merge_contents<W: Write + Seek>(
         &mut self,
         mut w: W,
-    ) -> ZipResult<IndexMap<Box<str>, ZipFileData>> {
+    ) -> ZipResult<IndexMap<Box<[u8]>, ZipFileData>> {
         if self.shared.files.is_empty() {
             return Ok(IndexMap::new());
         }

src/read/stream.rs

@@ -61,10 +61,10 @@ impl<R: Read> ZipStreamReader<R> {
     /// Extraction is not atomic; If an error is encountered, some of the files
     /// may be left on disk.
     pub fn extract<P: AsRef<Path>>(self, directory: P) -> ZipResult<()> {
-        struct Extractor(PathBuf, IndexMap<Box<str>, ()>);
+        struct Extractor(PathBuf, IndexMap<Box<[u8]>, ()>);
         impl ZipStreamVisitor for Extractor {
             fn visit_file<R: Read>(&mut self, file: &mut ZipFile<'_, R>) -> ZipResult<()> {
-                self.1.insert(file.name().into(), ());
+                self.1.insert(file.name_raw().into(), ());
                 let mut outpath = self.0.clone();
                 file.safe_prepare_path(&self.0, &mut outpath, None::<&(_, fn(&Path) -> bool)>)?;
 

src/read/zip_archive.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 /// Immutable metadata about a `ZipArchive`.
 #[derive(Debug)]
 pub struct ZipArchiveMetadata {
-    pub(crate) files: IndexMap<Box<str>, ZipFileData>,
+    pub(crate) files: IndexMap<Box<[u8]>, ZipFileData>,
     pub(crate) offset: u64,
     pub(crate) dir_start: u64,
     // This isn't yet used anywhere, but it is here for use cases in the future.
@@ -48,7 +48,7 @@ impl SharedBuilder {
     ) -> ZipArchiveMetadata {
         let mut index_map = IndexMap::with_capacity(self.files.len());
         self.files.into_iter().for_each(|file| {
-            index_map.insert(file.file_name.clone(), file);
+            index_map.insert(file.file_name_raw.clone(), file);
         });
         ZipArchiveMetadata {
             files: index_map,
@@ -89,7 +89,7 @@ pub struct ZipArchive<R> {
 
 impl<R> ZipArchive<R> {
     pub(crate) fn from_finalized_writer(
-        files: IndexMap<Box<str>, ZipFileData>,
+        files: IndexMap<Box<[u8]>, ZipFileData>,
         comment: Box<[u8]>,
         zip64_extensible_data_sector: Option<Box<[u8]>>,
         reader: R,
@@ -363,7 +363,7 @@ impl<R: Read + Seek> ZipArchive<R> {
 
     /// Returns an iterator over all the file and directory names in this archive.
     pub fn file_names(&self) -> impl Iterator<Item = &str> {
-        self.shared.files.keys().map(std::convert::AsRef::as_ref)
+        self.shared.files.values().map(|f| f.file_name.as_ref())
     }
 
     /// Returns Ok(true) if any compressed data in this archive belongs to more than one file. This
@@ -413,7 +413,7 @@ impl<R: Read + Seek> ZipArchive<R> {
     /// Get the index of a file entry by name, if it's present.
     #[inline]
     pub fn index_for_name(&self, name: &str) -> Option<usize> {
-        self.shared.files.get_index_of(name)
+        self.shared.files.get_index_of(name.as_bytes())
     }
 
     /// Search for a file entry by path, decrypt with given password
@@ -461,7 +461,7 @@ impl<R: Read + Seek> ZipArchive<R> {
         self.shared
             .files
             .get_index(index)
-            .map(|(name, _)| name.as_ref())
+            .map(|(_, file)| file.file_name.as_ref())
     }
 
     /// Search for a file entry by name and return a seekable object.
@@ -499,7 +499,7 @@ impl<R: Read + Seek> ZipArchive<R> {
         name: &str,
         password: Option<&[u8]>,
     ) -> ZipResult<ZipFile<'a, R>> {
-        let Some(index) = self.shared.files.get_index_of(name) else {
+        let Some(index) = self.shared.files.get_index_of(name.as_bytes()) else {
             return Err(ZipError::FileNotFound);
         };
         self.by_index_with_options(index, ZipReadOptions::new().password(password))

src/write.rs

@@ -172,7 +172,7 @@ pub(crate) mod zip_writer {
     /// ```
     pub struct ZipWriter<W: Write + Seek> {
         pub(super) inner: GenericZipWriter<W>,
-        pub(super) files: IndexMap<Box<str>, ZipFileData>,
+        pub(super) files: IndexMap<Box<[u8]>, ZipFileData>,
         pub(super) stats: ZipWriterStats,
         pub(super) writing_to_file: bool,
         pub(super) writing_raw: bool,
@@ -835,7 +835,6 @@ impl<A: Read + Write + Seek> ZipWriter<A> {
     pub fn new_append_with_config(config: Config, mut readwriter: A) -> ZipResult<ZipWriter<A>> {
         readwriter.seek(SeekFrom::Start(0))?;
         let shared = ZipArchive::get_metadata(config, &mut readwriter)?;
-
         Ok(ZipWriter {
             inner: GenericZipWriter::Storer(MaybeEncrypted::Unencrypted(readwriter)),
             files: shared.files,
@@ -873,11 +872,11 @@ impl<A: Read + Write + Seek> ZipWriter<A> {
     /// widely-compatible archive compared to [`Self::shallow_copy_file`]. Does not copy alignment.
     pub fn deep_copy_file(&mut self, src_name: &str, dest_name: &str) -> ZipResult<()> {
         self.finish_file()?;
-        if src_name == dest_name || self.files.contains_key(dest_name) {
+        if src_name == dest_name || self.files.contains_key(dest_name.as_bytes()) {
             return Err(invalid!("That file already exists"));
         }
         let write_position = self.inner.try_inner_mut()?.stream_position()?;
-        let src_index = self.index_by_name(src_name)?;
+        let src_index = self.index_by_name(src_name.as_bytes())?;
         let src_data = &mut self.files[src_index];
         let src_data_start = src_data.data_start(self.inner.try_inner_mut()?)?;
         debug_assert!(src_data_start <= write_position);
@@ -894,9 +893,8 @@ impl<A: Read + Write + Seek> ZipWriter<A> {
             .try_inner_mut()?
             .seek(SeekFrom::Start(write_position))?;
         let mut new_data = src_data.clone();
-        let dest_name_raw = dest_name.as_bytes();
+        new_data.file_name_raw = dest_name.as_bytes().into();
         new_data.file_name = dest_name.into();
-        new_data.file_name_raw = dest_name_raw.into();
         new_data.header_start = write_position;
         let extra_data_start = write_position
             + (size_of::<Magic>() + size_of::<ZipLocalEntryBlock>()) as u64
@@ -989,7 +987,6 @@ impl<A: Read + Write + Seek> ZipWriter<A> {
         let comment = mem::take(&mut self.comment);
         let zip64_extensible_data_sector = mem::take(&mut self.zip64_extensible_data_sector);
         let files = mem::take(&mut self.files);
-
         Ok(ZipArchive::from_finalized_writer(
             files,
             comment,
@@ -1381,10 +1378,10 @@ impl<W: Write + Seek> ZipWriter<W> {
     }
 
     fn insert_file_data(&mut self, file: ZipFileData) -> ZipResult<usize> {
-        if self.files.contains_key(&file.file_name) {
+        if self.files.contains_key(&file.file_name_raw) {
             return Err(invalid!("Duplicate filename: {}", file.file_name));
         }
-        let (index, _) = self.files.insert_full(file.file_name.clone(), file);
+        let (index, _) = self.files.insert_full(file.file_name_raw.clone(), file);
         Ok(index)
     }
 
@@ -1962,7 +1959,7 @@ impl<W: Write + Seek> ZipWriter<W> {
         Ok(central_start)
     }
 
-    fn index_by_name(&self, name: &str) -> ZipResult<usize> {
+    fn index_by_name(&self, name: &[u8]) -> ZipResult<usize> {
         self.files.get_index_of(name).ok_or(ZipError::FileNotFound)
     }
 
@@ -1976,7 +1973,7 @@ impl<W: Write + Seek> ZipWriter<W> {
         if src_name == dest_name {
             return Err(invalid!("Trying to copy a file to itself"));
         }
-        let src_index = self.index_by_name(src_name)?;
+        let src_index = self.index_by_name(src_name.as_bytes())?;
         let mut dest_data = self.files[src_index].clone();
         dest_data.file_name = dest_name.into();
         dest_data.file_name_raw = dest_name.as_bytes().into();