💥 Unify solid entry reads with ReadOptions

Replace password-only solid entry APIs with ReadOptions-based variants so normal and solid reads share the same configuration and derived-key cache. Update CLI callers, examples, fuzz coverage, and tests for the unified API.

Author: ChanTsune

cli/src/command/core.rs

@@ -28,7 +28,7 @@ use path_slash::*;
 pub(crate) use path_transformer::PathTransformers;
 use pna::{
     Archive, EntryBuilder, EntryPart, LinkTargetType, MIN_CHUNK_BYTES_SIZE, NormalEntry,
-    PNA_HEADER, ReadEntry, SolidEntryBuilder, WriteOptions, prelude::*,
+    PNA_HEADER, ReadEntry, ReadOptions, SolidEntryBuilder, WriteOptions, prelude::*,
 };
 use std::{
     borrow::Cow,
@@ -1290,7 +1290,7 @@ impl TransformStrategy for TransformStrategyUnSolid {
     {
         match read_entry? {
             ReadEntry::Solid(s) => {
-                for n in s.entries(password)? {
+                for n in s.entries(ReadOptions::with_password(password))? {
                     if let Some(entry) = transformer(n.map(Into::into))? {
                         archive.add_entry(entry)?;
                     }
@@ -1334,7 +1334,7 @@ impl TransformStrategy for TransformStrategyKeepSolid {
                         .password(password)
                         .build(),
                 )?;
-                for n in s.entries(password)? {
+                for n in s.entries(ReadOptions::with_password(password))? {
                     if let Some(entry) = transformer(n.map(Into::into))? {
                         builder.add_entry(entry)?;
                     }
@@ -1426,43 +1426,39 @@ where
     Ok(())
 }
 
-pub(crate) fn run_process_archive<'p, Provider, F>(
+pub(crate) fn run_process_archive<F>(
     archive_provider: impl IntoIterator<Item = impl Read>,
-    mut password_provider: Provider,
+    read_options: &ReadOptions,
     mut processor: F,
     allow_concatenated_archives: bool,
 ) -> io::Result<()>
 where
-    Provider: FnMut() -> Option<&'p [u8]>,
     F: FnMut(io::Result<NormalEntry>) -> io::Result<()>,
 {
-    let password = password_provider();
     run_read_entries(
         archive_provider,
         |entry| match entry? {
-            ReadEntry::Solid(solid) => solid.entries(password)?.try_for_each(&mut processor),
+            ReadEntry::Solid(solid) => solid.entries(read_options)?.try_for_each(&mut processor),
             ReadEntry::Normal(regular) => processor(Ok(regular)),
         },
         allow_concatenated_archives,
     )
 }
 
-pub(crate) fn run_process_archive_stoppable<'p, Provider, F>(
+pub(crate) fn run_process_archive_stoppable<F>(
     archive_provider: impl IntoIterator<Item = impl Read>,
-    mut password_provider: Provider,
+    read_options: &ReadOptions,
     mut processor: F,
     allow_concatenated_archives: bool,
 ) -> io::Result<()>
 where
-    Provider: FnMut() -> Option<&'p [u8]>,
     F: FnMut(io::Result<NormalEntry>) -> io::Result<ProcessAction>,
 {
-    let password = password_provider();
     run_read_entries_stoppable(
         archive_provider,
         |entry| match entry? {
             ReadEntry::Solid(solid) => {
-                for n in solid.entries(password)? {
+                for n in solid.entries(read_options)? {
                     match processor(n)? {
                         ProcessAction::Continue => {}
                         ProcessAction::Stop => return Ok(ProcessAction::Stop),
@@ -1530,21 +1526,19 @@ where
 }
 
 #[cfg(feature = "memmap")]
-pub(crate) fn run_entries<'d, 'p, Provider, F>(
+pub(crate) fn run_entries<'d, F>(
     archives: impl IntoIterator<Item = &'d [u8]>,
-    mut password_provider: Provider,
+    read_options: &ReadOptions,
     mut processor: F,
 ) -> io::Result<()>
 where
-    Provider: FnMut() -> Option<&'p [u8]>,
     F: FnMut(io::Result<NormalEntry<Cow<'d, [u8]>>>) -> io::Result<()>,
 {
-    let password = password_provider();
     run_read_entries_mem(
         archives,
         |entry| match entry? {
             ReadEntry::Solid(s) => s
-                .entries(password)?
+                .entries(read_options)?
                 .try_for_each(|r| processor(r.map(Into::into))),
             ReadEntry::Normal(r) => processor(Ok(r)),
         },
@@ -1615,21 +1609,19 @@ where
 }
 
 #[cfg(feature = "memmap")]
-pub(crate) fn run_entries_stoppable<'d, 'p, Provider, F>(
+pub(crate) fn run_entries_stoppable<'d, F>(
     archives: impl IntoIterator<Item = &'d [u8]>,
-    mut password_provider: Provider,
+    read_options: &ReadOptions,
     mut processor: F,
 ) -> io::Result<()>
 where
-    Provider: FnMut() -> Option<&'p [u8]>,
     F: FnMut(io::Result<NormalEntry<Cow<'d, [u8]>>>) -> io::Result<ProcessAction>,
 {
-    let password = password_provider();
     run_read_entries_mem_stoppable(
         archives,
         |entry| match entry? {
             ReadEntry::Solid(s) => {
-                for n in s.entries(password)? {
+                for n in s.entries(read_options)? {
                     match processor(n.map(Into::into))? {
                         ProcessAction::Continue => {}
                         ProcessAction::Stop => return Ok(ProcessAction::Stop),
@@ -1898,9 +1890,10 @@ pub(crate) fn transform_archive_entries<R: io::Read>(
     allow_concatenated_archives: bool,
 ) -> io::Result<Vec<io::Result<Option<NormalEntry>>>> {
     let mut results = Vec::new();
+    let read_options = ReadOptions::with_password(password);
     run_process_archive(
         std::iter::once(reader),
-        || password,
+        &read_options,
         |entry| {
             let entry = entry?;
             if filter.excluded(entry.header().path()) {

cli/src/command/core/archive_source.rs

@@ -2,7 +2,7 @@
 use std::borrow::Cow;
 use std::{fs, io};
 
-use pna::{NormalEntry, ReadEntry};
+use pna::{NormalEntry, ReadEntry, ReadOptions};
 
 use super::TransformStrategy;
 
@@ -81,7 +81,8 @@ impl SplitArchiveReader {
         password: Option<&[u8]>,
         processor: impl FnMut(io::Result<NormalEntry>) -> io::Result<()>,
     ) -> io::Result<()> {
-        super::run_process_archive(self.files.drain(..), || password, processor, false)
+        let read_options = ReadOptions::with_password(password);
+        super::run_process_archive(self.files.drain(..), &read_options, processor, false)
     }
 
     #[cfg(feature = "memmap")]
@@ -90,11 +91,12 @@ impl SplitArchiveReader {
         password: Option<&[u8]>,
         mut processor: impl FnMut(io::Result<NormalEntry<Cow<'s, [u8]>>>) -> io::Result<()>,
     ) -> io::Result<()> {
+        let read_options = ReadOptions::with_password(password);
         super::run_read_entries_mem(
             self.mmaps.iter().map(|m| m.as_ref()),
             |entry| match entry? {
                 ReadEntry::Solid(s) => s
-                    .entries(password)?
+                    .entries(&read_options)?
                     .try_for_each(|r| processor(r.map(Into::into))),
                 ReadEntry::Normal(n) => processor(Ok(n)),
             },

cli/src/command/extract.rs

@@ -613,7 +613,7 @@ where
             if fast_read && !globs.is_empty() {
                 run_process_archive_stoppable(
                     reader,
-                    password_provider,
+                    read_options,
                     |entry| {
                         let item = entry.map_err(|e| {
                             io::Error::new(e.kind(), format!("reading archive entry: {e}"))
@@ -679,7 +679,7 @@ where
             } else {
                 run_process_archive(
                     reader,
-                    password_provider,
+                    read_options,
                     |entry| {
                         let item = entry.map_err(|e| {
                             io::Error::new(e.kind(), format!("reading archive entry: {e}"))
@@ -740,7 +740,7 @@ where
         if fast_read && !globs.is_empty() {
             run_process_archive_stoppable(
                 reader,
-                password_provider,
+                read_options,
                 |entry| {
                     let item = entry.map_err(|e| {
                         io::Error::new(e.kind(), format!("reading archive entry: {e}"))
@@ -795,7 +795,7 @@ where
         } else {
             run_process_archive(
                 reader,
-                password_provider,
+                read_options,
                 |entry| {
                     let item = entry.map_err(|e| {
                         io::Error::new(e.kind(), format!("reading archive entry: {e}"))
@@ -883,7 +883,7 @@ where
     rayon::scope_fifo(|s| -> anyhow::Result<()> {
         if fast_read && !globs.is_empty() {
             #[hooq::skip_all]
-            run_entries_stoppable(archives, password_provider, |entry| {
+            run_entries_stoppable(archives, read_options, |entry| {
                 let item = entry
                     .map_err(|e| io::Error::new(e.kind(), format!("reading archive entry: {e}")))?;
                 let item_path = item.name().to_string();
@@ -943,7 +943,7 @@ where
             .with_context(|| "streaming archive entries")?;
         } else {
             #[hooq::skip_all]
-            run_entries(archives, password_provider, |entry| {
+            run_entries(archives, read_options, |entry| {
                 let item = entry
                     .map_err(|e| io::Error::new(e.kind(), format!("reading archive entry: {e}")))?;
                 let Some(name) = filter_entry(&item, &mut globs, &args) else {

cli/src/command/list.rs

@@ -551,7 +551,7 @@ fn list_archive(ctx: &crate::cli::GlobalContext, args: ListCommand) -> anyhow::R
         |entry| {
         match entry? {
             ReadEntry::Solid(solid) if options.solid => {
-                for entry in solid.entries(password)? {
+                for entry in solid.entries(&read_options)? {
                     entries.push(TableRow::from_entry(
                         &entry?,
                         &read_options,
@@ -659,7 +659,7 @@ pub(crate) fn run_list_archive<'a>(
             |entry| {
                 match entry? {
                     ReadEntry::Solid(solid) if args.solid => {
-                        for entry in solid.entries(password)? {
+                        for entry in solid.entries(&read_options)? {
                             entries.push(TableRow::from_entry(
                                 &entry?,
                                 &read_options,
@@ -695,7 +695,7 @@ pub(crate) fn run_list_archive<'a>(
         |entry| {
             match entry? {
                 ReadEntry::Solid(solid) if args.solid => {
-                    for entry in solid.entries(password)? {
+                    for entry in solid.entries(&read_options)? {
                         let entry = entry?;
                         let entry_path = entry.name().to_string();
                         if !globs.matches_any_pattern(&entry_path) {

cli/src/command/verify.rs

@@ -127,7 +127,7 @@ fn verify_solid(
     fast: bool,
     report: &mut VerifyReport,
 ) -> io::Result<()> {
-    for entry in solid.entries(password)? {
+    for entry in solid.entries(read_options)? {
         verify_entry(&entry?, password, read_options, fast, report);
     }
     Ok(())

cli/tests/cli/stdio/option_ignore_zeros.rs

@@ -68,7 +68,7 @@ fn read_archive_entries(path: impl AsRef<Path>) -> Vec<(String, String)> {
     let mut archive = Archive::read_header(fs::File::open(path).unwrap()).unwrap();
     archive
         .entries()
-        .extract_solid_entries(None)
+        .extract_solid_entries(&ReadOptions::builder().build())
         .map(|entry| {
             let entry = entry.unwrap();
             let mut reader = entry.reader(ReadOptions::builder().build()).unwrap();
@@ -89,13 +89,18 @@ fn read_all_archive_entries_from_bytes(bytes: &[u8]) -> Vec<(String, String)> {
             Err(err) if err.kind() == std::io::ErrorKind::UnexpectedEof => break,
             Err(err) => panic!("unexpected archive read error: {err}"),
         };
-        entries.extend(archive.entries().extract_solid_entries(None).map(|entry| {
-            let entry = entry.unwrap();
-            let mut reader = entry.reader(ReadOptions::builder().build()).unwrap();
-            let mut content = String::new();
-            reader.read_to_string(&mut content).unwrap();
-            (entry.name().to_string(), content)
-        }));
+        entries.extend(
+            archive
+                .entries()
+                .extract_solid_entries(&ReadOptions::builder().build())
+                .map(|entry| {
+                    let entry = entry.unwrap();
+                    let mut reader = entry.reader(ReadOptions::builder().build()).unwrap();
+                    let mut content = String::new();
+                    reader.read_to_string(&mut content).unwrap();
+                    (entry.name().to_string(), content)
+                }),
+        );
         let _ = archive.into_inner();
     }
 

cli/tests/cli/stdio/option_mac_metadata.rs

@@ -11,7 +11,7 @@ fn read_archive_entries(bytes: &[u8]) -> Vec<(String, String)> {
     let mut archive = Archive::read_header(Cursor::new(bytes)).unwrap();
     archive
         .entries()
-        .extract_solid_entries(None)
+        .extract_solid_entries(&ReadOptions::builder().build())
         .map(|entry| {
             let entry = entry.unwrap();
             let mut reader = entry.reader(ReadOptions::builder().build()).unwrap();

cli/tests/cli/utils/archive.rs

@@ -1,3 +1,4 @@
+use pna::ReadOptions;
 use pna::prelude::*;
 use std::{
     fs::File,
@@ -113,7 +114,9 @@ pub fn extract_single_entry(
     name: &str,
 ) -> io::Result<Option<pna::NormalEntry>> {
     let mut archive = pna::Archive::open(path)?;
-    let entries = archive.entries().extract_solid_entries(None);
+    let entries = archive
+        .entries()
+        .extract_solid_entries(&ReadOptions::builder().build());
     for entry in entries {
         let entry = entry?;
         if entry.header().path() == name {
@@ -140,7 +143,8 @@ where
 {
     let password = password.into().map(|p| p.as_bytes());
     let mut archive = pna::Archive::open(path)?;
-    let entries = archive.entries().extract_solid_entries(password);
+    let read_options = ReadOptions::with_password(password);
+    let entries = archive.entries().extract_solid_entries(&read_options);
     for entry in entries {
         f(entry?);
     }

fuzz/fuzz_targets/split_archive.rs

@@ -34,7 +34,10 @@ fuzz_target!(|data: (&[u8], usize)| {
     let archive_bytes = archive.finalize().unwrap();
     let mut archive = Archive::read_header_from_slice(&archive_bytes).unwrap();
 
-    for entry in archive.entries_slice().extract_solid_entries(None) {
+    for entry in archive
+        .entries_slice()
+        .extract_solid_entries(&ReadOptions::builder().build())
+    {
         let entry = entry.unwrap();
         let read_option = ReadOptions::builder().build();
         let mut reader = entry.reader(read_option).unwrap();

lib/examples/async_io.rs

@@ -38,7 +38,7 @@ async fn extract(path: String) -> io::Result<()> {
     while let Some(entry) = archive.read_entry_async().await? {
         match entry {
             ReadEntry::Solid(solid_entry) => {
-                for entry in solid_entry.entries(None)? {
+                for entry in solid_entry.entries(ReadOptions::builder().build())? {
                     let entry = entry?;
                     let mut file = io::Cursor::new(Vec::new());
                     let mut reader = entry.reader(ReadOptions::builder().build())?.compat();