refactor!: store the file_name_raw only as key

src/read.rs

@@ -47,6 +47,7 @@
 /// If your logic depends on the buffer being completely populated, use [`Self::read_exact()`] instead. It will continue reading until the entire buffer is filled or an error occurs.
 #[derive(Debug)]
 pub struct ZipFile<'a, R: Read + ?Sized> {
+    pub(crate) file_name_raw: Cow<'a, [u8]>,
     pub(crate) data: Cow<'a, ZipFileData>,
     pub(crate) reader: ZipFileReader<'a, R>,
 }
@@ -78,7 +79,7 @@
 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 +89,11 @@
 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 +113,7 @@
 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 +125,7 @@
 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 +219,7 @@
     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());
         }
@@ -454,13 +456,13 @@
 pub(crate) fn central_header_to_zip_file<R: Read + Seek>(
     reader: &mut R,
     central_directory: &CentralDirectoryInfo,
-) -> ZipResult<ZipFileData> {
+) -> ZipResult<(ZipFileData, Box<[u8]>)> {
     let central_header_start = reader.stream_position()?;
 
     // Parse central header
     let block = ZipCentralEntryBlock::parse(reader)?;
 
-    let file = central_header_to_zip_file_inner(
+    let (file, file_name_raw) = central_header_to_zip_file_inner(
         reader,
         central_directory.archive_offset,
         central_header_start,
@@ -470,12 +472,12 @@
     let central_header_end = reader.stream_position()?;
 
     reader.seek(SeekFrom::Start(central_header_end))?;
-    Ok(file)
+    Ok((file, file_name_raw))
 }
 
 #[inline]
-fn read_variable_length_byte_field<R: Read>(reader: &mut R, len: usize) -> ZipResult<Box<[u8]>> {
-    let mut data = vec![0; len].into_boxed_slice();
+fn read_variable_length_byte_field<R: Read>(reader: &mut R, len: usize) -> ZipResult<Vec<u8>> {
+    let mut data = vec![0; len];
     if let Err(e) = reader.read_exact(&mut data) {
         if e.kind() == io::ErrorKind::UnexpectedEof {
             return Err(invalid!(
@@ -493,7 +495,7 @@
     archive_offset: u64,
     central_header_start: u64,
     block: ZipCentralEntryBlock,
-) -> ZipResult<ZipFileData> {
+) -> ZipResult<(ZipFileData, Box<[u8]>)> {
     let ZipCentralEntryBlock {
         // magic,
         version_made_by,
@@ -519,7 +521,7 @@
     let is_utf8 = ZipFlags::matching(flags, ZipFlags::LanguageEncoding);
     let using_data_descriptor = ZipFlags::matching(flags, ZipFlags::UsingDataDescriptor);
 
-    let file_name_raw = read_variable_length_byte_field(reader, file_name_length as usize)?;
+    let mut file_name_raw = read_variable_length_byte_field(reader, file_name_length as usize)?;
     let extra_field = read_variable_length_byte_field(reader, extra_field_length as usize)?;
     let file_comment_raw = read_variable_length_byte_field(reader, file_comment_length as usize)?;
     let file_name: Box<str> = if is_utf8 {
@@ -549,7 +551,6 @@
         uncompressed_size: uncompressed_size.into(),
         flags,
         file_name,
-        file_name_raw,
         extra_field: Some(Arc::from(extra_field)),
         central_extra_field: None,
         file_comment,
@@ -563,7 +564,7 @@
         aes_extra_data_start: 0,
         extra_fields: Vec::new(),
     };
-    parse_extra_field(&mut result)?;
+    parse_extra_field(&mut result, &mut file_name_raw)?;
 
     let aes_enabled = result.compression_method == CompressionMethod::AES;
     if aes_enabled && result.aes_mode.is_none() {
@@ -576,10 +577,13 @@
         .checked_add(archive_offset)
         .ok_or(invalid!("Archive header is too large"))?;
 
-    Ok(result)
+    Ok((result, file_name_raw.into()))
 }
 
-pub(crate) fn parse_extra_field(file: &mut ZipFileData) -> ZipResult<()> {
+pub(crate) fn parse_extra_field(
+    file: &mut ZipFileData,
+    file_name_raw: &mut Vec<u8>,
+) -> ZipResult<()> {
     let mut extra_field = file.extra_field.clone();
     let mut central_extra_field = file.central_extra_field.clone();
     for field_group in [&mut extra_field, &mut central_extra_field] {
@@ -594,7 +598,8 @@
         let mut position = reader.position();
         while position < len as u64 {
             let old_position = position;
-            let remove = parse_single_extra_field(file, &mut reader, position, false)?;
+            let remove =
+                parse_single_extra_field(file, &mut reader, position, false, file_name_raw)?;
             position = reader.position();
             if remove {
                 modified = true;
@@ -627,6 +632,7 @@
     reader: &mut R,
     bytes_already_read: u64,
     disallow_zip64: bool,
+    file_name_raw: &mut Vec<u8>,
 ) -> ZipResult<bool> {
     let kind = match reader.read_u16_le() {
         Ok(kind) => kind,
@@ -704,10 +710,11 @@
         Ok(UsedExtraField::UnicodePath) => {
             // Info-ZIP Unicode Path Extra Field
             // APPNOTE 4.6.9 and https://libzip.org/specifications/extrafld.txt
-            file.file_name_raw = UnicodeExtraField::try_from_reader(reader, len)?
-                .unwrap_valid(&file.file_name_raw)?;
-            file.file_name =
-                String::from_utf8(file.file_name_raw.clone().into_vec())?.into_boxed_str();
+            let unicode = UnicodeExtraField::try_from_reader(reader, len)?;
+            let file_name = unicode.unwrap_valid(&file_name_raw)?;
+            file_name_raw.clear();
+            file_name_raw.extend_from_slice(&file_name);
+            file.file_name = String::from_utf8(file_name_raw.to_vec())?.into_boxed_str();
             file.is_utf8 = true;
         }
         _ => {
@@ -805,7 +812,7 @@
     ///
     /// The encoding of this data is currently undefined.
     pub fn name_raw(&self) -> &[u8] {
-        &self.get_metadata().file_name_raw
+        &self.file_name_raw
     }
 
     /// Get the name of the file in a sanitized form. It truncates the name to the first NULL byte,

src/read/stream.rs

@@ -34,13 +34,13 @@ impl<R: Read> ZipStreamReader<R> {
 
         // Parse central header
         let block = ZipCentralEntryBlock::parse(&mut self.0)?;
-        let file = central_header_to_zip_file_inner(
+        let (file, file_name_raw) = central_header_to_zip_file_inner(
             &mut self.0,
             archive_offset,
             central_header_start,
             block,
         )?;
-        Ok(ZipStreamFileMetadata(file))
+        Ok(ZipStreamFileMetadata(file, file_name_raw))
     }
 
     /// Iterate over the stream and extract all file and their
@@ -63,10 +63,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)>)?;
 
@@ -135,7 +135,7 @@ pub trait ZipStreamVisitor {
 
 /// Additional metadata for the file.
 #[derive(Debug)]
-pub struct ZipStreamFileMetadata(ZipFileData);
+pub struct ZipStreamFileMetadata(ZipFileData, Box<[u8]>);
 
 impl ZipStreamFileMetadata {
     /// Get the name of the file
@@ -158,7 +158,7 @@ impl ZipStreamFileMetadata {
     ///
     /// The encoding of this data is currently undefined.
     pub fn name_raw(&self) -> &[u8] {
-        &self.0.file_name_raw
+        &self.1
     }
 
     /// Rewrite the path, ignoring any path components with special meaning.
@@ -249,9 +249,9 @@ pub fn read_zipfile_from_stream<R: Read>(reader: &mut R) -> ZipResult<Option<Zip
 
     let block = block.from_le();
 
-    let mut result = ZipFileData::from_local_block(block, reader)?;
+    let (mut result, mut file_name_raw) = ZipFileData::from_local_block(block, reader)?;
 
-    match parse_extra_field(&mut result) {
+    match parse_extra_field(&mut result, &mut file_name_raw) {
         Ok(..) | Err(ZipError::Io(..)) => {}
         Err(e) => return Err(e),
     }
@@ -268,6 +268,7 @@ pub fn read_zipfile_from_stream<R: Read>(reader: &mut R) -> ZipResult<Option<Zip
     } = result;
 
     Ok(Some(ZipFile {
+        file_name_raw: Cow::Owned(file_name_raw),
         data: Cow::Owned(result),
         reader: make_reader(
             compression_method,
@@ -300,7 +301,7 @@ pub fn read_zipfile_from_stream_with_compressed_size<R: io::Read>(
 
     let block = block.from_le();
 
-    let mut result = ZipFileData::from_local_block(block, reader)?;
+    let (mut result, file_name_raw) = ZipFileData::from_local_block(block, reader)?;
     result.compressed_size = compressed_size;
 
     if result.encrypted {
@@ -321,6 +322,7 @@ pub fn read_zipfile_from_stream_with_compressed_size<R: io::Read>(
     } = result;
 
     Ok(Some(ZipFile {
+        file_name_raw: Cow::Owned(file_name_raw),
         data: Cow::Owned(result),
         reader: make_reader(
             compression_method,

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.
@@ -32,7 +32,7 @@ pub struct ZipArchiveMetadata {
 
 #[derive(Debug)]
 pub(crate) struct SharedBuilder {
-    pub(crate) files: Vec<super::ZipFileData>,
+    pub(crate) files: Vec<(Box<[u8]>, ZipFileData)>,
     pub(super) offset: u64,
     pub(super) dir_start: u64,
     // This isn't yet used anywhere, but it is here for use cases in the future.
@@ -47,8 +47,8 @@ impl SharedBuilder {
         zip64_extensible_data_sector: Option<Box<[u8]>>,
     ) -> 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);
+        self.files.into_iter().for_each(|(file_name_raw, file)| {
+            index_map.insert(file_name_raw, file);
         });
         ZipArchiveMetadata {
             files: index_map,
@@ -90,7 +90,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,
@@ -201,8 +201,8 @@ impl<R: Read + Seek> ZipArchive<R> {
         let mut files = Vec::with_capacity(file_capacity);
         reader.seek(SeekFrom::Start(dir_info.directory_start))?;
         for _ in 0..dir_info.number_of_files {
-            let file = central_header_to_zip_file(reader, dir_info)?;
-            files.push(file);
+            let (file, file_name_raw) = central_header_to_zip_file(reader, dir_info)?;
+            files.push((file_name_raw, file));
         }
 
         Ok(SharedBuilder {
@@ -364,7 +364,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
@@ -414,7 +414,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
@@ -462,7 +462,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.
@@ -500,7 +500,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))
@@ -535,12 +535,13 @@ impl<R: Read + Seek> ZipArchive<R> {
     /// Get a contained file by index without decompressing it
     pub fn by_index_raw(&mut self, file_number: usize) -> ZipResult<ZipFile<'_, R>> {
         let reader = &mut self.reader;
-        let (_, data) = self
+        let (file_name_raw, data) = self
             .shared
             .files
             .get_index(file_number)
             .ok_or(ZipError::FileNotFound)?;
         Ok(ZipFile {
+            file_name_raw: Cow::Borrowed(file_name_raw),
             reader: ZipFileReader::Raw(data.find_content(reader)?),
             data: Cow::Borrowed(data),
         })
@@ -552,12 +553,11 @@ impl<R: Read + Seek> ZipArchive<R> {
         file_number: usize,
         mut options: ZipReadOptions<'_>,
     ) -> ZipResult<ZipFile<'_, R>> {
-        let (_, data) = self
+        let (file_name_raw, data) = self
             .shared
             .files
             .get_index(file_number)
             .ok_or(ZipError::FileNotFound)?;
-
         if options.ignore_encryption_flag {
             // Always use no password when we're ignoring the encryption flag.
             options.password = None;
@@ -584,6 +584,7 @@ impl<R: Read + Seek> ZipArchive<R> {
         };
 
         Ok(ZipFile {
+            file_name_raw: Cow::Borrowed(file_name_raw),
             data: Cow::Borrowed(data),
             reader: make_reader(
                 data.compression_method,