From e892560486a79b9fdd963d0bec91177dfe2823e9 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:14:58 +0100 Subject: [PATCH 01/44] fix(arca-tar): read GNU and pax long names, and tarballs made from "." MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A tarball whose paths run past 100 bytes, which GNU tar writes with an "L" header and pax with an "x" record, failed with "GNU tar long headers are not supported yet" or listed the pax records as junk files with the names cut short. GitHub and `git archive` tarballs also start with a global pax header that was extracted as a file. The reader now applies "L" and pax path, size and mtime to the entry that follows and skips "K" and global headers, with every payload held to a limit before it is read. Sizes and times in GNU's base-256 form are read. A tar made with `tar -C folder .` names everything "./…" and adds "./" for the folder; the prefix is dropped and the folder is no longer an entry, which made extraction fail with "empty name". A .tar.gz split across several gzip members, as pigz writes them, is read to the end instead of stopping after the first. interop.sh now extracts GNU, pax and split tarballs with long names and compares them with the source. Closes #102 Co-Authored-By: Claude Opus 5.5 --- arca-cli/src/main.rs | 2 +- arca-gui/src/archive_ops/io.rs | 2 +- arca-tar/src/lib.rs | 424 +++++++++++++++++++++++++++++---- interop.sh | 18 ++ 4 files changed, 401 insertions(+), 45 deletions(-) diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index a3930ffc..74414bb9 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -174,7 +174,7 @@ fn tar_source(archive: &Path, format_kind: Format) -> Result> { _ => { let f = BufReader::with_capacity(BUF, File::open(archive)?); if format_kind == Format::TarGz { - Box::new(flate2::read::GzDecoder::new(f)) + Box::new(flate2::read::MultiGzDecoder::new(f)) } else { Box::new(f) } diff --git a/arca-gui/src/archive_ops/io.rs b/arca-gui/src/archive_ops/io.rs index f9047ff8..ef0e6f3e 100644 --- a/arca-gui/src/archive_ops/io.rs +++ b/arca-gui/src/archive_ops/io.rs @@ -93,7 +93,7 @@ pub(crate) fn open_source(archive: &Path, format: Format) -> arca_core::Result Box::new(flate2::read::GzDecoder::new(f)), + Format::TarGz => Box::new(flate2::read::MultiGzDecoder::new(f)), _ => Box::new(f), }) } diff --git a/arca-tar/src/lib.rs b/arca-tar/src/lib.rs index 46b3f32c..e82c5300 100644 --- a/arca-tar/src/lib.rs +++ b/arca-tar/src/lib.rs @@ -28,6 +28,106 @@ fn octal(field: &[u8], what: &str) -> Result { Ok(v) } +/// A numeric field, in octal or, with the top bit of its first byte set, in the +/// base-256 GNU tar uses for sizes over 8 GiB and times before 1970. +fn number(field: &[u8], what: &str) -> Result { + let overflow = || Error::Limit(format!("{what}: overflow")); + match field.first() { + Some(&first) if first & 0x80 != 0 => { + // Big-endian, in two's complement over the whole field when the + // second bit says negative, with the marker bit aside otherwise. + if field.len() > 15 { + return Err(overflow()); + } + let negative = first & 0x40 != 0; + let mut v: i128 = 0; + for (i, &byte) in field.iter().enumerate() { + let byte = if i == 0 && !negative { + byte & 0x7f + } else { + byte + }; + v = v * 256 + i128::from(byte); + } + if negative { + v -= 1i128 << (8 * field.len()); + } + i64::try_from(v).map_err(|_| overflow()) + } + _ => i64::try_from(octal(field, what)?).map_err(|_| overflow()), + } +} + +fn unsigned(field: &[u8], what: &str) -> Result { + u64::try_from(number(field, what)?).map_err(|_| Error::Format(format!("{what}: negative"))) +} + +/// The most a pax header may hold. Real ones are a few hundred bytes; this is +/// room for a long path and every attribute tar knows, and no more. +const PAX_LIMIT: u64 = 64 * 1024; + +/// What the extension headers in front of an entry say about it. +#[derive(Default)] +struct Longer { + name: Option, + size: Option, + mtime: Option, +} + +impl Longer { + fn is_empty(&self) -> bool { + self.name.is_none() && self.size.is_none() && self.mtime.is_none() + } + + /// Reads pax records, each ` =\n` where the length + /// counts the whole record, itself included. + fn apply_pax(&mut self, mut data: &[u8]) -> Result<()> { + let bad = || Error::Format("a malformed pax record".into()); + while !data.is_empty() { + let space = data.iter().position(|&b| b == b' ').ok_or_else(bad)?; + let length: usize = std::str::from_utf8(&data[..space]) + .ok() + .and_then(|s| s.parse().ok()) + .ok_or_else(bad)?; + if length <= space + 1 || length > data.len() || data[length - 1] != b'\n' { + return Err(bad()); + } + let record = &data[space + 1..length - 1]; + let equals = record.iter().position(|&b| b == b'=').ok_or_else(bad)?; + let (key, value) = (&record[..equals], &record[equals + 1..]); + let value = std::str::from_utf8(value).map_err(|_| bad())?; + match key { + b"path" => self.name = Some(value.to_string()), + b"size" => self.size = Some(value.parse().map_err(|_| bad())?), + b"mtime" => { + let whole = value.split('.').next().unwrap_or(value); + self.mtime = Some(whole.parse().map_err(|_| bad())?); + } + _ => {} + } + data = &data[length..]; + } + Ok(()) + } +} + +/// A name without the `./` in front of it, however many times it is there. +fn without_current(name: &str) -> &str { + let mut name = name; + while let Some(rest) = name.strip_prefix("./") { + name = rest.trim_start_matches('/'); + } + if name == "." { + "" + } else { + name + } +} + +fn dangling() -> Error { + Error::Format("an extension header with no entry after it".into()) +} + fn write_octal(dest: &mut [u8], value: u64) { let width = dest.len() - 1; let s = format!("{value:0width$o}", width = width); @@ -91,60 +191,112 @@ impl TarReader { self.source } + /// The next file or folder. The headers GNU tar and pax put in front of + /// one to give it a longer name, a larger size or an exact time are read + /// and applied here, never returned as entries of their own. pub fn next_entry(&mut self) -> Result> { if self.finished { return Ok(None); } - let mut header = [0u8; BLOCK]; - match self.source.read_exact(&mut header) { - Ok(()) => {} - Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => { - self.finished = true; - return Ok(None); + let (header, longer, name) = loop { + let mut longer = Longer::default(); + let header = loop { + let mut header = [0u8; BLOCK]; + match self.source.read_exact(&mut header) { + Ok(()) => {} + Err(e) if e.kind() == io::ErrorKind::UnexpectedEof => { + self.finished = true; + return if longer.is_empty() { + Ok(None) + } else { + Err(dangling()) + }; + } + Err(e) => return Err(Error::Io(e)), + } + self.pos += BLOCK as u64; + + if header.iter().all(|&b| b == 0) { + self.finished = true; + return if longer.is_empty() { + Ok(None) + } else { + Err(dangling()) + }; + } + + let declared = octal(&header[148..156], "checksum")? as u32; + let actual = checksum(&header); + if declared != actual { + return Err(Error::Format(format!( + "invalid header checksum: {declared} declared, {actual} computed" + ))); + } + let size = unsigned(&header[124..136], "size")?; + match header[156] { + b'L' => { + let name = self.payload(size, limits::MAX_NAME as u64 + 1)?; + longer.name = Some(text_field(&name)); + } + b'K' => { + self.payload(size, limits::MAX_NAME as u64 + 1)?; + } + b'x' => { + let records = self.payload(size, PAX_LIMIT)?; + longer.apply_pax(&records)?; + } + // The global header every `git archive` tarball starts with. + // Nothing in it names a file, so it is stepped over. + b'g' => self.payload(size, PAX_LIMIT).map(|_| ())?, + _ => break header, + } + }; + + let name = match longer.name.take() { + Some(name) => name, + None => { + let base_name = text_field(&header[0..100]); + let prefix = if &header[257..262] == b"ustar" { + text_field(&header[345..500]) + } else { + String::new() + }; + if prefix.is_empty() { + base_name + } else { + format!("{prefix}/{base_name}") + } + } + }; + if name.len() > limits::MAX_NAME { + return Err(Error::Limit("name too long".into())); } - Err(e) => return Err(Error::Io(e)), - } - self.pos += BLOCK as u64; - - if header.iter().all(|&b| b == 0) { - self.finished = true; - return Ok(None); - } - - let declared = octal(&header[148..156], "checksum")? as u32; - let actual = checksum(&header); - if declared != actual { - return Err(Error::Format(format!( - "invalid header checksum: {declared} declared, {actual} computed" - ))); - } + // `tar -C folder .` names everything `./…` and adds `./` for the + // folder itself. The prefix says nothing, and the folder is wherever + // the archive is extracted to, so it is not an entry of its own. + let bare = without_current(&name); + if bare.is_empty() { + if header[156] == b'5' || name.ends_with('/') || name == "." { + let size = unsigned(&header[124..136], "size")?; + self.skip(longer.size.unwrap_or(size))?; + continue; + } + return Err(Error::Format("an entry without a name".into())); + } + break (header, longer, bare.to_string()); + }; - let base_name = text_field(&header[0..100]); - let prefix = if &header[257..262] == b"ustar" { - text_field(&header[345..500]) - } else { - String::new() + let size = match longer.size { + Some(size) => size, + None => unsigned(&header[124..136], "size")?, }; - let name = if prefix.is_empty() { - base_name - } else { - format!("{prefix}/{base_name}") + let mtime = match longer.mtime { + Some(mtime) => mtime, + None => number(&header[136..148], "mtime")?, }; - if name.len() > limits::MAX_NAME { - return Err(Error::Limit("name too long".into())); - } - - let size = octal(&header[124..136], "size")?; - let mtime = octal(&header[136..148], "mtime")? as i64; let kind = header[156]; let is_dir = kind == b'5' || name.ends_with('/'); - if kind == b'L' || kind == b'K' { - return Err(Error::Unsupported( - "GNU tar long headers are not supported yet".into(), - )); - } - let entry = Entry { // A tar name is bytes too, but this reader has always taken them as // UTF-8 and no tar carries a flag to argue with. @@ -172,6 +324,38 @@ impl TarReader { })) } + /// The data of an extension header, read whole and with its padding. Its + /// size comes from the archive, so it is held to `limit` before anything + /// is set aside for it. + fn payload(&mut self, size: u64, limit: u64) -> Result> { + if size > limit { + return Err(Error::Limit(format!("an extension header of {size} bytes"))); + } + let padded = size.div_ceil(BLOCK as u64) * BLOCK as u64; + let mut data = vec![0u8; padded as usize]; + self.source.read_exact(&mut data).map_err(|e| { + if e.kind() == io::ErrorKind::UnexpectedEof { + Error::Format("an extension header is truncated".into()) + } else { + Error::Io(e) + } + })?; + self.pos += padded; + data.truncate(size as usize); + Ok(data) + } + + /// Steps over `size` bytes of data and their padding. + fn skip(&mut self, size: u64) -> Result<()> { + let padded = size.div_ceil(BLOCK as u64) * BLOCK as u64; + let n = io::copy(&mut (&mut self.source).take(padded), &mut io::sink())?; + self.pos += n; + if n < padded { + return Err(Error::Io(truncated())); + } + Ok(()) + } + pub fn copy_data(&mut self, e: &TarEntry, dest: &mut W) -> Result { let n = io::copy(&mut (&mut self.source).take(e.data), dest)?; self.pos += n; @@ -427,4 +611,158 @@ mod tests { let _ = r.next_entry(); } } + + /// A header of `kind` for `name` holding `size` bytes, as GNU tar and + /// pax write their extension headers. + fn header(name: &str, kind: u8, size: u64) -> Vec { + let mut h = [0u8; BLOCK]; + h[..name.len()].copy_from_slice(name.as_bytes()); + write_octal(&mut h[100..108], 0o644); + write_octal(&mut h[124..136], size); + write_octal(&mut h[136..148], 1_700_000_000); + h[156] = kind; + h[257..262].copy_from_slice(b"ustar"); + let sum = checksum(&h); + write_octal(&mut h[148..155], u64::from(sum)); + h[155] = b' '; + h.to_vec() + } + + fn padded(data: &[u8]) -> Vec { + let mut out = data.to_vec(); + out.resize(data.len().div_ceil(BLOCK) * BLOCK, 0); + out + } + + fn pax(records: &[(&str, &str)]) -> Vec { + let mut out = Vec::new(); + for (key, value) in records { + let body = format!(" {key}={value}\n"); + let mut length = body.len() + 1; + while format!("{length}{body}").len() != length { + length += 1; + } + out.extend_from_slice(format!("{length}{body}").as_bytes()); + } + out + } + + type Listed = (String, u64, i64, Vec); + + fn names(tar: &[u8]) -> Result> { + let mut r = TarReader::new(tar); + let mut out = Vec::new(); + while let Some(e) = r.next_entry()? { + let mut data = Vec::new(); + r.copy_data(&e, &mut data)?; + out.push((e.entry.name, e.entry.size, e.entry.mtime.unwrap(), data)); + } + Ok(out) + } + + fn end() -> Vec { + vec![0u8; BLOCK * 2] + } + + #[test] + fn a_gnu_long_name_names_the_entry_after_it() { + let long = format!("{}/{}.txt", "d".repeat(120), "f".repeat(40)); + let mut tar = header("././@LongLink", b'L', long.len() as u64 + 1); + tar.extend(padded(format!("{long}\0").as_bytes())); + tar.extend(header("short-cut-name", b'0', 2)); + tar.extend(padded(b"hi")); + tar.extend(header("././@LongLink", b'K', 10)); + tar.extend(padded(b"target.txt")); + tar.extend(header("link", b'2', 0)); + tar.extend(end()); + let got = names(&tar).unwrap(); + assert_eq!(got[0].0, long); + assert_eq!(got[0].3, b"hi"); + assert_eq!(got[1].0, "link"); + assert_eq!(got.len(), 2); + } + + #[test] + fn pax_records_override_the_header_and_global_ones_are_skipped() { + let long = format!("{}/{}.bin", "p".repeat(150), "q".repeat(30)); + let global = pax(&[("comment", "made by git archive")]); + let mut tar = header("pax_global_header", b'g', global.len() as u64); + tar.extend(padded(&global)); + let local = pax(&[("path", &long), ("mtime", "1234567890.25"), ("size", "3")]); + tar.extend(header("PaxHeaders/x", b'x', local.len() as u64)); + tar.extend(padded(&local)); + tar.extend(header("cut", b'0', 0)); + tar.extend(padded(b"abc")); + tar.extend(end()); + let got = names(&tar).unwrap(); + assert_eq!(got.len(), 1); + assert_eq!(got[0].0, long); + assert_eq!((got[0].1, got[0].2), (3, 1_234_567_890)); + assert_eq!(got[0].3, b"abc"); + } + + #[test] + fn the_folder_tar_was_run_in_is_not_an_entry() { + let mut tar = header("./", b'5', 0); + tar.extend(header("./a.txt", b'0', 1)); + tar.extend(padded(b"a")); + tar.extend(header("././b/", b'5', 0)); + tar.extend(end()); + let got = names(&tar).unwrap(); + let got: Vec<&str> = got.iter().map(|e| e.0.as_str()).collect(); + assert_eq!(got, ["a.txt", "b/"]); + let mut nameless = header("", b'0', 0); + nameless.extend(end()); + assert!(names(&nameless).is_err()); + } + + #[test] + fn base_256_numbers_are_read() { + let mut field = [0u8; 12]; + field[0] = 0x80; + field[11] = 5; + field[7] = 1; + assert_eq!(number(&field, "size").unwrap(), (1i64 << 32) + 5); + let negative = [0xffu8; 12]; + assert_eq!(number(&negative, "mtime").unwrap(), -1); + assert!(unsigned(&negative, "size").is_err()); + let mut huge = [0u8; 12]; + huge[0] = 0x80; + huge[1] = 0x7f; + assert!(number(&huge, "size").is_err()); + } + + #[test] + fn broken_extension_headers_are_errors_not_panics() { + let name = b"long-name.txt\0"; + // A long name with nothing after it. + let mut alone = header("././@LongLink", b'L', name.len() as u64); + alone.extend(padded(name)); + assert!(names(&alone).is_err()); + let mut then_end = alone.clone(); + then_end.extend(end()); + assert!(names(&then_end).is_err()); + // Cut in the middle of its own data. + let mut cut = header("././@LongLink", b'L', 600); + cut.extend(vec![b'a'; 100]); + assert!(names(&cut).is_err()); + // Larger than any name may be. + let mut huge = header("././@LongLink", b'L', 100_000); + huge.extend(end()); + assert!(matches!(names(&huge), Err(Error::Limit(_)))); + // Pax records that do not add up. + for records in [ + &b"99 path=x\n"[..], + b"9 pathx\n", + b"x path=y\n", + b"10 path=xy", + b"3 a\n", + ] { + let mut tar = header("PaxHeaders/x", b'x', records.len() as u64); + tar.extend(padded(records)); + tar.extend(header("a.txt", b'0', 0)); + tar.extend(end()); + assert!(names(&tar).is_err(), "{}", String::from_utf8_lossy(records)); + } + } } diff --git a/interop.sh b/interop.sh index f82b9e99..6b5c1915 100644 --- a/interop.sh +++ b/interop.sh @@ -66,6 +66,24 @@ for f in t.tar t.tar.gz; do H=$(cd y/src && find . -type f | sort | xargs sha256sum | sha256sum | cut -d' ' -f1) [ "$H" = "$REF" ] && ok "Arca extracts tar's $f without losing a byte" || ko "Arca mis-extracts $f" done +# Names past ustar's 100 bytes, in both ways tar spells them, archived from +# inside the folder so every name starts with ./ as GitHub release tarballs +# do, and a .tar.gz split across two gzip members as pigz writes them. +LONG="long/$(printf 'd%.0s' {1..120})/$(printf 'e%.0s' {1..90})" +mkdir -p "$LONG" && cp -r src "$LONG/" +LREF=$(cd long && find . -type f | sort | xargs sha256sum | sha256sum | cut -d' ' -f1) +tar --format=gnu -czf out/long-gnu.tar.gz -C long . +tar --format=pax -czf out/long-pax.tar.gz -C long . +tar --format=gnu -cf out/long.tar -C long . +head -c 4096 out/long.tar | gzip -c > out/long-split.tar.gz +tail -c +4097 out/long.tar | gzip -c >> out/long-split.tar.gz +for f in long-gnu long-pax long-split; do + rm -rf y; mkdir y + $ARCA extract out/$f.tar.gz -o y >/dev/null 2>&1 || { ko "arca extract $f.tar.gz"; continue; } + H=$(cd y && find . -type f | sort | xargs sha256sum | sha256sum | cut -d' ' -f1) + [ "$H" = "$LREF" ] && ok "Arca extracts $f.tar.gz with its long names" || ko "Arca mis-extracts $f.tar.gz" +done +rm -rf long 7z a -tzip -mx5 out/s7.zip src >/dev/null 2>&1 rm -rf y; mkdir y; $ARCA extract out/s7.zip -o y >/dev/null 2>&1 H=$(cd y/src && find . -type f|sort|xargs sha256sum|sha256sum|cut -d' ' -f1) From 46175b847bda398ca2a886550021b364a497456c Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:17:56 +0100 Subject: [PATCH 02/44] fix(arca-gui): show what a .tar.gz or .tar.xz saved A tar entry has no compressed size of its own: the whole stream is compressed, so each one reports its own size. Adding those up made the status bar say every .tar.xz saved 0.0% and was as large as its contents. For the tar family the packed size is now the archive file's, read once when the listing arrives, and the saving of a plain .tar, a little larger than what it holds, shows as 0% rather than negative. The Packed and Saved columns stay empty for their entries, which have neither. Closes #103 Co-Authored-By: Claude Opus 5.5 --- arca-gui/src/controller/jobs_tests.rs | 28 +++++++++++++++++++++++++++ arca-gui/src/controller/mod.rs | 11 +++++++++-- arca-gui/src/controller/state.rs | 2 ++ arca-gui/src/model.rs | 10 ++++++++++ arca-gui/src/ui/browser.rs | 12 +++++++++++- 5 files changed, 60 insertions(+), 3 deletions(-) diff --git a/arca-gui/src/controller/jobs_tests.rs b/arca-gui/src/controller/jobs_tests.rs index 3f2c29f7..b7f46247 100644 --- a/arca-gui/src/controller/jobs_tests.rs +++ b/arca-gui/src/controller/jobs_tests.rs @@ -555,6 +555,34 @@ fn leaving_for_the_disk_forgets_a_cut_out_of_the_archive() { assert!(app.state.cut_names.is_empty()); } +// A tar.xz compresses the whole stream, so the saving is the file against +// what it holds; summing the entries said 0% for every one of them. +#[test] +fn a_compressed_tar_says_how_much_its_file_saved() { + let room = Room::new(); + let source = room.path("source"); + std::fs::create_dir_all(&source).unwrap(); + std::fs::write(source.join("a.txt"), "the same line again\n".repeat(5000)).unwrap(); + let archive = room.path("saved.tar.xz"); + crate::archive_ops::compress( + &archive, + &[source], + Format::TarXz, + arca_core::Codec::Deflate, + arca_core::Level::NORMAL, + &|_, _, _| true, + (None, false), + ) + .unwrap(); + let mut app = AppController::new(Settings::default()); + app.open_with_password(archive.clone(), None); + settle(&mut app); + let bytes = std::fs::metadata(&archive).unwrap().len(); + let summary = app.summary(); + assert!(summary.contains(&human(bytes)), "{summary}"); + assert!(!summary.contains(" 0.0%"), "{summary}"); +} + #[test] fn a_rewrite_that_failed_behind_keeps_the_reread_of_the_one_before() { let room = Room::new(); diff --git a/arca-gui/src/controller/mod.rs b/arca-gui/src/controller/mod.rs index c063fde6..c11cdb4c 100644 --- a/arca-gui/src/controller/mod.rs +++ b/arca-gui/src/controller/mod.rs @@ -797,6 +797,7 @@ impl AppController { add_password: String::new(), hide_names: false, archive_password: None, + archive_bytes: None, reread_dir: None, reread_queued: None, history: vec![String::new()], @@ -853,11 +854,16 @@ impl AppController { } let n = self.state.entries.iter().filter(|e| !e.is_dir).count(); let raw: u64 = self.state.entries.iter().map(|e| e.size).sum(); - let packed: u64 = self.state.entries.iter().map(|e| e.compressed_size).sum(); + let packed: u64 = match self.state.archive_bytes { + Some(bytes) if whole_stream(self.state.format) => bytes, + _ => self.state.entries.iter().map(|e| e.compressed_size).sum(), + }; + // A plain .tar is a little larger than what it holds, and "-2% saved" + // says nothing anybody wants to know. let ratio = if raw == 0 { 0.0 } else { - (1.0 - packed as f64 / raw as f64) * 100.0 + ((1.0 - packed as f64 / raw as f64) * 100.0).max(0.0) }; format!( "{n} {} \u{b7} {} {} \u{b7} {} {} \u{b7} {ratio:.1}% {}", @@ -1861,6 +1867,7 @@ impl AppController { if let Some(f) = detect(&path) { self.state.format = f; } + self.state.archive_bytes = fs::metadata(&path).ok().map(|m| m.len()); // The name of what is open goes where every other // program puts it, which frees a whole row above the // list for nothing at all. diff --git a/arca-gui/src/controller/state.rs b/arca-gui/src/controller/state.rs index 98601690..4003470c 100644 --- a/arca-gui/src/controller/state.rs +++ b/arca-gui/src/controller/state.rs @@ -69,6 +69,8 @@ pub(crate) struct AppState { // Held for the archive currently open in the window, so extracting from it // does not ask again for every button press. pub(crate) archive_password: Option, + /// The size of the open archive's file, read when its listing arrives. + pub(crate) archive_bytes: Option, // The folder to restore after rereading a rewritten archive. It is consumed // by the next listing, so opening an archive normally still starts at root. pub(crate) reread_dir: Option, diff --git a/arca-gui/src/model.rs b/arca-gui/src/model.rs index 20a21c9e..a3d6a190 100644 --- a/arca-gui/src/model.rs +++ b/arca-gui/src/model.rs @@ -45,6 +45,16 @@ pub(crate) fn read_only_suffix(format: Option) -> String { } } +/// Whether a format compresses the archive as one stream rather than entry by +/// entry, so that no entry has a compressed size of its own and only the +/// file's size says how much was saved. +pub(crate) fn whole_stream(format: Format) -> bool { + matches!( + format.container(), + arca_core::Container::Tar | arca_core::Container::TarGz | arca_core::Container::TarXz + ) +} + pub(crate) fn saved_of(r: &Row) -> f64 { if r.size == 0 { 0.0 diff --git a/arca-gui/src/ui/browser.rs b/arca-gui/src/ui/browser.rs index 12c73268..dbd5af2a 100644 --- a/arca-gui/src/ui/browser.rs +++ b/arca-gui/src/ui/browser.rs @@ -399,6 +399,10 @@ impl Shell { let total: f32 = widths.iter().sum(); let order = self.controller.state.active_pane().order; let current_dir = self.controller.row_root().to_string(); + // No entry of a .tar.gz or a .tar.xz is compressed on its own, so it + // has no packed size or saving to show; the status bar has the total. + let whole = self.controller.state.archive.is_some() + && crate::model::whole_stream(self.controller.state.format); egui::ScrollArea::horizontal() .id_salt("details-across") .auto_shrink(false) @@ -594,7 +598,13 @@ impl Shell { } continue; } - let text = column_text(row, *column, s, ¤t_dir); + let text = if whole + && matches!(column, SortColumn::Packed | SortColumn::Saved) + { + String::new() + } else { + column_text(row, *column, s, ¤t_dir) + }; let (anchor, at) = if right_aligned(*column) { ( Align2::RIGHT_CENTER, From b0aab26d33358810c68efd62ff1d96ca84c39fa8 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:19:30 +0100 Subject: [PATCH 03/44] fix: name sizes in KiB, MiB and GiB Every size was divided by 1024 and labelled KB, MB or GB, which read the other way is several percent too large: a 17.4 MiB file showed as "17.4 MB" while file managers that count in powers of 1000 said 18.2. The window, Properties and the CLI now say KiB, MiB and GiB, and the CLI's rate MiB/s. Properties uses the list's formatter instead of a copy of its own. Closes #104 Co-Authored-By: Claude Opus 5.5 --- arca-cli/src/main.rs | 4 ++-- arca-gui/src/main.rs | 10 ++++++++++ arca-gui/src/model.rs | 2 +- arca-gui/src/ui/dialogs.rs | 17 +---------------- 4 files changed, 14 insertions(+), 19 deletions(-) diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index 74414bb9..afdbae69 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -463,7 +463,7 @@ fn create( 0.0 }; println!( - "{}: {} files, {} -> {} ({:.1}% smaller) in {:.3} s · {:.0} MB/s · {} threads", + "{}: {} files, {} -> {} ({:.1}% smaller) in {:.3} s · {:.0} MiB/s · {} threads", out.display(), files.len(), human(total), @@ -1013,7 +1013,7 @@ fn pass_fail(ok: bool) -> &'static str { } fn human(b: u64) -> String { - const U: [&str; 5] = ["B", "KB", "MB", "GB", "TB"]; + const U: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"]; let mut v = b as f64; let mut i = 0; while v >= 1024.0 && i < U.len() - 1 { diff --git a/arca-gui/src/main.rs b/arca-gui/src/main.rs index e67b8136..4b15ed71 100644 --- a/arca-gui/src/main.rs +++ b/arca-gui/src/main.rs @@ -318,6 +318,16 @@ c76ecf12e8e05b8f4730fb9933450ea121fe1ce3699ab9b7d20b058f872815f4 *arca-setup-0.6 assert_eq!(wheel_speed(900.0), wheel_speed(2000.0)); } + // Sizes are counted in powers of 1024, and say so: "17.4 MB" for 17.4 + // MiB is 1.3 MB off by the other reading. + #[test] + fn sizes_are_named_in_binary_units() { + assert_eq!(crate::model::human(1023), "1023 B"); + assert_eq!(crate::model::human(1024), "1.0 KiB"); + assert_eq!(crate::model::human(17_400 * 1024 * 1024 / 1000), "17.4 MiB"); + assert_eq!(crate::model::human(3 << 30), "3.0 GiB"); + } + // The only arithmetic in this file that can be wrong without anyone // noticing: a date is either right or plausible, and plausible is worse. #[test] diff --git a/arca-gui/src/model.rs b/arca-gui/src/model.rs index a3d6a190..9ae209b5 100644 --- a/arca-gui/src/model.rs +++ b/arca-gui/src/model.rs @@ -96,7 +96,7 @@ pub(crate) fn civil(t: i64) -> String { } pub(crate) fn human(n: u64) -> String { - const U: [&str; 5] = ["B", "KB", "MB", "GB", "TB"]; + const U: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"]; let mut v = n as f64; let mut i = 0; while v >= 1024.0 && i < U.len() - 1 { diff --git a/arca-gui/src/ui/dialogs.rs b/arca-gui/src/ui/dialogs.rs index dbe74a36..2db45f1e 100644 --- a/arca-gui/src/ui/dialogs.rs +++ b/arca-gui/src/ui/dialogs.rs @@ -532,7 +532,7 @@ impl Shell { let yes_no = |on: bool| if on { s.yes_word } else { s.no_word }; let mut rows: Vec<(&str, String)> = vec![ (s.location_word, location), - (s.col_size, at_least(pretty_bytes(props.size))), + (s.col_size, at_least(crate::model::human(props.size))), ]; if props.is_dir { rows.push(( @@ -2210,21 +2210,6 @@ fn paint_swatch(ui: &egui::Ui, rect: egui::Rect, palette: theme::Palette) { } } -fn pretty_bytes(n: u64) -> String { - const UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"]; - let mut value = n as f64; - let mut unit = 0; - while value >= 1024.0 && unit < UNITS.len() - 1 { - value /= 1024.0; - unit += 1; - } - if unit == 0 { - format!("{n} B") - } else { - format!("{value:.1} {}", UNITS[unit]) - } -} - /// A file's time as the date and time the clock here showed then. fn stamp(when: std::time::SystemTime) -> String { let secs = when From c514399b92e9a5e599d2bee6806818b87b243327 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:21:03 +0100 Subject: [PATCH 04/44] fix(arca-gui): duplicate with Ctrl+D The disk view's menu showed Ctrl+D next to Duplicate, but nothing listened for the key. It now duplicates the selection on disk, where the menu offers it, and not while typing in a field. The shortcut help and the guide list it. Closes #101 Co-Authored-By: Claude Opus 5.5 --- arca-gui/src/ui/actions.rs | 2 ++ arca-gui/src/ui/dialogs.rs | 1 + arca-gui/src/ui/mod.rs | 6 ++++++ arca-gui/src/ui/tests.rs | 1 + docs/guide/keyboard-shortcuts.md | 1 + 5 files changed, 11 insertions(+) diff --git a/arca-gui/src/ui/actions.rs b/arca-gui/src/ui/actions.rs index aef89298..60af121f 100644 --- a/arca-gui/src/ui/actions.rs +++ b/arca-gui/src/ui/actions.rs @@ -447,6 +447,7 @@ pub(crate) enum Shortcut { Up, CloseWindow, TogglePreview, + Duplicate, } /// Reading a key press, with no state and no side effects, so the table of @@ -481,6 +482,7 @@ pub(crate) fn shortcut_for( "i" => Some(Shortcut::Invert), "w" => Some(Shortcut::CloseWindow), "z" if !typing => Some(Shortcut::Undo), + "d" if !typing => Some(Shortcut::Duplicate), _ => None, }; } diff --git a/arca-gui/src/ui/dialogs.rs b/arca-gui/src/ui/dialogs.rs index 2db45f1e..07c6206d 100644 --- a/arca-gui/src/ui/dialogs.rs +++ b/arca-gui/src/ui/dialogs.rs @@ -45,6 +45,7 @@ pub(crate) fn shortcut_rows(s: &'static Strings) -> [Vec; 2] { (&["f2"], s.rename_word), (&["delete"], s.delete_word), (&["ctrl-shift-n"], s.new_folder), + (&["ctrl-d"], s.duplicate_word), (&["alt-enter"], s.properties_word), (&["alt-p"], s.preview_panel), (&["ctrl-w"], s.close_window), diff --git a/arca-gui/src/ui/mod.rs b/arca-gui/src/ui/mod.rs index ca1d8ff0..649fb77c 100644 --- a/arca-gui/src/ui/mod.rs +++ b/arca-gui/src/ui/mod.rs @@ -1806,6 +1806,12 @@ impl Shell { self.row_action(RowAction::Properties, at.unwrap_or(usize::MAX)); } Shortcut::NewFolder => self.row_action(RowAction::NewFolder, usize::MAX), + // The menu offers it on the disk only, and the key does the same. + Shortcut::Duplicate => { + if self.controller.on_disk() && !self.controller.selected_roots().is_empty() { + self.row_action(RowAction::Duplicate, usize::MAX); + } + } Shortcut::Up => { if self.controller.can_go_up() { self.controller.dispatch(AppAction::Up); diff --git a/arca-gui/src/ui/tests.rs b/arca-gui/src/ui/tests.rs index 76fcc17c..d4aeca9e 100644 --- a/arca-gui/src/ui/tests.rs +++ b/arca-gui/src/ui/tests.rs @@ -403,6 +403,7 @@ fn the_explorer_shortcuts_mean_what_they_mean_there() { let cases = [ (true, true, false, "n", Shortcut::NewFolder), (true, false, false, "w", Shortcut::CloseWindow), + (true, false, false, "d", Shortcut::Duplicate), (false, false, true, "enter", Shortcut::Properties), (false, false, true, "up", Shortcut::Up), (false, false, true, "d", Shortcut::EditPath), diff --git a/docs/guide/keyboard-shortcuts.md b/docs/guide/keyboard-shortcuts.md index 1f6143ae..e862688e 100644 --- a/docs/guide/keyboard-shortcuts.md +++ b/docs/guide/keyboard-shortcuts.md @@ -34,6 +34,7 @@ List commands apply to the active pane. Text fields and dialogs retain their edi | Ctrl+Z | Undo the last supported archive modification | | Alt+W | Extract here | | Ctrl+Shift+N | New folder | +| Ctrl+D | Duplicate the selected files and folders (on disk) | | Alt+Enter | Properties of the cursor row, or of the folder when there is none (on disk) | | Alt+P | Show or hide the preview panel | | Ctrl+W | Close the window | From 7689bf302025a02ec7cebe9808affdf33f825d47 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:21:03 +0100 Subject: [PATCH 05/44] docs: bring the Spanish shortcut guide up to date It had fallen behind the English one: the path bar keys, F2 on disk, new folder, Alt+Enter, Alt+P, Ctrl+W, Shift+F10, the mouse side buttons, the shared clipboard, Esc for a pending cut, and double-click to open. Co-Authored-By: Claude Opus 5.5 --- docs/guide/es/keyboard-shortcuts.md | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/docs/guide/es/keyboard-shortcuts.md b/docs/guide/es/keyboard-shortcuts.md index 22a389f0..7a7330f5 100644 --- a/docs/guide/es/keyboard-shortcuts.md +++ b/docs/guide/es/keyboard-shortcuts.md @@ -13,18 +13,19 @@ Las órdenes de lista actúan sobre el panel activo. Los campos de texto y los d | --- | --- | | Arriba Abajo RePág AvPág Inicio Fin | Mover el cursor | | Derecha | Entrar en la carpeta del cursor | -| Izquierda Retroceso | Subir a la carpeta superior | +| Izquierda Retroceso Alt+Arriba | Subir a la carpeta superior | | Intro | Entrar en una carpeta o abrir explícitamente un archivo con la aplicación del sistema | | Espacio | Alternar la selección de la fila del cursor | | Mayús+Arriba Mayús+Abajo | Ampliar la selección | | Ctrl+A | Seleccionar filas visibles del panel activo | | a…z | Saltar por prefijo del nombre | -| Alt+Izquierda Alt+Derecha | Atrás y adelante en el historial | +| Alt+Izquierda Alt+Derecha | Atrás y adelante en el historial; los botones laterales del ratón hacen lo mismo | | Ctrl+O Ctrl+N Ctrl+E | Abrir archivo, crear archivo, extraer todo | -| Ctrl+C Ctrl+X Ctrl+V | Copiar, cortar y pegar archivos (integración con Windows) | +| Ctrl+C Ctrl+X Ctrl+V | Copiar, cortar y pegar archivos, compartidos con el gestor de archivos del sistema en Windows y Linux | | Ctrl+Mayús+C | Copiar los nombres seleccionados como texto | | Ctrl+F | Mostrar y enfocar el filtro del panel activo | -| F2 | Renombrar la entrada seleccionada en un ZIP modificable | +| Ctrl+L Alt+D F4 | Escribir una ruta en la barra de ruta | +| F2 | Renombrar el archivo o la carpeta seleccionados, en el disco o en un ZIP modificable | | F3 | Activar la vista previa integrada del archivo del cursor | | Ctrl+T | Comprobar el archivo | | Ctrl+I | Invertir la selección visible del panel activo | @@ -32,12 +33,18 @@ Las órdenes de lista actúan sobre el panel activo. Los campos de texto y los d | Supr | Confirmar la eliminación de entradas seleccionadas de un ZIP modificable | | Ctrl+Z | Deshacer la última modificación compatible | | Alt+W | Extraer aquí | +| Ctrl+Mayús+N | Carpeta nueva | +| Ctrl+D | Duplicar los archivos y carpetas seleccionados (en el disco) | +| Alt+Intro | Propiedades de la fila del cursor, o de la carpeta si no hay ninguna (en el disco) | +| Alt+P | Mostrar u ocultar el panel de vista previa | +| Ctrl+W | Cerrar la ventana | | + - | Seleccionar o deseleccionar por máscara de nombre | | Tab Mayús+Tab | Mover el foco entre controles y paneles | +| Mayús+F10 | Abrir el menú de la fila del cursor, o el de la carpeta si no hay ninguna | | F1 | Ayuda de atajos | -| Esc | Cerrar el diálogo o la edición en línea; en otro caso, quitar la selección | +| Esc | Cerrar el diálogo o la edición en línea; si no, deshacer un corte pendiente y después quitar la selección | -Ctrl+clic alterna una fila; Mayús+clic selecciona un intervalo. Un clic en una carpeta abre su hijo en Columnas; Detalles usa doble clic. Haz clic derecho en una fila o espacio vacío del panel para abrir su menú. Arrastra los divisores para ajustar el ancho y desplázate horizontalmente para llegar a los antecesores. +Ctrl+clic alterna una fila; Mayús+clic selecciona un intervalo. Un clic selecciona una fila y un doble clic o Intro la abre; con **Abrir las carpetas en el panel de al lado** activado, un clic en una carpeta la muestra en el panel de al lado. Haz clic derecho en una fila o espacio vacío del panel para abrir su menú. Arrastra los divisores para ajustar el ancho y desplázate horizontalmente para llegar a los antecesores. El botón de cierre de vista previa devuelve el foco. En ventanas estrechas puede quedar suspendida temporalmente hasta que haya sitio. El botón lateral alterna entre panel ampliado, iconos y oculto. From d81628824ec2a9dba5becb60847ff17c1f550981 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:22:22 +0100 Subject: [PATCH 06/44] feat(arca-gui): show that an archive is being opened MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit While a large archive was read, the list said "This folder is empty", and only the status bar said otherwise. The list now shows the Arca mark fading in and out above "Opening…" and the archive's name, in the details view and in the active pane, and screen readers are told it is opening rather than empty. It gives way to the entries, to the password prompt or to the error as soon as the listing ends. Closes #105 Co-Authored-By: Claude Opus 5.5 --- arca-gui/src/ui/actions.rs | 7 ++++++- arca-gui/src/ui/browser.rs | 42 +++++++++++++++++++++++++++++++++++++- arca-gui/src/ui/tests.rs | 13 ++++++++---- 3 files changed, 56 insertions(+), 6 deletions(-) diff --git a/arca-gui/src/ui/actions.rs b/arca-gui/src/ui/actions.rs index 60af121f..cedebc32 100644 --- a/arca-gui/src/ui/actions.rs +++ b/arca-gui/src/ui/actions.rs @@ -535,12 +535,17 @@ pub(crate) fn clipboard_action_allowed( available && idle && has_archive && (!needs_selection || selected > 0) } +/// What an empty list says. An archive still being read has no rows yet, and +/// saying the folder is empty then is saying something false. pub(crate) fn empty_state_aria_label( + listing: bool, error: bool, filter: &str, s: &'static Strings, ) -> &'static str { - if error { + if listing { + s.opening + } else if error { s.cannot_open } else if filter.trim().is_empty() { s.empty_folder diff --git a/arca-gui/src/ui/browser.rs b/arca-gui/src/ui/browser.rs index dbd5af2a..9abd3d23 100644 --- a/arca-gui/src/ui/browser.rs +++ b/arca-gui/src/ui/browser.rs @@ -338,17 +338,51 @@ impl Shell { }); } + /// What the list shows while an archive is being read: the mark breathing + /// in and out over the name of what is being opened, so a large archive + /// does not look like an empty one. + fn opening_state(&self, ui: &mut egui::Ui) { + let s = self.controller.s(); + let p = palette_of(ui.ctx()); + let time = ui.input(|i| i.time); + let alpha = 0.55 + 0.45 * (time * std::f64::consts::TAU / 1.6).cos() as f32; + ui.vertical_centered(|ui| { + ui.add_space((ui.available_height() / 2.0 - 90.0).max(24.0)); + ui.add( + egui::Image::from_bytes("bytes://arca-mark.svg", crate::assets::MARK) + .fit_to_exact_size(Vec2::splat(96.0)) + .tint(egui::Color32::WHITE.gamma_multiply(alpha)), + ); + ui.add_space(12.0); + ui.label(RichText::new(format!("{}\u{2026}", s.opening)).font(theme::display(20.0))); + let name = self + .controller + .state + .archive + .as_ref() + .and_then(|a| a.file_name()) + .map(|n| n.to_string_lossy().into_owned()) + .unwrap_or_default(); + ui.add(egui::Label::new(RichText::new(name).color(hex(p.muted))).truncate()); + }); + ui.ctx().request_repaint(); + } + fn empty_state(&self, ui: &mut egui::Ui) { let s = self.controller.s(); let p = palette_of(ui.ctx()); let state = &self.controller.state; + if state.listing { + self.opening_state(ui); + return; + } let text = if state.archive.is_some() && state.entries.is_empty() && state.active_pane().filter.trim().is_empty() { s.empty_archive } else { - empty_state_aria_label(state.error, &state.active_pane().filter, s) + empty_state_aria_label(false, state.error, &state.active_pane().filter, s) }; ui.add_space(40.0); ui.vertical_centered(|ui| { @@ -856,6 +890,12 @@ impl Shell { } } let rows = self.controller.pane_rows(pane); + if rows.is_empty() && self.controller.state.listing { + if pane == self.controller.state.browser.active { + self.opening_state(ui); + } + return; + } if rows.is_empty() { ui.label(RichText::new(s.empty_folder).color(hex(p.muted))); self.empty_space(ui, Some(pane)); diff --git a/arca-gui/src/ui/tests.rs b/arca-gui/src/ui/tests.rs index d4aeca9e..1763fd65 100644 --- a/arca-gui/src/ui/tests.rs +++ b/arca-gui/src/ui/tests.rs @@ -488,10 +488,15 @@ fn empty_folder_label_is_not_reported_as_archive_contents() { // translation that loses the difference is the same bug in Spanish. for lang in super::super::Lang::ALL { let s = crate::i18n::strings(lang); - assert_eq!(empty_state_aria_label(false, "", s), s.empty_folder); - assert_eq!(empty_state_aria_label(false, " ", s), s.empty_folder); - assert_eq!(empty_state_aria_label(false, "zip", s), s.no_matches); - assert_eq!(empty_state_aria_label(true, "", s), s.cannot_open); + assert_eq!(empty_state_aria_label(false, false, "", s), s.empty_folder); + assert_eq!( + empty_state_aria_label(false, false, " ", s), + s.empty_folder + ); + assert_eq!(empty_state_aria_label(false, false, "zip", s), s.no_matches); + assert_eq!(empty_state_aria_label(false, true, "", s), s.cannot_open); + assert_eq!(empty_state_aria_label(true, false, "", s), s.opening); + assert_ne!(s.opening, s.empty_folder); assert_ne!(s.empty_folder, s.cannot_open); } } From a7187286fbc519b87bcfda65410da4e77076ff15 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:36:26 +0100 Subject: [PATCH 07/44] fix(arca-cli): write one of two same-named ZIP entries, not both at once With --on-conflict overwrite, two entries of one name both went to the thread pool, and two threads could write the same file at the same time and leave a mix of the two. The later entry, which is what extracting in order leaves, is now the only one written. The test accepted either entry and failed about one run in ten; it now expects the later one. Co-Authored-By: Claude Opus 5.5 --- arca-cli/src/main.rs | 13 +++++++++++++ arca-cli/tests/zip_extract.rs | 2 +- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index afdbae69..78e921cb 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -730,6 +730,19 @@ fn extract( }; jobs.push((e.clone(), path)); } + // Two entries with one name, overwriting: the later one is what + // extracting in order would leave, and writing both from two + // threads at once would leave a mix of the two. + if matches!(policy, OnConflict::Overwrite) { + let mut seen: HashSet = HashSet::new(); + let mut kept: Vec<(arca_core::Entry, PathBuf)> = jobs + .into_iter() + .rev() + .filter(|(_, path)| seen.insert(path.clone())) + .collect(); + kept.reverse(); + jobs = kept; + } drop(a); let pool = rayon::ThreadPoolBuilder::new() diff --git a/arca-cli/tests/zip_extract.rs b/arca-cli/tests/zip_extract.rs index 2ff616c2..2f2c7bb0 100644 --- a/arca-cli/tests/zip_extract.rs +++ b/arca-cli/tests/zip_extract.rs @@ -210,7 +210,7 @@ fn mixed_sizes_and_duplicate_names_share_one_reader_per_chunk() { assert_eq!(fs::read(output.path().join(name)).unwrap(), *body); } let dup = fs::read(output.path().join("dup.txt")).unwrap(); - assert!(dup == b"first" || dup == b"second"); + assert_eq!(dup, b"second"); let output = tempfile::tempdir().unwrap(); success(extract( &archive, From 2c933ca289646a2e6d574baa84f86842d998b157 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:43:54 +0100 Subject: [PATCH 08/44] perf(arca-gui): redraw the opening indicator at 30 frames a second It asked for a new frame as soon as one was drawn, which kept the window redrawing as fast as it could for the whole listing; a fade over 1.6 seconds needs far fewer. Co-Authored-By: Claude Opus 5.5 --- arca-gui/src/ui/browser.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/arca-gui/src/ui/browser.rs b/arca-gui/src/ui/browser.rs index 9abd3d23..e219f278 100644 --- a/arca-gui/src/ui/browser.rs +++ b/arca-gui/src/ui/browser.rs @@ -365,7 +365,8 @@ impl Shell { .unwrap_or_default(); ui.add(egui::Label::new(RichText::new(name).color(hex(p.muted))).truncate()); }); - ui.ctx().request_repaint(); + ui.ctx() + .request_repaint_after(std::time::Duration::from_millis(33)); } fn empty_state(&self, ui: &mut egui::Ui) { From 158aa361bc8d961045e2f130acc82bfcba9feb71 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 01:54:55 +0100 Subject: [PATCH 09/44] fix: keep the execute bit of programs extracted from a tar Every file came out of a tarball without execute permission, so on Linux and macOS an application shipped as a .tar.gz, such as the one in #102, extracted correctly but would not start. The reader now keeps each entry's Unix mode, and extraction in the window and the CLI adds its execute bits to the file. Nothing is ever taken away, and setuid and the other special bits are never applied. Windows has no such bits and is unchanged. interop.sh checks a program and a plain file from a GNU tar.gz. Co-Authored-By: Claude Opus 5.5 --- arca-cli/src/main.rs | 3 +- arca-core/src/extraction.rs | 72 +++++++++++++++++++++++++++++++++- arca-gui/src/archive_ops/io.rs | 22 +++++++---- arca-tar/src/lib.rs | 21 ++++++++++ interop.sh | 7 ++++ 5 files changed, 114 insertions(+), 11 deletions(-) diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index 78e921cb..6a016571 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -807,10 +807,11 @@ fn extract( let mut destination = Destination::new(dest); while let Some(e) = r.next_entry()? { let written = r.with_data(&e, |data| { - destination.write_entry( + destination.write_file( &e.entry.name, e.entry.is_dir, e.entry.mtime, + Some(e.mode), data, &mut |_| conflict(policy), ) diff --git a/arca-core/src/extraction.rs b/arca-core/src/extraction.rs index 9f645b91..cd20dced 100644 --- a/arca-core/src/extraction.rs +++ b/arca-core/src/extraction.rs @@ -65,6 +65,20 @@ impl Destination { mtime: Option, reader: &mut dyn Read, ask: &mut dyn FnMut(&Path) -> Conflict, + ) -> Result> { + self.write_file(name, is_dir, mtime, None, reader, ask) + } + + /// `write_entry` for a format that records Unix permissions: the file + /// also gets the execute bits `mode` has, see [`set_executable`]. + pub fn write_file( + &mut self, + name: &str, + is_dir: bool, + mtime: Option, + mode: Option, + reader: &mut dyn Read, + ask: &mut dyn FnMut(&Path) -> Conflict, ) -> Result> { let relative = safe_name(name)?; let directory = if is_dir { @@ -103,8 +117,9 @@ impl Destination { let mut writer = BufWriter::with_capacity(256 * 1024, file); let bytes = io::copy(reader, &mut writer)?; writer.flush()?; - let file = writer.into_inner().map_err(|e| e.into_error())?; - set_mtime(&file.into_std(), mtime); + let file = writer.into_inner().map_err(|e| e.into_error())?.into_std(); + set_mtime(&file, mtime); + set_executable(&file, mode); exists_without_link(parent, Path::new(&name))?; // Rename replaces the directory entry without following it, even if it changed. parent.rename(&staged.name, parent, &name)?; @@ -126,6 +141,28 @@ pub fn set_mtime(file: &std::fs::File, mtime: Option) { } } +/// Lets an extracted program run where the archive says it could: the execute +/// bits of `mode`, the Unix permissions the archive recorded, are added to +/// the file's. Nothing is ever taken away and nothing else is added, so the +/// most an archive can do is mark one of its own files executable. A no-op +/// where there are no such bits, and best effort like `set_mtime`. +pub fn set_executable(file: &std::fs::File, mode: Option) { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let Some(execute) = mode.map(|m| m & 0o111).filter(|m| *m != 0) else { + return; + }; + if let Ok(meta) = file.metadata() { + let mut permissions = meta.permissions(); + permissions.set_mode(permissions.mode() | execute); + let _ = file.set_permissions(permissions); + } + } + #[cfg(not(unix))] + let _ = (file, mode); +} + fn open_child(parent: &Dir, name: &Path) -> Result { let dir = match parent.open_dir_nofollow(name) { Ok(dir) => dir, @@ -333,6 +370,37 @@ mod tests { assert!(modified("undated") > when as u64); } + // A program in a tarball has to come out runnable, and a plain file must + // not come out runnable just for having passed through an archive. + #[cfg(unix)] + #[test] + fn programs_keep_their_execute_bits_and_nothing_more() { + use std::os::unix::fs::PermissionsExt; + let room = room(); + let mut dest = Destination::new(room.path()); + for (name, mode) in [ + ("program", Some(0o755)), + ("plain", Some(0o644)), + ("setuid", Some(0o4755)), + ("unknown", None), + ] { + dest.write_file(name, false, None, mode, &mut &b"x"[..], &mut |_| { + Conflict::Overwrite + }) + .unwrap(); + } + let mode = |name: &str| { + fs::metadata(room.path().join(name)) + .unwrap() + .permissions() + .mode() + }; + assert_eq!(mode("program") & 0o111, 0o111); + assert_eq!(mode("plain") & 0o111, 0); + assert_eq!(mode("unknown") & 0o111, 0); + assert_eq!(mode("setuid") & 0o7000, 0); + } + #[test] fn pinned_root_cannot_be_redirected_before_directory_creation() { let room = room(); diff --git a/arca-gui/src/archive_ops/io.rs b/arca-gui/src/archive_ops/io.rs index ef0e6f3e..ac7afc75 100644 --- a/arca-gui/src/archive_ops/io.rs +++ b/arca-gui/src/archive_ops/io.rs @@ -50,10 +50,11 @@ impl Write for Watched<'_, W> { // Writes one entry to `path` while keeping `notify` in the loop, so a pause // holds and a stop lands inside the file rather than after it. A stop, like -// any other failure, takes the half-written file away with it. +// any other failure, takes the half-written file away with it. `stamp` is the +// time and, where the format keeps them, the Unix permissions to give it. fn unpack( path: &Path, - mtime: Option, + (mtime, mode): (Option, Option), notify: &(dyn Fn(usize, usize, &str) -> bool + Sync), progress: (usize, usize, &str), fill: impl FnOnce(&mut dyn Write) -> arca_core::Result, @@ -77,6 +78,7 @@ fn unpack( result.and_then(|n| { inner.flush()?; arca_core::extraction::set_mtime(inner.get_ref(), mtime); + arca_core::extraction::set_executable(inner.get_ref(), mode); Ok(n) }) }; @@ -448,9 +450,13 @@ pub(crate) fn extract_one_into( fs::create_dir_all(parent)?; } let mut source = BufReader::with_capacity(BUF, File::open(archive)?); - unpack(&path, entry.mtime, notify, (0, 1, &entry.name), |out| { - arca_zip::extract_entry_with(&mut source, entry, out, password) - })?; + unpack( + &path, + (entry.mtime, None), + notify, + (0, 1, &entry.name), + |out| arca_zip::extract_entry_with(&mut source, entry, out, password), + )?; Ok(path) } Container::Tar | Container::TarGz | Container::TarXz => { @@ -465,7 +471,7 @@ pub(crate) fn extract_one_into( if e.entry.name == entry.name && !e.entry.is_dir { unpack( &path, - entry.mtime, + (entry.mtime, Some(e.mode)), notify, (0, 1, &entry.name), |mut out| r.copy_data(&e, &mut out), @@ -771,7 +777,7 @@ pub(crate) fn extract( .map(|(e, path)| { let mut source = BufReader::with_capacity(BUF, File::open(archive)?); let at = (done.load(Ordering::Relaxed), total, e.name.as_str()); - let w = unpack(path, e.mtime, notify, at, |out| { + let w = unpack(path, (e.mtime, None), notify, at, |out| { arca_zip::extract_entry_with(&mut source, e, out, password) })?; if !notify(done.fetch_add(1, Ordering::Relaxed) + 1, total, &e.name) { @@ -812,7 +818,7 @@ pub(crate) fn extract( match dest_path(dest, &e.entry.name, e.entry.is_dir, ask, &mut claimed)? { Some(path) => { let at = (i, total, e.entry.name.as_str()); - bytes += unpack(&path, e.entry.mtime, notify, at, |out| { + bytes += unpack(&path, (e.entry.mtime, Some(e.mode)), notify, at, |out| { r.with_data(&e, |data| Ok(std::io::copy(data, out)?)) })?; } diff --git a/arca-tar/src/lib.rs b/arca-tar/src/lib.rs index e82c5300..ff182331 100644 --- a/arca-tar/src/lib.rs +++ b/arca-tar/src/lib.rs @@ -169,6 +169,9 @@ pub fn is_header(block: &[u8]) -> bool { pub struct TarEntry { pub entry: Entry, pub data: u64, + /// The Unix permission bits, `0o755` for a program. Zero when the field + /// cannot be read, which only ever costs the execute bit. + pub mode: u32, } pub struct TarReader { @@ -321,6 +324,7 @@ impl TarReader { Ok(Some(TarEntry { entry, data: if is_dir { 0 } else { size }, + mode: octal(&header[100..108], "mode").map_or(0, |m| (m & 0o7777) as u32), })) } @@ -664,6 +668,23 @@ mod tests { vec![0u8; BLOCK * 2] } + #[test] + fn the_permissions_of_an_entry_are_read_and_a_bad_field_costs_only_them() { + let with_mode = |field: &[u8]| { + let mut h = header("tool", b'0', 0); + h[100..108].copy_from_slice(field); + h[148..156].copy_from_slice(b" "); + let sum = checksum(<&[u8; BLOCK]>::try_from(&h[..]).unwrap()); + write_octal(&mut h[148..155], u64::from(sum)); + h.extend(end()); + let mut r = TarReader::new(&h[..]); + r.next_entry().unwrap().unwrap().mode + }; + assert_eq!(with_mode(b"0000755\0"), 0o755); + assert_eq!(with_mode(b"0104755\0"), 0o4755); + assert_eq!(with_mode(b"07x5\0\0\0\0"), 0); + } + #[test] fn a_gnu_long_name_names_the_entry_after_it() { let long = format!("{}/{}.txt", "d".repeat(120), "f".repeat(40)); diff --git a/interop.sh b/interop.sh index 6b5c1915..af874c7a 100644 --- a/interop.sh +++ b/interop.sh @@ -84,6 +84,13 @@ for f in long-gnu long-pax long-split; do [ "$H" = "$LREF" ] && ok "Arca extracts $f.tar.gz with its long names" || ko "Arca mis-extracts $f.tar.gz" done rm -rf long +# A program in a tarball comes out runnable, and a plain file does not. +mkdir -p perm && printf '#!/bin/sh\necho ok\n' > perm/run.sh && echo data > perm/plain.txt +chmod 755 perm/run.sh && chmod 644 perm/plain.txt +tar czf out/perm.tar.gz perm && rm -rf perm y && mkdir y +$ARCA extract out/perm.tar.gz -o y >/dev/null 2>&1 +[ -x y/perm/run.sh ] && [ ! -x y/perm/plain.txt ] && [ "$(y/perm/run.sh)" = ok ] && + ok "Arca keeps the execute bit of a tar's program" || ko "Arca loses or invents execute bits" 7z a -tzip -mx5 out/s7.zip src >/dev/null 2>&1 rm -rf y; mkdir y; $ARCA extract out/s7.zip -o y >/dev/null 2>&1 H=$(cd y/src && find . -type f|sort|xargs sha256sum|sha256sum|cut -d' ' -f1) From e468ed601dc2247de1fb68d8ea13e22d747a0c30 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 13:54:11 +0100 Subject: [PATCH 10/44] fix: record real dates and permissions when making a tar The window wrote every .tar and .tar.gz entry dated 1970, and both the window and the CLI recorded every file as 0644, so a program packed on Linux or macOS came out of the tarball unable to run. Entries now carry the file's own date everywhere and, on Unix, its own permissions; other systems keep 0644. Co-Authored-By: Claude Opus 5.5 --- arca-cli/src/main.rs | 12 ++++++---- arca-gui/src/archive_ops/io.rs | 16 +++++++++++-- arca-gui/src/controller/jobs_tests.rs | 34 +++++++++++++++++++++++++++ arca-tar/src/lib.rs | 15 ++++++++++++ interop.sh | 6 +++++ 5 files changed, 77 insertions(+), 6 deletions(-) diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index 6a016571..30482ac0 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -417,8 +417,10 @@ fn create( }; let mut w = TarWriter::new(dest); for s in &files { - let entrada = BufReader::with_capacity(BUF, File::open(&s.path)?); - w.add(&s.name, s.size, s.mtime, 0o644, entrada)?; + let file = File::open(&s.path)?; + let mode = arca_tar::mode_of(&file.metadata()?); + let entrada = BufReader::with_capacity(BUF, file); + w.add(&s.name, s.size, s.mtime, mode, entrada)?; } let mut d = w.finish()?; d.flush()?; @@ -429,8 +431,10 @@ fn create( let used = e.workers(); let mut w = TarWriter::new(e); for s in &files { - let entrada = BufReader::with_capacity(BUF, File::open(&s.path)?); - w.add(&s.name, s.size, s.mtime, 0o644, entrada)?; + let file = File::open(&s.path)?; + let mode = arca_tar::mode_of(&file.metadata()?); + let entrada = BufReader::with_capacity(BUF, file); + w.add(&s.name, s.size, s.mtime, mode, entrada)?; } w.finish()?.finish()?.flush()?; Ok(used) diff --git a/arca-gui/src/archive_ops/io.rs b/arca-gui/src/archive_ops/io.rs index ac7afc75..c6d12be1 100644 --- a/arca-gui/src/archive_ops/io.rs +++ b/arca-gui/src/archive_ops/io.rs @@ -1256,7 +1256,13 @@ pub(crate) fn compress( } let meta = fs::metadata(path)?; let f = BufReader::with_capacity(BUF, File::open(path)?); - w.add(name, meta.len(), 0, 0o644, f)?; + w.add( + name, + meta.len(), + mtime_of(&meta), + arca_tar::mode_of(&meta), + f, + )?; source_bytes += meta.len(); } w.finish()?; @@ -1273,7 +1279,13 @@ pub(crate) fn compress( name, notify, ); - let result = w.add(name, meta.len(), mtime_of(&meta), 0o644, &mut f); + let result = w.add( + name, + meta.len(), + mtime_of(&meta), + arca_tar::mode_of(&meta), + &mut f, + ); f.check(result)?; source_bytes += meta.len(); } diff --git a/arca-gui/src/controller/jobs_tests.rs b/arca-gui/src/controller/jobs_tests.rs index b7f46247..5f36fd00 100644 --- a/arca-gui/src/controller/jobs_tests.rs +++ b/arca-gui/src/controller/jobs_tests.rs @@ -555,6 +555,40 @@ fn leaving_for_the_disk_forgets_a_cut_out_of_the_archive() { assert!(app.state.cut_names.is_empty()); } +// The window wrote every .tar and .tar.gz entry dated 1970. +#[test] +fn a_tar_made_in_the_window_keeps_the_dates_of_its_files() { + let room = Room::new(); + let source = room.path("dated"); + std::fs::create_dir_all(&source).unwrap(); + let file = source.join("a.txt"); + std::fs::write(&file, b"a").unwrap(); + let when = std::time::UNIX_EPOCH + std::time::Duration::from_secs(1_600_000_000); + std::fs::File::options() + .write(true) + .open(&file) + .unwrap() + .set_modified(when) + .unwrap(); + for format in [Format::Tar, Format::TarGz, Format::TarXz] { + let archive = room.path(&format!("dated.{}", format.extension())); + crate::archive_ops::compress( + &archive, + std::slice::from_ref(&source), + format, + arca_core::Codec::Deflate, + arca_core::Level::NORMAL, + &|_, _, _| true, + (None, false), + ) + .unwrap(); + let (entries, _) = + crate::archive_ops::list_entries(&archive, None, &|_, _, _| true).unwrap(); + let entry = entries.iter().find(|e| e.name.ends_with("a.txt")).unwrap(); + assert_eq!(entry.mtime, Some(1_600_000_000), "{format:?}"); + } +} + // A tar.xz compresses the whole stream, so the saving is the file against // what it holds; summing the entries said 0% for every one of them. #[test] diff --git a/arca-tar/src/lib.rs b/arca-tar/src/lib.rs index ff182331..b7c1c64a 100644 --- a/arca-tar/src/lib.rs +++ b/arca-tar/src/lib.rs @@ -154,6 +154,21 @@ fn text_field(field: &[u8]) -> String { String::from_utf8_lossy(&field[..end]).into_owned() } +/// The permissions to record for a file going into a tar: its own on Unix, so +/// a program stays runnable once extracted, and an ordinary file's elsewhere. +pub fn mode_of(meta: &std::fs::Metadata) -> u32 { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + meta.permissions().mode() & 0o777 + } + #[cfg(not(unix))] + { + let _ = meta; + 0o644 + } +} + /// Whether a 512-byte block is a TAR header with a valid checksum. pub fn is_header(block: &[u8]) -> bool { let Ok(header) = <&[u8; BLOCK]>::try_from(block) else { diff --git a/interop.sh b/interop.sh index af874c7a..a3ea222d 100644 --- a/interop.sh +++ b/interop.sh @@ -91,6 +91,12 @@ tar czf out/perm.tar.gz perm && rm -rf perm y && mkdir y $ARCA extract out/perm.tar.gz -o y >/dev/null 2>&1 [ -x y/perm/run.sh ] && [ ! -x y/perm/plain.txt ] && [ "$(y/perm/run.sh)" = ok ] && ok "Arca keeps the execute bit of a tar's program" || ko "Arca loses or invents execute bits" +# And the other way: a tarball Arca makes keeps it for tar to restore. +rm -rf z && mkdir z && mv y/perm . && $ARCA create out/arca-perm.tar.gz perm >/dev/null 2>&1 +tar xzf out/arca-perm.tar.gz -C z 2>/dev/null +[ -x z/perm/run.sh ] && [ ! -x z/perm/plain.txt ] && + ok "Arca's .tar.gz keeps the execute bit for tar" || ko "Arca's .tar.gz loses execute bits" +rm -rf perm z 7z a -tzip -mx5 out/s7.zip src >/dev/null 2>&1 rm -rf y; mkdir y; $ARCA extract out/s7.zip -o y >/dev/null 2>&1 H=$(cd y/src && find . -type f|sort|xargs sha256sum|sha256sum|cut -d' ' -f1) From f62e151cdcda9bf784c0d9659c827fbce4d0c10e Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 14:26:25 +0100 Subject: [PATCH 11/44] perf(arca-7z): compress in solid blocks on every core, with BCJ for programs 7z creation put every file in a block of its own and ran LZMA2 on one thread, and extraction decoded on one thread too. Files now go into solid blocks of up to 256 MiB, sorted by extension as 7-Zip does, with x86 executables in blocks of their own behind the BCJ filter. LZMA2 runs multithreaded within the 2 GiB budget the .xz encoder already keeps to, and files are opened only when their block reaches them. Decoding uses every core where the stream was written in chunks; the vendored decoder now caps its threads so that one dictionary each stays within four times the single-thread limit, since the archive names the dictionary size. Measured with `arca create out.7z -l ` and `arca extract` on 144 MiB of this repository's source, four vendored crates' sources and three release executables (1,382 files), Windows 11, 16 threads: fast 9.8 s -> 1.5 s (15.1% -> 14.3% of the input), normal 50.1 s -> 17.9 s (13.5% -> 11.6%), best 57.1 s -> 43.1 s (13.5% -> 9.9%), extraction 6.4 s -> 3.0 s. WinRAR extracts the result byte for byte, executables and AES included, and interop.sh now has 7-Zip check an executable and a filtered library. Entries are listed in the grouped order, like 7-Zip's. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 1 + arca-7z/Cargo.toml | 1 + arca-7z/src/lib.rs | 2 +- arca-7z/src/read.rs | 20 +- arca-7z/src/write.rs | 240 ++++++++++++++++----- arca-7z/tests/archive.rs | 143 +++++++++++- arca-7z/vendor/PATCHES.md | 3 + arca-7z/vendor/sevenz-rust2/src/decoder.rs | 4 + arca-cli/src/main.rs | 2 +- arca-cli/src/sevenz.rs | 9 +- arca-cli/tests/rar.rs | 5 +- arca-cli/tests/sevenz.rs | 4 +- arca-xz/src/lib.rs | 4 +- docs/guide/cli-reference.md | 2 +- docs/guide/creating-archives.md | 9 +- docs/guide/desktop-app.md | 4 +- docs/guide/es/cli-reference.md | 2 +- docs/guide/es/creating-archives.md | 9 +- docs/guide/es/desktop-app.md | 4 +- docs/guide/es/listing-extracting.md | 2 +- docs/guide/listing-extracting.md | 2 +- interop.sh | 12 +- 22 files changed, 393 insertions(+), 91 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1dd9fb7a..96ccd435 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -261,6 +261,7 @@ name = "arca-7z" version = "0.10.0" dependencies = [ "arca-core", + "arca-xz", "crc32fast", "getrandom 0.4.3", "sevenz-rust2", diff --git a/arca-7z/Cargo.toml b/arca-7z/Cargo.toml index a679bb07..65a26779 100644 --- a/arca-7z/Cargo.toml +++ b/arca-7z/Cargo.toml @@ -9,6 +9,7 @@ description = "Bounded, safe Rust 7z reading and writing for Arca" [dependencies] arca-core.workspace = true +arca-xz.workspace = true sevenz-rust2 = { version = "=0.23.0", default-features = false, features = ["aes256", "compress", "deflate"] } crc32fast.workspace = true tempfile = "3" diff --git a/arca-7z/src/lib.rs b/arca-7z/src/lib.rs index 00e92eb9..508f2352 100644 --- a/arca-7z/src/lib.rs +++ b/arca-7z/src/lib.rs @@ -4,7 +4,7 @@ mod read; mod write; pub use read::{Phase, Progress, SevenZArchive}; -pub use write::{create_7z, CreateOptions, Source}; +pub use write::{create_7z, workers, CreateOptions, Source}; use arca_core::{Error, Result}; diff --git a/arca-7z/src/read.rs b/arca-7z/src/read.rs index 8dd71f32..e219118b 100644 --- a/arca-7z/src/read.rs +++ b/arca-7z/src/read.rs @@ -300,6 +300,7 @@ impl SevenZArchive { } Ok(()) }; + let threads = std::thread::available_parallelism().map_or(1, |n| n.get() as u32); for (block, &needed) in blocks.iter().enumerate() { if !needed { continue; @@ -316,15 +317,16 @@ impl SevenZArchive { } else { &no_password }; - let result = BlockDecoder::new(1, block, &self.archive, password, &mut self.source) - .for_each_entries(&mut |_, reader| { - if let Err(error) = visit(index, reader) { - callback_error = Some(error); - return Ok(false); - } - index += 1; - Ok(true) - }); + let result = + BlockDecoder::new(threads, block, &self.archive, password, &mut self.source) + .for_each_entries(&mut |_, reader| { + if let Err(error) = visit(index, reader) { + callback_error = Some(error); + return Ok(false); + } + index += 1; + Ok(true) + }); if let Some(error) = callback_error { return Err(error); } diff --git a/arca-7z/src/write.rs b/arca-7z/src/write.rs index 6000c613..dfdbcdc2 100644 --- a/arca-7z/src/write.rs +++ b/arca-7z/src/write.rs @@ -7,7 +7,7 @@ use std::{ use arca_core::{Error, Level, Result}; use sevenz_rust2::{ encoder_options::{AesEncoderOptions, Lzma2Options}, - ArchiveEntry, ArchiveWriter, EncoderConfiguration, EncoderMethod, Password, + ArchiveEntry, ArchiveWriter, EncoderConfiguration, EncoderMethod, Password, SourceReader, }; use crate::{entry_path, upstream, Phase, Progress}; @@ -98,9 +98,8 @@ pub fn create_7z( let mut writer = ArchiveWriter::new(io::BufWriter::new(temporary.as_file_mut())) .map_err(|e| upstream(e, false))?; writer.set_encrypt_header(options.hide_names); - let mut bytes = 0; - for (index, (source, meta)) in sources.iter().zip(&metadata).enumerate() { - writer.set_content_methods(methods(options)?); + let entry_of = |index: usize| { + let (source, meta) = (&sources[index], &metadata[index]); let mut entry = if meta.is_dir() { ArchiveEntry::new_directory(&source.name) } else { @@ -113,45 +112,69 @@ pub fn create_7z( entry.has_last_modified_date = true; entry.last_modified_date = time; } - let progress = Progress { + entry + }; + // Folders and empty files have no data and go in first, outside any block. + let (empty, full): (Vec, Vec) = + (0..sources.len()).partition(|&i| metadata[i].is_dir() || metadata[i].len() == 0); + for &index in &empty { + if !notify(Progress { phase: Phase::Create, entries_done: index, entries_total: sources.len(), - bytes_done: bytes, - name: &source.name, - }; - if !notify(progress) { + bytes_done: 0, + name: &sources[index].name, + }) { return Err(Error::Cancelled); } - if meta.is_dir() || meta.len() == 0 { - entry.has_stream = false; - writer - .push_archive_entry::(entry, None) - .map_err(|e| upstream(e, false))?; - } else { - let file = fs::File::open(&source.path)?; - let mut input = Input { - file, - notify, - progress, - cancelled: false, - bytes: 0, - }; - let result = writer.push_archive_entry(entry, Some(&mut input)); - if input.cancelled { - return Err(Error::Cancelled); - } - result.map_err(|e| upstream(e, false))?; - if input.bytes != meta.len() { - return Err(Error::Io(io::Error::other( - "7z source changed size during creation", - ))); - } - bytes += input.bytes; + let mut entry = entry_of(index); + entry.has_stream = false; + writer + .push_archive_entry::(entry, None) + .map_err(|e| upstream(e, false))?; + } + let tracker = std::cell::RefCell::new(Tracker { + notify, + total: sources.len(), + done: empty.len(), + bytes: 0, + cancelled: false, + changed: false, + }); + let workers = workers(options.level); + for block in solid_blocks(sources, &metadata, &full) { + writer.set_content_methods(methods(options, block.executables, workers)?); + let entries = block.files.iter().map(|&i| entry_of(i)).collect(); + let readers = block + .files + .iter() + .map(|&i| { + SourceReader::new(Lazy { + path: &sources[i].path, + name: &sources[i].name, + expected: metadata[i].len(), + file: None, + read: 0, + tracker: &tracker, + }) + }) + .collect(); + let result = writer.push_archive_entries(entries, readers); + let state = tracker.borrow(); + if state.cancelled { + return Err(Error::Cancelled); } + if state.changed { + return Err(Error::Io(io::Error::other( + "7z source changed size during creation", + ))); + } + drop(state); + result.map_err(|e| upstream(e, false))?; } + let Tracker { notify, bytes, .. } = tracker.into_inner(); // A header must never reuse the last file's AES salt and IV. - writer.set_content_methods(methods(options)?); + writer.set_content_methods(methods(options, false, 1)?); writer.finish()?.flush()?; if !notify(Progress { phase: Phase::Create, @@ -167,7 +190,73 @@ pub fn create_7z( Ok(()) } -fn methods(options: &CreateOptions<'_>) -> Result> { +/// The most a solid block holds. Reading one entry decodes everything before +/// it in its block, so a block of the whole archive would make opening one +/// file of a large archive as slow as extracting all of it. +const SOLID_BYTES: u64 = 256 << 20; + +/// Extensions of x86 and x64 machine code, which the BCJ filter makes much +/// easier to compress by turning relative call targets into absolute ones. +/// 7-Zip picks them the same way, by name. +const EXECUTABLE: [&str; 9] = [ + "exe", "dll", "sys", "ocx", "cpl", "scr", "drv", "efi", "mui", +]; + +struct Block { + files: Vec, + executables: bool, +} + +/// Groups the files with data into solid blocks, executables apart so that +/// only they go through the filter, each group sorted by extension and then +/// by name so that similar files sit next to each other in the stream. +fn solid_blocks(sources: &[Source], metadata: &[fs::Metadata], files: &[usize]) -> Vec { + let extension = |i: usize| { + Path::new(&sources[i].name) + .extension() + .map(|e| e.to_string_lossy().to_ascii_lowercase()) + .unwrap_or_default() + }; + let (mut executables, mut rest): (Vec, Vec) = files + .iter() + .partition(|&&i| EXECUTABLE.contains(&extension(i).as_str())); + let mut blocks = Vec::new(); + for (group, filtered) in [(&mut rest, false), (&mut executables, true)] { + group.sort_by_cached_key(|&i| (extension(i), sources[i].name.to_lowercase())); + let mut block = Vec::new(); + let mut size = 0u64; + for &i in group.iter() { + if !block.is_empty() && size + metadata[i].len() > SOLID_BYTES { + blocks.push(Block { + files: std::mem::take(&mut block), + executables: filtered, + }); + size = 0; + } + size += metadata[i].len(); + block.push(i); + } + if !block.is_empty() { + blocks.push(Block { + files: block, + executables: filtered, + }); + } + } + blocks +} + +/// LZMA2 threads for `level`, as many cores as fit in the same memory budget +/// the .xz encoder keeps to. +pub fn workers(level: Level) -> usize { + arca_xz::workers(level, 0) +} + +fn methods( + options: &CreateOptions<'_>, + executables: bool, + workers: usize, +) -> Result> { let mut methods = Vec::new(); if let Some(password) = options.password { let mut iv = [0; 16]; @@ -185,31 +274,80 @@ fn methods(options: &CreateOptions<'_>) -> Result> { .into(), ); } - methods.push(match options.level.get() { - 0 => EncoderMethod::COPY.into(), - n => Lzma2Options::from_level(u32::from(n)).into(), + let level = u32::from(options.level.get()); + if level == 0 { + methods.push(EncoderMethod::COPY.into()); + return Ok(methods); + } + let preset = arca_xz::preset(options.level); + methods.push(if workers > 1 { + Lzma2Options::from_level_mt(level, workers as u32, arca_xz::block_size(preset)).into() + } else { + Lzma2Options::from_level(level).into() }); + // The last method is the first applied to the data. + if executables { + methods.push(EncoderMethod::BCJ_X86_FILTER.into()); + } Ok(methods) } -struct Input<'a> { - file: fs::File, - notify: &'a mut dyn FnMut(Progress<'_>) -> bool, - progress: Progress<'a>, - cancelled: bool, +/// What every file of a solid block shares while the block is written: the +/// caller's progress, and whether reading stopped and why. +struct Tracker<'n> { + notify: &'n mut dyn FnMut(Progress<'_>) -> bool, + total: usize, + done: usize, bytes: u64, + cancelled: bool, + changed: bool, } -impl Read for Input<'_> { +/// A file of a solid block, opened when the block first reads from it so that +/// a block of thousands of files never holds thousands of handles. +struct Lazy<'a, 'n> { + path: &'a Path, + name: &'a str, + expected: u64, + file: Option, + read: u64, + tracker: &'a std::cell::RefCell>, +} + +impl Read for Lazy<'_, '_> { fn read(&mut self, buffer: &mut [u8]) -> io::Result { - let mut progress = self.progress; - progress.bytes_done += self.bytes; - if !(self.notify)(progress) { - self.cancelled = true; + let mut tracker = self.tracker.borrow_mut(); + let progress = Progress { + phase: Phase::Create, + entries_done: tracker.done, + entries_total: tracker.total, + bytes_done: tracker.bytes, + name: self.name, + }; + if !(tracker.notify)(progress) { + tracker.cancelled = true; return Err(io::Error::other("cancelled")); } - let size = self.file.read(buffer)?; - self.bytes += size as u64; + if self.file.is_none() { + self.file = Some(fs::File::open(self.path)?); + } + let size = match self.file.as_mut() { + Some(file) => file.read(buffer)?, + None => 0, + }; + self.read += size as u64; + tracker.bytes += size as u64; + if size == 0 { + if self.read != self.expected { + tracker.changed = true; + return Err(io::Error::other("7z source changed size during creation")); + } + self.file = None; + tracker.done += 1; + } else if self.read > self.expected { + tracker.changed = true; + return Err(io::Error::other("7z source changed size during creation")); + } Ok(size) } } diff --git a/arca-7z/tests/archive.rs b/arca-7z/tests/archive.rs index abe5792a..04856914 100644 --- a/arca-7z/tests/archive.rs +++ b/arca-7z/tests/archive.rs @@ -215,12 +215,21 @@ fn empty_and_unicode_roundtrip_all_levels_and_password_modes() { let mut archive = SevenZArchive::open(fs::File::open(path).unwrap(), password).unwrap(); assert_eq!(archive.has_encrypted_header(), hide_names); assert_eq!(archive.has_encrypted(), password.is_some()); - assert_eq!(archive.entries()[1].name, sources[1].name); - assert!(archive.entries()[0].is_dir); - assert!(!archive.entries()[2].is_dir); - assert_eq!(archive.read_entry(2, 0, &mut |_| true).unwrap(), b""); + // Entries are grouped by kind for solid compression, as 7-Zip does, + // so they are found by name rather than by the order they were given. + let at = |name: &str| { + archive + .entries() + .iter() + .position(|e| e.name == name) + .unwrap() + }; + let (folder, data, empty) = (at("folder"), at(&sources[1].name), at("empty")); + assert!(archive.entries()[folder].is_dir); + assert!(!archive.entries()[empty].is_dir); + assert_eq!(archive.read_entry(empty, 0, &mut |_| true).unwrap(), b""); assert_eq!( - archive.read_entry(1, 100, &mut |_| true).unwrap(), + archive.read_entry(data, 100, &mut |_| true).unwrap(), b"hello compressed world" ); archive.test(&mut |_| true).unwrap(); @@ -671,3 +680,127 @@ fn malformed_header_mutations_never_panic() { } } } + +/// Bytes that look like x86 code and compress like a program: the same few +/// call instructions with targets that drift, which BCJ is there to smooth. +fn machine_code(len: usize) -> Vec { + let mut out = Vec::with_capacity(len); + let mut target = 0x1000u32; + while out.len() < len { + out.push(0xE8); + out.extend_from_slice(&target.wrapping_sub(out.len() as u32).to_le_bytes()); + out.extend_from_slice(b"\x48\x89\xc7\x90"); + target = target.wrapping_add(16); + } + out.truncate(len); + out +} + +/// Text that varies enough to need several multithreaded LZMA2 chunks. +fn prose(len: usize) -> Vec { + let mut out = Vec::with_capacity(len); + let mut n = 0u64; + while out.len() < len { + n = n.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1); + out.extend_from_slice(format!("line {} of the archive, {}\n", n % 977, n >> 50).as_bytes()); + } + out.truncate(len); + out +} + +// Solid blocks, executables in a block of their own behind the BCJ filter, +// more files than a block could hold open at once, and data large enough to +// be cut into chunks by every LZMA2 thread: all of it reads back, with and +// without a password. +#[test] +fn solid_blocks_with_executables_and_many_files_round_trip() { + let temp = tempfile::tempdir().unwrap(); + let mut sources = Vec::new(); + let mut expected = Vec::new(); + let mut add = |name: String, data: Vec| { + let path = temp.path().join(format!("f{}", sources.len())); + fs::write(&path, &data).unwrap(); + sources.push(Source { + path, + name: name.clone(), + }); + expected.push((name, data)); + }; + add("app/program.exe".into(), machine_code(300_000)); + add("app/library.DLL".into(), machine_code(120_000)); + add("big.txt".into(), prose(7 << 20)); + for i in 0..1500 { + add( + format!("many/{i:04}.txt"), + format!("file number {i}\n").repeat(i % 7 + 1).into_bytes(), + ); + } + for (level, password) in [ + (Level::FAST, None), + (Level::FAST, Some("secret")), + (Level::STORE, None), + ] { + let path = temp.path().join("out.7z"); + create_7z( + &path, + &sources, + &CreateOptions { + level, + password, + hide_names: false, + }, + &mut |_| true, + ) + .unwrap(); + let mut archive = SevenZArchive::open(fs::File::open(&path).unwrap(), password).unwrap(); + assert_eq!(archive.entries().len(), expected.len()); + archive.test(&mut |_| true).unwrap(); + let checked = [ + "app/program.exe", + "app/library.DLL", + "big.txt", + "many/0000.txt", + "many/1499.txt", + ]; + for (name, data) in expected + .iter() + .filter(|(n, _)| checked.contains(&n.as_str())) + { + let index = archive + .entries() + .iter() + .position(|e| &e.name == name) + .unwrap(); + let read = archive.read_entry(index, 32 << 20, &mut |_| true).unwrap(); + assert!(&read == data, "{name} at {level:?}"); + } + } +} + +// A source that grows while a solid block reads it fails the whole archive +// instead of writing an entry whose recorded size is wrong. +#[test] +fn a_source_that_changes_size_in_a_solid_block_fails() { + let temp = tempfile::tempdir().unwrap(); + let path = temp.path().join("a.txt"); + fs::write(&path, b"abc").unwrap(); + let sources = vec![Source { + path: path.clone(), + name: "a.txt".into(), + }]; + let mut grown = false; + let result = create_7z( + &temp.path().join("out.7z"), + &sources, + &CreateOptions::default(), + &mut |p| { + if !grown && p.name == "a.txt" { + fs::write(&path, b"abcdef").unwrap(); + grown = true; + } + true + }, + ); + assert!(result.is_err()); + assert!(!temp.path().join("out.7z").exists()); +} diff --git a/arca-7z/vendor/PATCHES.md b/arca-7z/vendor/PATCHES.md index f726e324..bf5bf493 100644 --- a/arca-7z/vendor/PATCHES.md +++ b/arca-7z/vendor/PATCHES.md @@ -30,6 +30,9 @@ Local changes: encrypted headers without a verifiable nonempty stream. - Populate the format's default substream mapping when its optional section is absent; reject unused pack streams and inconsistent file/substream counts. +- Cap the threads of a multithreaded LZMA2 decoder so that one dictionary per + thread stays within four times the single-thread memory limit, since the + dictionary size comes from the archive. No new compression or cryptography is implemented. Upstream's existing bounded AES work factor (max power 24) and single-entry KDF cache are unchanged. Arca diff --git a/arca-7z/vendor/sevenz-rust2/src/decoder.rs b/arca-7z/vendor/sevenz-rust2/src/decoder.rs index 9f7217ce..3b5cf90f 100644 --- a/arca-7z/vendor/sevenz-rust2/src/decoder.rs +++ b/arca-7z/vendor/sevenz-rust2/src/decoder.rs @@ -120,6 +120,10 @@ pub fn add_decoder( }); } + // Each thread holds a dictionary of its own: an archive that names a + // large one gets fewer threads, so all of them together stay within + // four times the single-thread limit. + let threads = threads.min((4 * max_mem_limit_kb / mem_size.max(1)) as u32); let lz = if threads < 2 { Decoder::Lzma2(Box::new(Lzma2Reader::new(input, dic_size, None))) } else { diff --git a/arca-cli/src/main.rs b/arca-cli/src/main.rs index 30482ac0..fb31a20c 100644 --- a/arca-cli/src/main.rs +++ b/arca-cli/src/main.rs @@ -45,7 +45,7 @@ enum Cmd { short = 'j', long, default_value_t = 0, - help = "Threads to use. 0 means every core. .7z and .rar creation is sequential; .xz and .tar.xz use as many as fit in 2 GiB" + help = "Threads to use. 0 means every core. .rar creation is sequential; .xz and .tar.xz use as many as fit in 2 GiB, and .7z always does" )] threads: usize, #[arg( diff --git a/arca-cli/src/sevenz.rs b/arca-cli/src/sevenz.rs index 3fbc0ae9..b0967b9b 100644 --- a/arca-cli/src/sevenz.rs +++ b/arca-cli/src/sevenz.rs @@ -49,11 +49,16 @@ pub(super) fn create( let t0 = Instant::now(); create_7z(out, &sources, &options, &mut |_| true)?; println!( - "{}: {files} files, {} -> {} in {:.3} s (sequential)", + "{}: {files} files, {} -> {} in {:.3} s \u{b7} {} threads", out.display(), human(bytes), human(fs::metadata(out)?.len()), - t0.elapsed().as_secs_f64() + t0.elapsed().as_secs_f64(), + if options.level == Level::STORE { + 1 + } else { + arca_7z::workers(options.level) + } ); Ok(()) } diff --git a/arca-cli/tests/rar.rs b/arca-cli/tests/rar.rs index 2a9d89ca..08487408 100644 --- a/arca-cli/tests/rar.rs +++ b/arca-cli/tests/rar.rs @@ -91,10 +91,7 @@ fn help_mentions_rar_creation() { assert!(result.status.success()); let help = stdout(&result); assert!(help.contains(".rar"), "{help}"); - assert!( - help.contains(".7z and .rar creation is sequential"), - "{help}" - ); + assert!(help.contains(".rar creation is sequential"), "{help}"); } #[cfg(not(feature = "rar"))] diff --git a/arca-cli/tests/sevenz.rs b/arca-cli/tests/sevenz.rs index 8efaf5d4..a8aa5dfb 100644 --- a/arca-cli/tests/sevenz.rs +++ b/arca-cli/tests/sevenz.rs @@ -133,14 +133,14 @@ fn create_list_test_extract_all_levels_and_password_modes() { args.push("--hide-names"); } let summary = temp.ok(&args); - assert!(summary.contains("sequential")); + assert!(summary.contains("threads")); let archive = SevenZArchive::open( File::open(temp.0.join("archive.7z")).unwrap(), Some(password), ) .unwrap(); assert_eq!(archive.has_encrypted_header(), mode == "hidden"); - assert!(!archive.is_solid()); + assert!(archive.is_solid()); let entry = archive .entries() .iter() diff --git a/arca-xz/src/lib.rs b/arca-xz/src/lib.rs index e6411f63..e49059ce 100644 --- a/arca-xz/src/lib.rs +++ b/arca-xz/src/lib.rs @@ -340,7 +340,9 @@ fn dictionary(preset: u32) -> u64 { u64::from(LzmaOptions::with_preset(preset).dict_size) } -fn block_size(preset: u32) -> u64 { +/// How much uncompressed data each thread of a multithreaded LZMA2 encoder +/// takes at a time: three dictionaries, so cutting the stream costs little. +pub fn block_size(preset: u32) -> u64 { (3 * dictionary(preset)).max(1 << 20) } diff --git a/docs/guide/cli-reference.md b/docs/guide/cli-reference.md index 28d05964..153c0847 100644 --- a/docs/guide/cli-reference.md +++ b/docs/guide/cli-reference.md @@ -42,7 +42,7 @@ Create an archive. The format is taken from the extension of the output file. | `...` | required | Files or directories to include. | | `-l, --level ` | normal | store · fast · normal · best. | | `-c, --codec ` | auto | auto · store · deflate · zstd · lzma2. auto uses Deflate in .zip, LZMA2 in .7z, .xz and .tar.xz and the RAR compressor in .rar (auto or store only). | -| `-j, --threads ` | 0 | ZIP and XZ threads; 0 means every core. XZ uses as many as fit in 2 GiB. 7z and RAR creation is sequential; .rar refuses N above 1. | +| `-j, --threads ` | 0 | ZIP and XZ threads; 0 means every core. XZ, and 7z regardless of this option, use as many as fit in 2 GiB. RAR creation is sequential; .rar refuses N above 1. | | `-p, --password ` | none | Encrypt with AES-256 (.zip, .7z). Other tools will ask for it to open the archive. Refused for .rar. | | `--hide-names` | off | 7z only: encrypt headers; requires a nonempty password. | diff --git a/docs/guide/creating-archives.md b/docs/guide/creating-archives.md index 217861a0..58dc797d 100644 --- a/docs/guide/creating-archives.md +++ b/docs/guide/creating-archives.md @@ -15,7 +15,7 @@ arca create ... [-l LEVEL] [-c CODEC] [-j THREADS] [-p PASSWORD] [ | --- | --- | --- | --- | | `-l, --level` | store · fast · normal · best | normal | Compression level. | | `-c, --codec` | auto · store · deflate · zstd · lzma2 | auto | Deflate in .zip, LZMA2 in .7z, .xz and .tar.xz, the RAR compressor in .rar (auto or store only). | -| `-j, --threads` | a number | 0 | ZIP and XZ thread limit. 0 means every core; 7z and RAR are sequential. | +| `-j, --threads` | a number | 0 | ZIP and XZ thread limit. 0 means every core; 7z uses as many as fit in 2 GiB and RAR is sequential. | | `-p, --password` | text | none | Encrypt ZIP or 7z with AES-256. Refused for .rar. | | `--hide-names` | flag | off | Encrypt 7z headers too; requires a nonempty password. | @@ -65,8 +65,11 @@ and 9. `-c store` overrides the level. Only `auto`, `store` and `lzma2` are accepted for 7z; explicit Deflate/Zstandard codec selection applies to ZIP, not 7z. TAR ignores those codec choices and `.tar.gz` always uses gzip; `lzma2` is rejected outside 7z. -Creation is sequential regardless of `-j`, with one independent block per file, -not solid compression. Reading existing solid archives is supported. +Files are compressed together in solid blocks of up to 256 MiB, grouped by +extension the way 7-Zip does; x86 executables (`.exe`, `.dll` and the like) go +in blocks of their own behind the BCJ filter, which makes machine code smaller. +LZMA2 runs on as many cores as fit in 2 GiB (every core at `fast` and `normal`, +one at `best`), and entries are listed in that grouped order. 7z includes empty files and directories and rejects symlink/reparse-point and special-file inputs rather than following them. Creation writes a temporary diff --git a/docs/guide/desktop-app.md b/docs/guide/desktop-app.md index a54180e1..af941a2a 100644 --- a/docs/guide/desktop-app.md +++ b/docs/guide/desktop-app.md @@ -63,8 +63,8 @@ actions stay disabled for it. CBR cannot be created. See [RAR](rar.md#creating-r ## 7z -Create 7z using Store or LZMA2 and the existing levels. Creation and extraction -are sequential. Selected members of solid archives share one decoder per block +Create 7z using Store or LZMA2 and the existing levels, in solid blocks and on as +many cores as fit in 2 GiB; extraction decodes on every core. Selected members of solid archives share one decoder per block per pass, rather than reopening it for each member. Preview, open-file, Copy and Extract use the same validated read path. See [Encryption](encryption.md) and [resource limits](architecture.md#7z-boundaries). diff --git a/docs/guide/es/cli-reference.md b/docs/guide/es/cli-reference.md index c2e2cd47..10a1af9c 100644 --- a/docs/guide/es/cli-reference.md +++ b/docs/guide/es/cli-reference.md @@ -42,7 +42,7 @@ Crea un archivo. El formato se toma de la extensión del archivo de salida. | `...` | obligatorio | Archivos o directorios a incluir. | | `-l, --level ` | normal | store · fast · normal · best. | | `-c, --codec ` | auto | auto · store · deflate · zstd · lzma2. auto usa Deflate en .zip, LZMA2 en .7z, .xz y .tar.xz y el compresor RAR en .rar (solo auto o store). | -| `-j, --threads ` | 0 | Hilos ZIP y XZ; 0 usa todos los núcleos. XZ usa tantos como quepan en 2 GiB. La creación 7z y RAR es secuencial; .rar rechaza N mayor que 1. | +| `-j, --threads ` | 0 | Hilos ZIP y XZ; 0 usa todos los núcleos. XZ, y 7z al margen de esta opción, usan tantos como quepan en 2 GiB. La creación RAR es secuencial; .rar rechaza N mayor que 1. | | `-p, --password ` | ninguna | Cifra con AES-256 (.zip, .7z). Otras herramientas la pedirán para abrir el archivo. Se rechaza en .rar. | | `--hide-names` | desactivado | Solo 7z: cifra cabeceras; exige una contraseña no vacía. | diff --git a/docs/guide/es/creating-archives.md b/docs/guide/es/creating-archives.md index e51a9d41..31b660d4 100644 --- a/docs/guide/es/creating-archives.md +++ b/docs/guide/es/creating-archives.md @@ -15,7 +15,7 @@ arca create ... [-l LEVEL] [-c CODEC] [-j THREADS] [-p PASSWORD] [ | --- | --- | --- | --- | | `-l, --level` | store · fast · normal · best | normal | Nivel de compresión. | | `-c, --codec` | auto · store · deflate · zstd · lzma2 | auto | Deflate en .zip, LZMA2 en .7z, .xz y .tar.xz, el compresor RAR en .rar (solo auto o store). | -| `-j, --threads` | un número | 0 | Límite de hilos ZIP y XZ. 0 usa todos los núcleos; 7z y RAR son secuenciales. | +| `-j, --threads` | un número | 0 | Límite de hilos ZIP y XZ. 0 usa todos los núcleos; 7z usa tantos como quepan en 2 GiB y RAR es secuencial. | | `-p, --password` | texto | ninguna | Cifra ZIP o 7z con AES-256. Se rechaza en .rar. | | `--hide-names` | indicador | desactivado | Cifra también las cabeceras 7z; exige una contraseña no vacía. | @@ -64,8 +64,11 @@ Los niveles `store`, `fast`, `normal` y `best` seleccionan Copy o LZMA2 con nive 1, 6 y 9. `-c store` prevalece sobre el nivel. 7z solo admite `auto`, `store` y `lzma2`; la selección explícita Deflate/Zstandard se aplica a ZIP, no a 7z. TAR ignora esas opciones y `.tar.gz` siempre usa gzip; `lzma2` se rechaza fuera de 7z. -La creación es secuencial independientemente de `-j`, con un bloque independiente -por fichero, sin compresión sólida. Sí se pueden leer archivos sólidos existentes. +Los ficheros se comprimen juntos en bloques sólidos de hasta 256 MiB, agrupados +por extensión como hace 7-Zip; los ejecutables x86 (`.exe`, `.dll` y similares) +van en bloques propios con el filtro BCJ, que reduce el código máquina. LZMA2 usa +tantos núcleos como quepan en 2 GiB (todos en `fast` y `normal`, uno en `best`), y +las entradas se listan en ese orden agrupado. 7z incluye ficheros y directorios vacíos y rechaza enlaces simbólicos, puntos de reanálisis y ficheros especiales. La creación usa un temporal junto al destino y diff --git a/docs/guide/es/desktop-app.md b/docs/guide/es/desktop-app.md index a6aa6855..268af8a7 100644 --- a/docs/guide/es/desktop-app.md +++ b/docs/guide/es/desktop-app.md @@ -64,8 +64,8 @@ No se puede crear CBR. Consulta [RAR](rar.md#crear-archivos-rar5). ## 7z -Crea 7z con Store o LZMA2 y los niveles existentes. La creación y la extracción -son secuenciales. Las entradas seleccionadas de archivos sólidos comparten un +Crea 7z con Store o LZMA2 y los niveles existentes, en bloques sólidos y con tantos +núcleos como quepan en 2 GiB; la extracción descomprime con todos los núcleos. Las entradas seleccionadas de archivos sólidos comparten un decodificador por bloque y pasada, sin reabrirlo por cada entrada. La vista previa, abrir, Copiar y Extraer usan la misma ruta de lectura validada. Consulta [Cifrado](encryption.md) y los [límites de recursos](architecture.md#7z-boundaries). diff --git a/docs/guide/es/listing-extracting.md b/docs/guide/es/listing-extracting.md index f3a8628e..5ffa04b5 100644 --- a/docs/guide/es/listing-extracting.md +++ b/docs/guide/es/listing-extracting.md @@ -78,7 +78,7 @@ Las cabeceras ocultas la exigen incluso para listar. El listado no verifica el contenido: usa `test`. Solo el primer miembro de un bloque sólido muestra su tamaño comprimido; los ratios por fichero no son medidas independientes. -La extracción 7z es secuencial, también para selecciones en la ventana. Hay que +La extracción 7z descomprime cada bloque con todos los núcleos cuando el bloque se escribió por trozos, como lo escriben Arca y `7z -mmt`; los bloques se descomprimen uno tras otro. Hay que descomprimir los datos sólidos omitidos. Para cualquier 7z cifrado, Arca valida todo el contenido antes de crear o sustituir ficheros o directorios de destino, y extrae lo seleccionado en una segunda pasada. Una contraseña incorrecta o un diff --git a/docs/guide/listing-extracting.md b/docs/guide/listing-extracting.md index e741beb9..a23867f7 100644 --- a/docs/guide/listing-extracting.md +++ b/docs/guide/listing-extracting.md @@ -78,7 +78,7 @@ Hidden headers require one even to list. Listing does not validate file contents use `test` for that. In a solid block, only the first member reports the packed size, so per-file ratios are not independent compression measurements. -7z extraction is sequential, including selected entries in the desktop window. +7z extraction decodes each block on every core where the block was written in chunks, as Arca and `7z -mmt` write them; blocks themselves are decoded one after another. Skipped solid data still has to be decoded. For any encrypted 7z, Arca validates all contents before any destination directory/file creation or replacement, then extracts selected contents in a second pass. A wrong password or failed encrypted diff --git a/interop.sh b/interop.sh index a3ea222d..4278b82c 100644 --- a/interop.sh +++ b/interop.sh @@ -195,7 +195,8 @@ fi echo echo "G) 7z: Arca writes, 7-Zip verifies and extracts" -python3 - <<'PY' +python3 - "$ARCA" <<'PY' +import sys from pathlib import Path root = Path('src7') (root / 'nested' / 'empty-dir').mkdir(parents=True) @@ -203,6 +204,15 @@ root = Path('src7') (root / 'first.txt').write_bytes(b'first solid contents\n' * 2000) (root / 'second.txt').write_bytes(b'second solid contents\n' * 2000) (root / 'nested' / '\u00f1-\U0001f680.txt').write_bytes(bytes(range(256)) * 16) +# Executables go in a block of their own behind the BCJ filter, so 7-Zip has +# to undo that filter too; the program is the binary under test, the library +# made-up x86 calls. +(root / 'bin').mkdir() +(root / 'bin' / 'arca.exe').write_bytes(Path(sys.argv[1]).read_bytes()) +calls = bytearray() +for i in range(40000): + calls += b'\xe8' + ((0x1000 + 16 * i - len(calls)) & 0xffffffff).to_bytes(4, 'little') + b'\x48\x89\xc7\x90' +(root / 'bin' / 'helper.dll').write_bytes(bytes(calls)) PY compare_trees() { python3 - "$1" "$2" <<'PY' From e1932505eb1eabf877d9f7acda75dfc25f96a600 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 14:49:22 +0100 Subject: [PATCH 12/44] fix(arca-gui): extract the later of two same-named ZIP entries, not both Extracting a ZIP whose two entries share a name, both answered Replace, wrote the two from two threads at the same time, and what was left could be a mix of both. The later entry, which extracting in order leaves, is now the only one written, as the CLI already does. Co-Authored-By: Claude Opus 5.5 --- arca-gui/src/archive_ops/io.rs | 7 +++++++ arca-gui/src/archive_ops/xz_tests.rs | 22 ++++++++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/arca-gui/src/archive_ops/io.rs b/arca-gui/src/archive_ops/io.rs index c6d12be1..77f66c34 100644 --- a/arca-gui/src/archive_ops/io.rs +++ b/arca-gui/src/archive_ops/io.rs @@ -769,6 +769,13 @@ pub(crate) fn extract( } } drop(a); + // Two entries of one name both answered Replace: the later one is + // what extracting in order leaves, and writing both from two + // threads at once would leave a mix of the two. + let mut seen = HashSet::new(); + jobs.reverse(); + jobs.retain(|(e, path)| e.is_dir || seen.insert(path.clone())); + jobs.reverse(); let total = jobs.len(); let done = AtomicUsize::new(0); diff --git a/arca-gui/src/archive_ops/xz_tests.rs b/arca-gui/src/archive_ops/xz_tests.rs index 54eb8c10..32c7cdb4 100644 --- a/arca-gui/src/archive_ops/xz_tests.rs +++ b/arca-gui/src/archive_ops/xz_tests.rs @@ -255,3 +255,25 @@ fn a_stop_during_a_small_xz_job_publishes_nothing() { )); assert!(leftovers(&room.0).is_empty()); } + +// Two ZIP entries of one name, both replaced: the later one wins, as it would +// extracting in order, and never a mix of the two written at once. +#[test] +fn the_later_of_two_same_named_zip_entries_is_the_one_extracted() { + let room = Room::new(); + let archive = room.path("dup.zip"); + let mut zip = arca_zip::ZipWriter::new(File::create(&archive).unwrap()); + for body in [&b"first"[..], &b"second, which is longer"[..]] { + zip.add("dup.txt", body, Codec::Store, Level::STORE, None) + .unwrap(); + } + zip.finish().unwrap(); + for run in 0..20 { + let dest = room.path(&format!("out{run}")); + extract(&archive, &dest, &[], GO, &replace, None).unwrap(); + assert_eq!( + fs::read(dest.join("dup.txt")).unwrap(), + b"second, which is longer" + ); + } +} From ba917031a8ecf06df7cb8be486cd9ceffad23865 Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 15:00:29 +0100 Subject: [PATCH 13/44] docs: take GNU tar long names and solid 7z off the roadmap Both are done: the tar reader applies GNU and pax long names, and 7z creation writes solid blocks. Co-Authored-By: Claude Opus 5.5 --- docs/guide/es/roadmap.md | 2 -- docs/guide/roadmap.md | 2 -- 2 files changed, 4 deletions(-) diff --git a/docs/guide/es/roadmap.md b/docs/guide/es/roadmap.md index 63fc45b4..9590a67e 100644 --- a/docs/guide/es/roadmap.md +++ b/docs/guide/es/roadmap.md @@ -32,8 +32,6 @@ y escritorio. Consulta el - **UDF:** las imágenes ISO se leen por ISO 9660, así que los ficheros que solo están en UDF (como `install.wim` en los medios de Windows) todavía no aparecen. - **Enlaces simbólicos:** se omiten al crear ZIP/TAR y se rechazan en 7z. -- **Nombres largos de GNU tar.** -- **Crear 7z sólidos:** se leen los existentes, pero se crean bloques independientes. - **Cambiar contraseñas y modificar 7z:** añadir, borrar y renombrar puede exigir reescribir bloques sólidos y queda fuera del alcance. - **Integración de escritorio en Linux y macOS:** el menú del Explorador es solo para Windows por ahora. - **Modificar fuera de ZIP:** ZIP ya se edita en la ventana; 7z solo se crea y se lee. diff --git a/docs/guide/roadmap.md b/docs/guide/roadmap.md index 06ef0e9f..415b3b50 100644 --- a/docs/guide/roadmap.md +++ b/docs/guide/roadmap.md @@ -31,8 +31,6 @@ extracted in CLI and desktop. See - **UDF:** ISO images are read through ISO 9660, so files stored only in UDF (such as `install.wim` on Windows media) are not listed yet. - **Symbolic links:** skipped for ZIP/TAR creation, rejected for 7z. -- **GNU tar long names.** -- **Solid 7z creation:** existing solid archives can be read, but new ones use independent blocks. - **7z password changes and mutation:** adding, deleting and renaming can require solid-block rewrites and are out of scope. - **Desktop integration on Linux and macOS:** the Explorer menu is Windows-only for now. - **Mutation outside ZIP:** ZIP desktop editing exists; 7z remains create/read only. From 34626487496a62f2d440693791dd4b87a6d650ea Mon Sep 17 00:00:00 2001 From: Saul Rodriguez Date: Mon, 16 Nov 2026 17:44:33 +0100 Subject: [PATCH 14/44] build(arca-rar): vendor rars 0.10.2 The RAR writer's speed is in the encoder's search and parse, which the crate does not let a caller tune, so the crate is brought in as arca-7z's 7z backend was: copied from the crates.io archive (SHA-256 0665518097392be04a322dec9eba41e88028f6aca85f5d61f8abb068691f2266) and applied with [patch.crates-io], outside the workspace. This commit is the published source as it is, so the changes that follow can be read on their own. Only the packaging differs: the [[bench]] targets go with the omitted benches/, the manifest gains an empty [workspace] so its own tests run with --manifest-path, and a .gitattributes keeps every file byte for byte. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 3 +- Cargo.toml | 3 +- arca-rar/vendor/rars/.gitattributes | 2 + arca-rar/vendor/rars/COPYING | 202 + arca-rar/vendor/rars/Cargo.toml | 301 + arca-rar/vendor/rars/README.md | 41 + arca-rar/vendor/rars/src/atomic64.rs | 125 + arca-rar/vendor/rars/src/builder.rs | 2736 ++++++ arca-rar/vendor/rars/src/codec/canonical.rs | 218 + arca-rar/vendor/rars/src/codec/fast.rs | 246 + arca-rar/vendor/rars/src/codec/filters.rs | 526 ++ arca-rar/vendor/rars/src/codec/huffman.rs | 617 ++ .../vendor/rars/src/codec/match_finder.rs | 479 + arca-rar/vendor/rars/src/codec/mod.rs | 145 + arca-rar/vendor/rars/src/codec/ppmd.rs | 1971 ++++ arca-rar/vendor/rars/src/codec/ppmd/tests.rs | 1545 +++ arca-rar/vendor/rars/src/codec/rar13.rs | 923 ++ .../vendor/rars/src/codec/rar13/encoder.rs | 1470 +++ .../rars/src/codec/rar13/solid_regressions.rs | 307 + arca-rar/vendor/rars/src/codec/rar13/tests.rs | 1482 +++ arca-rar/vendor/rars/src/codec/rar20.rs | 760 ++ .../vendor/rars/src/codec/rar20/encoder.rs | 1533 +++ arca-rar/vendor/rars/src/codec/rar20/tests.rs | 1227 +++ arca-rar/vendor/rars/src/codec/rar29.rs | 1407 +++ .../vendor/rars/src/codec/rar29/encoder.rs | 2321 +++++ .../rars/src/codec/rar29/standard_filters.rs | 302 + arca-rar/vendor/rars/src/codec/rar29/tests.rs | 4223 +++++++++ arca-rar/vendor/rars/src/codec/rar50.rs | 1927 ++++ .../rars/src/codec/rar50/bit_reader_tests.rs | 78 + .../rars/src/codec/rar50/checkpoint_tests.rs | 118 + .../rars/src/codec/rar50/convergence_tests.rs | 328 + .../vendor/rars/src/codec/rar50/encoder.rs | 3464 +++++++ .../codec/rar50/history_retention_tests.rs | 708 ++ .../rars/src/codec/rar50/huffman_tests.rs | 23 + .../src/codec/rar50/literal_pricing_tests.rs | 907 ++ .../rars/src/codec/rar50/pricing_tests.rs | 344 + .../src/codec/rar50/streaming_copy_tests.rs | 227 + arca-rar/vendor/rars/src/codec/rar50/tests.rs | 5770 ++++++++++++ arca-rar/vendor/rars/src/codec/rarvm.rs | 1093 +++ arca-rar/vendor/rars/src/codec/rarvm/tests.rs | 1273 +++ arca-rar/vendor/rars/src/codec/workspace.rs | 869 ++ .../rars/src/codec/workspace/coordinator.rs | 217 + .../vendor/rars/src/codec/workspace/ledger.rs | 286 + arca-rar/vendor/rars/src/crc32/mod.rs | 224 + arca-rar/vendor/rars/src/crypto/mod.rs | 90 + arca-rar/vendor/rars/src/crypto/rar13.rs | 107 + arca-rar/vendor/rars/src/crypto/rar15.rs | 76 + arca-rar/vendor/rars/src/crypto/rar20.rs | 22 + .../rars/src/crypto/rar20/implementation.rs | 233 + arca-rar/vendor/rars/src/crypto/rar30.rs | 24 + .../rars/src/crypto/rar30/implementation.rs | 312 + arca-rar/vendor/rars/src/crypto/rar50.rs | 122 + .../rars/src/crypto/rar50/implementation.rs | 280 + .../vendor/rars/src/crypto/unavailable.rs | 64 + arca-rar/vendor/rars/src/detect.rs | 192 + arca-rar/vendor/rars/src/entropy.rs | 65 + arca-rar/vendor/rars/src/error.rs | 1098 +++ .../vendor/rars/src/extraction_control.rs | 99 + arca-rar/vendor/rars/src/features.rs | 113 + arca-rar/vendor/rars/src/file_times.rs | 526 ++ arca-rar/vendor/rars/src/filename.rs | 607 ++ arca-rar/vendor/rars/src/filter.rs | 237 + arca-rar/vendor/rars/src/filter_search.rs | 2292 +++++ arca-rar/vendor/rars/src/io_util.rs | 33 + arca-rar/vendor/rars/src/lib.rs | 5822 ++++++++++++ arca-rar/vendor/rars/src/member.rs | 276 + arca-rar/vendor/rars/src/member_read.rs | 206 + arca-rar/vendor/rars/src/output_limit.rs | 483 + arca-rar/vendor/rars/src/parallel.rs | 376 + arca-rar/vendor/rars/src/parse_budget.rs | 154 + arca-rar/vendor/rars/src/pending_archive.rs | 58 + arca-rar/vendor/rars/src/progress.rs | 124 + arca-rar/vendor/rars/src/rar13.rs | 1424 +++ arca-rar/vendor/rars/src/rar13/write.rs | 3791 ++++++++ arca-rar/vendor/rars/src/rar15_40.rs | 5281 +++++++++++ arca-rar/vendor/rars/src/rar15_40/extract.rs | 2258 +++++ arca-rar/vendor/rars/src/rar15_40/write.rs | 3829 ++++++++ arca-rar/vendor/rars/src/rar50.rs | 4677 +++++++++ arca-rar/vendor/rars/src/rar50/blake2sp.rs | 517 + arca-rar/vendor/rars/src/rar50/extract.rs | 4148 ++++++++ arca-rar/vendor/rars/src/rar50/framing.rs | 173 + .../src/rar50/independent_history_tests.rs | 374 + arca-rar/vendor/rars/src/rar50/scratch.rs | 387 + .../rars/src/rar50/streaming_checks_tests.rs | 531 ++ .../vendor/rars/src/rar50/write/compress.rs | 3235 +++++++ .../vendor/rars/src/rar50/write/engine.rs | 3223 +++++++ .../rars/src/rar50/write/filter_policy.rs | 961 ++ .../vendor/rars/src/rar50/write/headers.rs | 1027 ++ .../vendor/rars/src/rar50/write/layout.rs | 446 + arca-rar/vendor/rars/src/rar50/write/mod.rs | 2867 ++++++ arca-rar/vendor/rars/src/rar50/write/plan.rs | 236 + arca-rar/vendor/rars/src/read_control.rs | 367 + arca-rar/vendor/rars/src/reader_scratch.rs | 49 + .../vendor/rars/src/reader_signature_tests.rs | 151 + arca-rar/vendor/rars/src/recovery/mod.rs | 8 + arca-rar/vendor/rars/src/recovery/rar3.rs | 9 + .../vendor/rars/src/recovery/rar3/errors.rs | 25 + .../rars/src/recovery/rar3/implementation.rs | 482 + arca-rar/vendor/rars/src/recovery/rar5.rs | 12 + .../vendor/rars/src/recovery/rar5/checksum.rs | 24 + .../vendor/rars/src/recovery/rar5/errors.rs | 79 + .../rars/src/recovery/rar5/implementation.rs | 4789 ++++++++++ arca-rar/vendor/rars/src/rewrite.rs | 642 ++ arca-rar/vendor/rars/src/rewrite_staging.rs | 533 ++ .../rars/src/rewrite_staging/pipeline.rs | 496 + arca-rar/vendor/rars/src/source.rs | 253 + arca-rar/vendor/rars/src/streaming.rs | 1634 ++++ .../vendor/rars/src/streaming/memory_spool.rs | 513 + arca-rar/vendor/rars/src/streaming/output.rs | 253 + .../vendor/rars/src/streaming/preparation.rs | 503 + arca-rar/vendor/rars/src/temp_file.rs | 181 + arca-rar/vendor/rars/src/test_features.rs | 283 + arca-rar/vendor/rars/src/timestamp.rs | 342 + arca-rar/vendor/rars/src/tzif.rs | 654 ++ arca-rar/vendor/rars/src/version.rs | 139 + arca-rar/vendor/rars/src/volume_extract.rs | 183 + arca-rar/vendor/rars/src/write_plan.rs | 446 + arca-rar/vendor/rars/src/write_progress.rs | 304 + arca-rar/vendor/rars/src/write_stream.rs | 452 + arca-rar/vendor/rars/src/writer_option.rs | 63 + arca-rar/vendor/rars/src/x86_filter_scan.rs | 440 + .../vendor/rars/tests/builder_directories.rs | 83 + .../rars/tests/builder_file_comments.rs | 285 + .../vendor/rars/tests/builder_identity.rs | 246 + .../vendor/rars/tests/builder_metadata.rs | 263 + arca-rar/vendor/rars/tests/builder_output.rs | 511 + .../vendor/rars/tests/builder_symlinks.rs | 460 + .../vendor/rars/tests/builder_timestamps.rs | 441 + arca-rar/vendor/rars/tests/comment_options.rs | 403 + arca-rar/vendor/rars/tests/crypto_api.rs | 79 + .../vendor/rars/tests/extraction_control.rs | 451 + .../tests/fixtures/golden/stored_comment.rar | Bin 0 -> 1165 bytes .../golden/stored_comment_metadata.rar | Bin 0 -> 1192 bytes .../fixtures/golden/stored_quick_open.rar | Bin 0 -> 3056 bytes .../tests/fixtures/golden/stored_rar50.rar | Bin 0 -> 4294 bytes .../tests/fixtures/golden/stored_rar70.rar | Bin 0 -> 4294 bytes .../fixtures/golden/stored_recovery_1.rar | Bin 0 -> 9387 bytes .../fixtures/golden/stored_recovery_10.rar | Bin 0 -> 9387 bytes .../fixtures/golden/stored_recovery_5.rar | Bin 0 -> 9387 bytes .../fixtures/golden/stored_recovery_50.rar | Bin 0 -> 12585 bytes .../golden/stored_recovery_large.sha256 | 1 + .../tests/fixtures/golden/stored_volume_0.rar | Bin 0 -> 1594 bytes .../tests/fixtures/golden/stored_volume_1.rar | Bin 0 -> 1594 bytes .../tests/fixtures/golden/stored_volume_2.rar | Bin 0 -> 1594 bytes .../tests/fixtures/golden/stored_volume_3.rar | Bin 0 -> 594 bytes .../rars/tests/fixtures/rar13/BIG80K.RAR | Bin 0 -> 12688 bytes .../rars/tests/fixtures/rar13/CMULTI.TXT | 1 + .../rars/tests/fixtures/rar13/CMULTIV.R00 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R01 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R02 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R03 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R04 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R05 | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/CMULTIV.R06 | Bin 0 -> 571 bytes .../rars/tests/fixtures/rar13/CMULTIV.RAR | Bin 0 -> 2000 bytes .../rars/tests/fixtures/rar13/COMMENT.RAR | Bin 0 -> 98 bytes .../rars/tests/fixtures/rar13/EMPTY.RAR | Bin 0 -> 37 bytes .../rars/tests/fixtures/rar13/FCOMM.RAR | Bin 0 -> 75 bytes .../rars/tests/fixtures/rar13/MULTIFIL.RAR | Bin 0 -> 106 bytes .../rars/tests/fixtures/rar13/MULTIVOL.R00 | Bin 0 -> 20000 bytes .../rars/tests/fixtures/rar13/MULTIVOL.R01 | Bin 0 -> 20000 bytes .../rars/tests/fixtures/rar13/MULTIVOL.R02 | Bin 0 -> 5688 bytes .../rars/tests/fixtures/rar13/MULTIVOL.RAR | Bin 0 -> 20000 bytes .../vendor/rars/tests/fixtures/rar13/README | 49 + .../tests/fixtures/rar13/README-solid-flag.md | 12 + .../rars/tests/fixtures/rar13/README.RAR | Bin 0 -> 1112 bytes .../rar13/README_password=password.rar | Bin 0 -> 1112 bytes .../tests/fixtures/rar13/README_store.rar | Bin 0 -> 2050 bytes .../rars/tests/fixtures/rar13/REPEATB.RAR | Bin 0 -> 337 bytes .../rars/tests/fixtures/rar13/SFXSRC.EXE | Bin 0 -> 6561 bytes .../rars/tests/fixtures/rar13/SOLID.RAR | Bin 0 -> 12789 bytes .../rars/tests/fixtures/rar13/STOREPWD.RAR | Bin 0 -> 65 bytes .../rars/tests/fixtures/rar13/WITHDIR.RAR | Bin 0 -> 87 bytes .../fixtures/rar13/encrypted_split/ESPLIT.R00 | Bin 0 -> 2000 bytes .../fixtures/rar13/encrypted_split/ESPLIT.R01 | Bin 0 -> 923 bytes .../fixtures/rar13/encrypted_split/ESPLIT.RAR | Bin 0 -> 2000 bytes .../fixtures/rar13/encrypted_split/README.md | 9 + .../rar13/rar140_av/rar140_av_patched.rar | Bin 0 -> 91 bytes .../rar13/rar140_av/rar140_noav_baseline.rar | Bin 0 -> 45 bytes .../fixtures/rar13/solid_flag_cleared.rar | Bin 0 -> 159 bytes .../rar15_40/README-crafted-legacy.md | 37 + .../empty_compressed_payload_rar30.rar | Bin 0 -> 61 bytes .../fixtures/rar15_40/encrypted/README.md | 16 + .../rar15_40/encrypted/header_enc_1234.rar | Bin 0 -> 356 bytes .../encrypted/header_rar300_password.rar | Bin 0 -> 164 bytes .../encrypted/header_rar420_password.rar | Bin 0 -> 164 bytes .../encrypted/per_file_rar300_password.rar | Bin 0 -> 124 bytes .../per_file_rar4_libarchive_mixed.rar | Bin 0 -> 311 bytes ..._junrar_file_content_encrypted_unicode.rar | Bin 0 -> 122 bytes .../rar4_junrar_header_encrypted.rar | Bin 0 -> 148 bytes .../encrypted/rar4_junrar_password.rar | Bin 0 -> 110 bytes .../rar4_mixed_visible_names_password.rar | Bin 0 -> 287 bytes .../rar4_sharpcompress_files_only.rar | Bin 0 -> 60069 bytes .../fixtures/rar15_40/node_unrar_js/README.md | 12 + .../rar15_40/node_unrar_js/with_comment.rar | Bin 0 -> 288 bytes .../tests/fixtures/rar15_40/ppmd/README.md | 21 + .../fixtures/rar15_40/ppmd/binary_64k.bin | Bin 0 -> 65536 bytes .../fixtures/rar15_40/ppmd/escape_64k.bin | 1338 +++ .../fixtures/rar15_40/ppmd/farmanager170.rar | Bin 0 -> 996166 bytes .../fixtures/rar15_40/ppmd/lorem_127k.txt | 1 + .../rar15_40/ppmd/ppmd_escape_rar300.rar | Bin 0 -> 408 bytes .../rar15_40/ppmd/ppmd_lorem_rar300.rar | Bin 0 -> 13349 bytes .../fixtures/rar15_40/ppmd/ppmd_lz_match.txt | 257 + .../rar15_40/ppmd/ppmd_lz_match_rar300.rar | Bin 0 -> 275 bytes .../rar15_40/ppmd/ppmd_lz_repeat_rar3.cbr | Bin 0 -> 381 bytes .../rar15_40/ppmd/ppmd_mixed_rar300.rar | Bin 0 -> 78931 bytes .../rar15_40/ppmd/ppmd_solid_rar300.rar | Bin 0 -> 19925 bytes .../fixtures/rar15_40/ppmd/solid_lorem_a.txt | 1 + .../fixtures/rar15_40/ppmd/solid_lorem_b.txt | 1 + .../tests/fixtures/rar15_40/rar154/README.md | 17 + .../rar154/audio_dos_names_unpack15.rar | Bin 0 -> 42948 bytes .../rar154/audio_win_names_unpack15.rar | Bin 0 -> 42964 bytes .../fixtures/rar15_40/rar154/doc_154_best.rar | Bin 0 -> 189390 bytes .../rar15_40/rar154/expected/README.md | 65 + .../tests/fixtures/rar15_40/rar154/random.r00 | Bin 0 -> 730112 bytes .../tests/fixtures/rar15_40/rar154/random.r01 | Bin 0 -> 639168 bytes .../tests/fixtures/rar15_40/rar154/random.rar | Bin 0 -> 730112 bytes .../rar15_40/rar154/readme_154_normal.rar | Bin 0 -> 2129 bytes .../rar15_40/rar154/readme_154_password.rar | Bin 0 -> 2129 bytes .../rar154/readme_154_store_solid.rar | Bin 0 -> 2129 bytes .../tests/fixtures/rar15_40/rar202/README.md | 28 + .../rar15_40/rar202/comment_nopsw.rar | Bin 0 -> 204 bytes .../fixtures/rar15_40/rar202/comment_psw.rar | Bin 0 -> 254 bytes .../tests/fixtures/rar15_40/rar250/AUDIO.RAR | Bin 0 -> 2000 bytes .../fixtures/rar15_40/rar250/AUTOREJ.RAR | Bin 0 -> 115 bytes .../tests/fixtures/rar15_40/rar250/BIGLZ.RAR | Bin 0 -> 4459 bytes .../tests/fixtures/rar15_40/rar250/README.md | 31 + .../tests/fixtures/rar15_40/rar250/SOLID.RAR | Bin 0 -> 281 bytes .../rar15_40/rar250/unpack20_audio_text.rar | Bin 0 -> 28125 bytes .../rar15_40/rar250/unpack20_keep_tables.rar | Bin 0 -> 25262 bytes .../rar15_40/rar250/unpack20_multiblock.rar | Bin 0 -> 4827 bytes .../rar15_40/rar250_protect_head_rr1.rar | Bin 0 -> 651 bytes .../rar15_40/rar250_protect_head_rr5.rar | Bin 0 -> 105447 bytes .../tests/fixtures/rar15_40/rar300/README.md | 22 + .../fixtures/rar15_40/rar300/bigtext_64k.bin | 1 + .../compressed_multivol_prng_rar300.r00 | Bin 0 -> 1000 bytes .../compressed_multivol_prng_rar300.r01 | Bin 0 -> 1000 bytes .../compressed_multivol_prng_rar300.r02 | Bin 0 -> 1000 bytes .../compressed_multivol_prng_rar300.r03 | Bin 0 -> 502 bytes .../compressed_multivol_prng_rar300.rar | Bin 0 -> 1000 bytes .../rar300/compressed_text_rar300.rar | Bin 0 -> 125 bytes .../rar300/encrypted_multivol_rar300.r00 | Bin 0 -> 1732 bytes .../rar300/encrypted_multivol_rar300.rar | Bin 0 -> 8192 bytes .../encrypted_newnaming_rar300.part01.rar | Bin 0 -> 8192 bytes .../encrypted_newnaming_rar300.part02.rar | Bin 0 -> 1732 bytes .../header_encrypted_multivol_rar300.r00 | Bin 0 -> 1800 bytes .../header_encrypted_multivol_rar300.rar | Bin 0 -> 8192 bytes ...ader_encrypted_newnaming_rar300.part01.rar | Bin 0 -> 8192 bytes ...ader_encrypted_newnaming_rar300.part02.rar | Bin 0 -> 1800 bytes .../multivol_newnaming_rar300.part01.rar | Bin 0 -> 8192 bytes .../multivol_newnaming_rar300.part02.rar | Bin 0 -> 1708 bytes .../rar300/multivol_oldnaming_rar300.r00 | Bin 0 -> 1708 bytes .../rar300/multivol_oldnaming_rar300.rar | Bin 0 -> 8192 bytes .../rar300/rarvm_audio_stereo_rar300.rar | Bin 0 -> 15767 bytes .../rar300/rarvm_delta_4ch_rar300.rar | Bin 0 -> 795 bytes .../rar300/rarvm_itanium_synthetic_rar300.rar | Bin 0 -> 3064 bytes .../rar300/rarvm_rgb_gradient_rar300.rar | Bin 0 -> 896 bytes .../rar15_40/rar300/rarvm_x86_e8_rar300.rar | Bin 0 -> 543 bytes .../rar15_40/rar300/rarvm_x86_e8e9_rar300.rar | Bin 0 -> 584 bytes .../rar15_40/rar300/rev_newstyle.part1.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_newstyle.part1.rev | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_newstyle.part2.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_newstyle.part2.rev | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_newstyle.part3.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_newstyle.part4.rar | Bin 0 -> 296 bytes .../rar15_40/rar300/rev_oldstyle.part1.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_oldstyle.part2.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_oldstyle.part3.rar | Bin 0 -> 2048 bytes .../rar15_40/rar300/rev_oldstyle.part4.rar | Bin 0 -> 224 bytes .../rar300/rev_oldstyle.part4_2_1.rev | Bin 0 -> 2048 bytes .../rar300/rev_oldstyle.part4_2_2.rev | Bin 0 -> 2048 bytes .../fixtures/rar15_40/rar300/solid_rar300.rar | Bin 0 -> 9956 bytes .../rar15_40/rar300/solid_simple_rar300.rar | Bin 0 -> 153 bytes .../rar300/stored_multivol_rar300.r00 | Bin 0 -> 1000 bytes .../rar300/stored_multivol_rar300.r01 | Bin 0 -> 1000 bytes .../rar300/stored_multivol_rar300.r02 | Bin 0 -> 664 bytes .../rar300/stored_multivol_rar300.rar | Bin 0 -> 1000 bytes .../rar15_40/rar300/with_comment_rar300.rar | Bin 0 -> 175 bytes ...h_compressed_recovery_header_synthetic.rar | Bin 0 -> 15552 bytes .../with_compressed_recovery_rar300.rar | Bin 0 -> 16324 bytes .../rar15_40/rar300/with_recovery_rar300.rar | Bin 0 -> 15552 bytes .../tests/fixtures/rar15_40/rar420/README.md | 12 + .../rar15_40/rar420/ext_time_rar420.rar | Bin 0 -> 103 bytes .../rar15_40/rars_generated/README.md | 15 + .../rar15_40/rars_generated/comments.rar | Bin 0 -> 133 bytes .../rar15_40/rars_generated/compressed.rar | Bin 0 -> 87 bytes .../rar15_40/rars_generated/encrypted.rar | Bin 0 -> 87 bytes .../rar15_40/rars_generated/solid.rar | Bin 0 -> 153 bytes .../rars_generated/split-encrypted.r00 | Bin 0 -> 73 bytes .../rars_generated/split-encrypted.r01 | Bin 0 -> 67 bytes .../rars_generated/split-encrypted.rar | Bin 0 -> 73 bytes .../rar15_40/rars_generated/split-store.r00 | Bin 0 -> 73 bytes .../rar15_40/rars_generated/split-store.r01 | Bin 0 -> 64 bytes .../rar15_40/rars_generated/split-store.rar | Bin 0 -> 73 bytes .../rar15_40/rars_generated/stored.rar | Bin 0 -> 84 bytes .../tests/fixtures/rar15_40/rarvm/README.md | 29 + .../rar15_40/rarvm/delta_64_channels.rar | Bin 0 -> 424 bytes .../rar15_40/rarvm/filter_bsdcat_exe.rar | Bin 0 -> 94301 bytes .../rarvm/generic_delta_padding_mutation.rar | Bin 0 -> 3064 bytes .../rarvm/ppmd_embedded_vm_filter.rar | Bin 0 -> 3429 bytes .../rar15_40/rarvm/solid_e8_filter_lead.txt | 16 + .../rarvm/solid_e8_filter_member_offset.rar | Bin 0 -> 483 bytes .../rarvm/solid_e8_filter_payload.exe | Bin 0 -> 5884 bytes .../rar15_40/rarvm/vm_encoded_u32_filter.rar | Bin 0 -> 94301 bytes .../rar15_40/solid_flag_cleared_rar15.rar | Bin 0 -> 197 bytes .../fixtures/rar15_40/zero_fill/README.md | 14 + .../fixtures/rar15_40/zero_fill/rar20.rar | Bin 0 -> 114 bytes .../fixtures/rar15_40/zero_fill/rar29.rar | Bin 0 -> 116 bytes .../fixtures/rar15_40/zero_head_size.rar | Bin 0 -> 197 bytes .../rar50/README-crafted-rejections.md | 33 + .../fixtures/rar50/README-hash-precedence.md | 15 + ...README-header-encrypted-stored-multivol.md | 13 + .../rar50/README-subdata-underflow.md | 17 + .../tests/fixtures/rar50/README-zero-fill.md | 13 + .../rar50/README-zeroed-password-check.md | 24 + .../fixtures/rar50/algorithm_version_2.rar | Bin 0 -> 2943 bytes .../rar50/algorithm_version_2_stored.rar | Bin 0 -> 103 bytes .../rar50/ams_archive_name_rar721.rar | Bin 0 -> 175 bytes .../rar50/crc32_wrong_beside_blake2sp.rar | Bin 0 -> 138 bytes .../rars/tests/fixtures/rar50/empty_file.rar | Bin 0 -> 104 bytes .../rar50/encrypted_multivol.part1.rar | Bin 0 -> 2048 bytes .../rar50/encrypted_multivol.part2.rar | Bin 0 -> 2048 bytes .../rar50/encrypted_multivol.part3.rar | Bin 0 -> 866 bytes .../rars/tests/fixtures/rar50/filter_arm.rar | Bin 0 -> 3639 bytes .../tests/fixtures/rar50/filter_delta.rar | Bin 0 -> 717 bytes .../rars/tests/fixtures/rar50/filter_e8.rar | Bin 0 -> 891 bytes .../rars/tests/fixtures/rar50/filter_e8e9.rar | Bin 0 -> 899 bytes .../rar50/first_block_without_tables.rar | Bin 0 -> 2943 bytes .../tests/fixtures/rar50/header_encrypted.rar | Bin 0 -> 302 bytes .../rar50/header_encrypted_comment.rar | Bin 0 -> 462 bytes ...header_encrypted_stored_multivol.part1.rar | Bin 0 -> 2048 bytes ...header_encrypted_stored_multivol.part2.rar | Bin 0 -> 2048 bytes ...header_encrypted_stored_multivol.part3.rar | Bin 0 -> 1262 bytes .../rars/tests/fixtures/rar50/m1_fastest.rar | Bin 0 -> 12582 bytes .../rars/tests/fixtures/rar50/m3_default.rar | Bin 0 -> 10007 bytes .../rars/tests/fixtures/rar50/m5_max.rar | Bin 0 -> 9922 bytes .../rars/tests/fixtures/rar50/multifile.rar | Bin 0 -> 4389 bytes .../tests/fixtures/rar50/multivol.part1.rar | Bin 0 -> 2048 bytes .../tests/fixtures/rar50/multivol.part2.rar | Bin 0 -> 2048 bytes .../tests/fixtures/rar50/multivol.part3.rar | Bin 0 -> 609 bytes .../fixtures/rar50/multivol_rev.part1.rar | Bin 0 -> 4096 bytes .../fixtures/rar50/multivol_rev.part1.rev | Bin 0 -> 4183 bytes .../fixtures/rar50/multivol_rev.part2.rar | Bin 0 -> 4096 bytes .../fixtures/rar50/multivol_rev.part2.rev | Bin 0 -> 4183 bytes .../fixtures/rar50/multivol_rev.part3.rar | Bin 0 -> 4096 bytes .../fixtures/rar50/multivol_rev.part4.rar | Bin 0 -> 4096 bytes .../fixtures/rar50/multivol_rev.part5.rar | Bin 0 -> 1032 bytes .../tests/fixtures/rar50/password_aes.rar | Bin 0 -> 201 bytes .../tests/fixtures/rar50/password_crc32.rar | Bin 0 -> 170 bytes .../rar50/plaintext_stored_multivol.part2.rar | Bin 0 -> 2048 bytes .../rars/tests/fixtures/rar50/solid.rar | Bin 0 -> 228 bytes .../fixtures/rar50/solid_multivol.part01.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/solid_multivol.part02.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/solid_multivol.part03.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/solid_multivol.part04.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/solid_multivol.part05.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/solid_multivol.part06.rar | Bin 0 -> 910 bytes .../rars/tests/fixtures/rar50/stored.rar | Bin 0 -> 103 bytes .../tests/fixtures/rar50/stored_blake2.rar | Bin 0 -> 134 bytes .../fixtures/rar50/stored_multivol.part1.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/stored_multivol.part2.rar | Bin 0 -> 2048 bytes .../fixtures/rar50/stored_multivol.part3.rar | Bin 0 -> 557 bytes .../fixtures/rar50/subdata_size_underflow.rar | Bin 0 -> 370 bytes .../tests/fixtures/rar50/wild/hardlink.rar | Bin 0 -> 122 bytes .../wild/invalid_hash_valid_htime_exfld.rar | Bin 0 -> 120 bytes .../rar50/wild/libarchive_loop_bug.rar | Bin 0 -> 8346 bytes .../wild/libarchive_multiple_files_solid.rar | Bin 0 -> 677 bytes .../fixtures/rar50/wild/libarchive_solid.rar | Bin 0 -> 1050 bytes .../fixtures/rar50/wild/rarfile_hlink.rar | Bin 0 -> 230 bytes .../fixtures/rar50/wild/rarfile_solid.rar | Bin 0 -> 169 bytes .../fixtures/rar50/wild/rarfile_solid_qo.rar | Bin 0 -> 508 bytes .../tests/fixtures/rar50/wild/symlink.rar | Bin 0 -> 190 bytes .../winrar721_header_encrypted_quickopen.rar | Bin 0 -> 8702 bytes .../fixtures/rar50/with_all_services.rar | Bin 0 -> 1002 bytes .../tests/fixtures/rar50/with_comment.rar | Bin 0 -> 188 bytes .../tests/fixtures/rar50/with_quickopen.rar | Bin 0 -> 396 bytes .../tests/fixtures/rar50/with_recovery.rar | Bin 0 -> 370 bytes .../rar50/zero_fill_out_of_window.rar | Bin 0 -> 148 bytes .../fixtures/rar50/zeroed_password_check.rar | Bin 0 -> 211 bytes .../rars/tests/fixtures/tz/America_New_York | Bin 0 -> 3552 bytes .../rars/tests/fixtures/tz/Asia_Kolkata | Bin 0 -> 285 bytes .../tests/fixtures/tz/Australia_Lord_Howe | Bin 0 -> 1846 bytes .../vendor/rars/tests/fixtures/tz/Etc_GMT_5 | Bin 0 -> 116 bytes .../rars/tests/fixtures/tz/Europe_London | Bin 0 -> 3664 bytes .../rars/tests/legacy_builder_sources.rs | 340 + .../rars/tests/legacy_codec_adapters.rs | 263 + .../vendor/rars/tests/legacy_name_encoding.rs | 218 + .../rars/tests/legacy_parallel_retention.rs | 143 + .../rars/tests/legacy_writer_cancellation.rs | 398 + .../vendor/rars/tests/legacy_writer_errors.rs | 944 ++ .../vendor/rars/tests/member_selection.rs | 527 ++ .../vendor/rars/tests/ppmd_regressions.rs | 93 + arca-rar/vendor/rars/tests/rar13_fixtures.rs | 875 ++ .../vendor/rars/tests/rar15_40_fixtures.rs | 8370 +++++++++++++++++ arca-rar/vendor/rars/tests/rar50_fixtures.rs | 6699 +++++++++++++ arca-rar/vendor/rars/tests/rar50_golden.rs | 243 + .../vendor/rars/tests/rar50_split_limits.rs | 180 + .../vendor/rars/tests/rarvm_regressions.rs | 152 + .../vendor/rars/tests/reader_32bit_lengths.rs | 91 + .../vendor/rars/tests/reader_cancellation.rs | 364 + .../rars/tests/reader_dictionary_limit.rs | 136 + .../rars/tests/reader_failure_output.rs | 140 + .../vendor/rars/tests/reader_failure_paths.rs | 506 + .../vendor/rars/tests/reader_header_limits.rs | 366 + .../vendor/rars/tests/reader_output_limit.rs | 861 ++ arca-rar/vendor/rars/tests/reader_scratch.rs | 344 + .../vendor/rars/tests/reader_signatures.rs | 261 + arca-rar/vendor/rars/tests/reader_source.rs | 222 + .../rars/tests/reader_stored_lengths.rs | 151 + .../vendor/rars/tests/reader_verification.rs | 644 ++ .../vendor/rars/tests/reader_workspace.rs | 309 + .../vendor/rars/tests/repair_cancellation.rs | 107 + .../vendor/rars/tests/rewrite_settings.rs | 933 ++ arca-rar/vendor/rars/tests/rewrite_staging.rs | 788 ++ .../vendor/rars/tests/source_consistency.rs | 362 + .../vendor/rars/tests/support/read_errors.rs | 37 + arca-rar/vendor/rars/tests/support/scratch.rs | 152 + arca-rar/vendor/rars/tests/write_progress.rs | 446 + .../rars/tests/writer_aggregate_limit.rs | 161 + .../rars/tests/writer_preparation_limit.rs | 193 + .../vendor/rars/tests/writer_spool_limit.rs | 398 + 421 files changed, 143513 insertions(+), 3 deletions(-) create mode 100644 arca-rar/vendor/rars/.gitattributes create mode 100644 arca-rar/vendor/rars/COPYING create mode 100644 arca-rar/vendor/rars/Cargo.toml create mode 100644 arca-rar/vendor/rars/README.md create mode 100644 arca-rar/vendor/rars/src/atomic64.rs create mode 100644 arca-rar/vendor/rars/src/builder.rs create mode 100644 arca-rar/vendor/rars/src/codec/canonical.rs create mode 100644 arca-rar/vendor/rars/src/codec/fast.rs create mode 100644 arca-rar/vendor/rars/src/codec/filters.rs create mode 100644 arca-rar/vendor/rars/src/codec/huffman.rs create mode 100644 arca-rar/vendor/rars/src/codec/match_finder.rs create mode 100644 arca-rar/vendor/rars/src/codec/mod.rs create mode 100644 arca-rar/vendor/rars/src/codec/ppmd.rs create mode 100644 arca-rar/vendor/rars/src/codec/ppmd/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar13.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar13/encoder.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar13/solid_regressions.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar13/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar20.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar20/encoder.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar20/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar29.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar29/encoder.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar29/standard_filters.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar29/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/bit_reader_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/checkpoint_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/convergence_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/encoder.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/history_retention_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/huffman_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/literal_pricing_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/pricing_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/streaming_copy_tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rar50/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/rarvm.rs create mode 100644 arca-rar/vendor/rars/src/codec/rarvm/tests.rs create mode 100644 arca-rar/vendor/rars/src/codec/workspace.rs create mode 100644 arca-rar/vendor/rars/src/codec/workspace/coordinator.rs create mode 100644 arca-rar/vendor/rars/src/codec/workspace/ledger.rs create mode 100644 arca-rar/vendor/rars/src/crc32/mod.rs create mode 100644 arca-rar/vendor/rars/src/crypto/mod.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar13.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar15.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar20.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar20/implementation.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar30.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar30/implementation.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar50.rs create mode 100644 arca-rar/vendor/rars/src/crypto/rar50/implementation.rs create mode 100644 arca-rar/vendor/rars/src/crypto/unavailable.rs create mode 100644 arca-rar/vendor/rars/src/detect.rs create mode 100644 arca-rar/vendor/rars/src/entropy.rs create mode 100644 arca-rar/vendor/rars/src/error.rs create mode 100644 arca-rar/vendor/rars/src/extraction_control.rs create mode 100644 arca-rar/vendor/rars/src/features.rs create mode 100644 arca-rar/vendor/rars/src/file_times.rs create mode 100644 arca-rar/vendor/rars/src/filename.rs create mode 100644 arca-rar/vendor/rars/src/filter.rs create mode 100644 arca-rar/vendor/rars/src/filter_search.rs create mode 100644 arca-rar/vendor/rars/src/io_util.rs create mode 100644 arca-rar/vendor/rars/src/lib.rs create mode 100644 arca-rar/vendor/rars/src/member.rs create mode 100644 arca-rar/vendor/rars/src/member_read.rs create mode 100644 arca-rar/vendor/rars/src/output_limit.rs create mode 100644 arca-rar/vendor/rars/src/parallel.rs create mode 100644 arca-rar/vendor/rars/src/parse_budget.rs create mode 100644 arca-rar/vendor/rars/src/pending_archive.rs create mode 100644 arca-rar/vendor/rars/src/progress.rs create mode 100644 arca-rar/vendor/rars/src/rar13.rs create mode 100644 arca-rar/vendor/rars/src/rar13/write.rs create mode 100644 arca-rar/vendor/rars/src/rar15_40.rs create mode 100644 arca-rar/vendor/rars/src/rar15_40/extract.rs create mode 100644 arca-rar/vendor/rars/src/rar15_40/write.rs create mode 100644 arca-rar/vendor/rars/src/rar50.rs create mode 100644 arca-rar/vendor/rars/src/rar50/blake2sp.rs create mode 100644 arca-rar/vendor/rars/src/rar50/extract.rs create mode 100644 arca-rar/vendor/rars/src/rar50/framing.rs create mode 100644 arca-rar/vendor/rars/src/rar50/independent_history_tests.rs create mode 100644 arca-rar/vendor/rars/src/rar50/scratch.rs create mode 100644 arca-rar/vendor/rars/src/rar50/streaming_checks_tests.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/compress.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/engine.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/filter_policy.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/headers.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/layout.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/mod.rs create mode 100644 arca-rar/vendor/rars/src/rar50/write/plan.rs create mode 100644 arca-rar/vendor/rars/src/read_control.rs create mode 100644 arca-rar/vendor/rars/src/reader_scratch.rs create mode 100644 arca-rar/vendor/rars/src/reader_signature_tests.rs create mode 100644 arca-rar/vendor/rars/src/recovery/mod.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar3.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar3/errors.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar3/implementation.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar5.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar5/checksum.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar5/errors.rs create mode 100644 arca-rar/vendor/rars/src/recovery/rar5/implementation.rs create mode 100644 arca-rar/vendor/rars/src/rewrite.rs create mode 100644 arca-rar/vendor/rars/src/rewrite_staging.rs create mode 100644 arca-rar/vendor/rars/src/rewrite_staging/pipeline.rs create mode 100644 arca-rar/vendor/rars/src/source.rs create mode 100644 arca-rar/vendor/rars/src/streaming.rs create mode 100644 arca-rar/vendor/rars/src/streaming/memory_spool.rs create mode 100644 arca-rar/vendor/rars/src/streaming/output.rs create mode 100644 arca-rar/vendor/rars/src/streaming/preparation.rs create mode 100644 arca-rar/vendor/rars/src/temp_file.rs create mode 100644 arca-rar/vendor/rars/src/test_features.rs create mode 100644 arca-rar/vendor/rars/src/timestamp.rs create mode 100644 arca-rar/vendor/rars/src/tzif.rs create mode 100644 arca-rar/vendor/rars/src/version.rs create mode 100644 arca-rar/vendor/rars/src/volume_extract.rs create mode 100644 arca-rar/vendor/rars/src/write_plan.rs create mode 100644 arca-rar/vendor/rars/src/write_progress.rs create mode 100644 arca-rar/vendor/rars/src/write_stream.rs create mode 100644 arca-rar/vendor/rars/src/writer_option.rs create mode 100644 arca-rar/vendor/rars/src/x86_filter_scan.rs create mode 100644 arca-rar/vendor/rars/tests/builder_directories.rs create mode 100644 arca-rar/vendor/rars/tests/builder_file_comments.rs create mode 100644 arca-rar/vendor/rars/tests/builder_identity.rs create mode 100644 arca-rar/vendor/rars/tests/builder_metadata.rs create mode 100644 arca-rar/vendor/rars/tests/builder_output.rs create mode 100644 arca-rar/vendor/rars/tests/builder_symlinks.rs create mode 100644 arca-rar/vendor/rars/tests/builder_timestamps.rs create mode 100644 arca-rar/vendor/rars/tests/comment_options.rs create mode 100644 arca-rar/vendor/rars/tests/crypto_api.rs create mode 100644 arca-rar/vendor/rars/tests/extraction_control.rs create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_comment.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_comment_metadata.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_quick_open.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_rar50.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_rar70.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_10.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_5.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_50.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_large.sha256 create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_0.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/BIG80K.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTI.TXT create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R02 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R03 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R04 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R05 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R06 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/COMMENT.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/EMPTY.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/FCOMM.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/MULTIFIL.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R02 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/README create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/README-solid-flag.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/README.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/README_password=password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/README_store.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/REPEATB.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/SFXSRC.EXE create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/SOLID.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/STOREPWD.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/WITHDIR.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/rar140_av/rar140_av_patched.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/rar140_av/rar140_noav_baseline.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar13/solid_flag_cleared.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/README-crafted-legacy.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/empty_compressed_payload_rar30.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_enc_1234.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_rar300_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_rar420_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar300_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar4_libarchive_mixed.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_file_content_encrypted_unicode.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_header_encrypted.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_mixed_visible_names_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_sharpcompress_files_only.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/node_unrar_js/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/node_unrar_js/with_comment.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/binary_64k.bin create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/escape_64k.bin create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/farmanager170.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/lorem_127k.txt create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_escape_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lorem_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match.txt create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_repeat_rar3.cbr create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_mixed_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_solid_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_a.txt create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_b.txt create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_dos_names_unpack15.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_win_names_unpack15.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/doc_154_best.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/expected/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.r01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/readme_154_normal.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/readme_154_password.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/readme_154_store_solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar202/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar202/comment_nopsw.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar202/comment_psw.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/AUDIO.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/AUTOREJ.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/BIGLZ.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/SOLID.RAR create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/unpack20_audio_text.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/unpack20_keep_tables.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250/unpack20_multiblock.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250_protect_head_rr1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar250_protect_head_rr5.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/bigtext_64k.bin create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_multivol_prng_rar300.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_multivol_prng_rar300.r01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_multivol_prng_rar300.r02 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_multivol_prng_rar300.r03 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_multivol_prng_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/compressed_text_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/encrypted_multivol_rar300.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/encrypted_multivol_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/encrypted_newnaming_rar300.part01.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/encrypted_newnaming_rar300.part02.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/header_encrypted_multivol_rar300.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/header_encrypted_multivol_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/header_encrypted_newnaming_rar300.part01.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/header_encrypted_newnaming_rar300.part02.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/multivol_newnaming_rar300.part01.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/multivol_newnaming_rar300.part02.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/multivol_oldnaming_rar300.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/multivol_oldnaming_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_audio_stereo_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_delta_4ch_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_itanium_synthetic_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_rgb_gradient_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_x86_e8_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rarvm_x86_e8e9_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part1.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part2.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_newstyle.part4.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part4.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part4_2_1.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/rev_oldstyle.part4_2_2.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/solid_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/solid_simple_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/stored_multivol_rar300.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/stored_multivol_rar300.r01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/stored_multivol_rar300.r02 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/stored_multivol_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/with_comment_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/with_compressed_recovery_header_synthetic.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/with_compressed_recovery_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar300/with_recovery_rar300.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar420/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rar420/ext_time_rar420.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/comments.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/compressed.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/encrypted.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-encrypted.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-encrypted.r01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-encrypted.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-store.r00 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-store.r01 create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/split-store.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rars_generated/stored.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/delta_64_channels.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/filter_bsdcat_exe.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/generic_delta_padding_mutation.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/ppmd_embedded_vm_filter.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/solid_e8_filter_lead.txt create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/solid_e8_filter_member_offset.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/solid_e8_filter_payload.exe create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/rarvm/vm_encoded_u32_filter.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/solid_flag_cleared_rar15.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/zero_fill/README.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/zero_fill/rar20.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/zero_fill/rar29.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar15_40/zero_head_size.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-crafted-rejections.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-hash-precedence.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-header-encrypted-stored-multivol.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-subdata-underflow.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-zero-fill.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/README-zeroed-password-check.md create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/algorithm_version_2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/algorithm_version_2_stored.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/ams_archive_name_rar721.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/crc32_wrong_beside_blake2sp.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/empty_file.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/encrypted_multivol.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/encrypted_multivol.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/encrypted_multivol.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/filter_arm.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/filter_delta.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/filter_e8.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/filter_e8e9.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/first_block_without_tables.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/header_encrypted.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/header_encrypted_comment.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/header_encrypted_stored_multivol.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/header_encrypted_stored_multivol.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/header_encrypted_stored_multivol.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/m1_fastest.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/m3_default.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/m5_max.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multifile.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part1.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part2.rev create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part4.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/multivol_rev.part5.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/password_aes.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/password_crc32.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/plaintext_stored_multivol.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part01.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part02.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part03.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part04.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part05.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/solid_multivol.part06.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/stored.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/stored_blake2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/stored_multivol.part1.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/stored_multivol.part2.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/stored_multivol.part3.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/subdata_size_underflow.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/hardlink.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/invalid_hash_valid_htime_exfld.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/libarchive_loop_bug.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/libarchive_multiple_files_solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/libarchive_solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/rarfile_hlink.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/rarfile_solid.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/rarfile_solid_qo.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/wild/symlink.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/winrar721_header_encrypted_quickopen.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/with_all_services.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/with_comment.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/with_quickopen.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/with_recovery.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/zero_fill_out_of_window.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/rar50/zeroed_password_check.rar create mode 100644 arca-rar/vendor/rars/tests/fixtures/tz/America_New_York create mode 100644 arca-rar/vendor/rars/tests/fixtures/tz/Asia_Kolkata create mode 100644 arca-rar/vendor/rars/tests/fixtures/tz/Australia_Lord_Howe create mode 100644 arca-rar/vendor/rars/tests/fixtures/tz/Etc_GMT_5 create mode 100644 arca-rar/vendor/rars/tests/fixtures/tz/Europe_London create mode 100644 arca-rar/vendor/rars/tests/legacy_builder_sources.rs create mode 100644 arca-rar/vendor/rars/tests/legacy_codec_adapters.rs create mode 100644 arca-rar/vendor/rars/tests/legacy_name_encoding.rs create mode 100644 arca-rar/vendor/rars/tests/legacy_parallel_retention.rs create mode 100644 arca-rar/vendor/rars/tests/legacy_writer_cancellation.rs create mode 100644 arca-rar/vendor/rars/tests/legacy_writer_errors.rs create mode 100644 arca-rar/vendor/rars/tests/member_selection.rs create mode 100644 arca-rar/vendor/rars/tests/ppmd_regressions.rs create mode 100644 arca-rar/vendor/rars/tests/rar13_fixtures.rs create mode 100644 arca-rar/vendor/rars/tests/rar15_40_fixtures.rs create mode 100644 arca-rar/vendor/rars/tests/rar50_fixtures.rs create mode 100644 arca-rar/vendor/rars/tests/rar50_golden.rs create mode 100644 arca-rar/vendor/rars/tests/rar50_split_limits.rs create mode 100644 arca-rar/vendor/rars/tests/rarvm_regressions.rs create mode 100644 arca-rar/vendor/rars/tests/reader_32bit_lengths.rs create mode 100644 arca-rar/vendor/rars/tests/reader_cancellation.rs create mode 100644 arca-rar/vendor/rars/tests/reader_dictionary_limit.rs create mode 100644 arca-rar/vendor/rars/tests/reader_failure_output.rs create mode 100644 arca-rar/vendor/rars/tests/reader_failure_paths.rs create mode 100644 arca-rar/vendor/rars/tests/reader_header_limits.rs create mode 100644 arca-rar/vendor/rars/tests/reader_output_limit.rs create mode 100644 arca-rar/vendor/rars/tests/reader_scratch.rs create mode 100644 arca-rar/vendor/rars/tests/reader_signatures.rs create mode 100644 arca-rar/vendor/rars/tests/reader_source.rs create mode 100644 arca-rar/vendor/rars/tests/reader_stored_lengths.rs create mode 100644 arca-rar/vendor/rars/tests/reader_verification.rs create mode 100644 arca-rar/vendor/rars/tests/reader_workspace.rs create mode 100644 arca-rar/vendor/rars/tests/repair_cancellation.rs create mode 100644 arca-rar/vendor/rars/tests/rewrite_settings.rs create mode 100644 arca-rar/vendor/rars/tests/rewrite_staging.rs create mode 100644 arca-rar/vendor/rars/tests/source_consistency.rs create mode 100644 arca-rar/vendor/rars/tests/support/read_errors.rs create mode 100644 arca-rar/vendor/rars/tests/support/scratch.rs create mode 100644 arca-rar/vendor/rars/tests/write_progress.rs create mode 100644 arca-rar/vendor/rars/tests/writer_aggregate_limit.rs create mode 100644 arca-rar/vendor/rars/tests/writer_preparation_limit.rs create mode 100644 arca-rar/vendor/rars/tests/writer_spool_limit.rs diff --git a/Cargo.lock b/Cargo.lock index 96ccd435..454f5d48 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3063,13 +3063,12 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" [[package]] name = "rars" version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0665518097392be04a322dec9eba41e88028f6aca85f5d61f8abb068691f2266" dependencies = [ "aes", "aho-corasick", "getrandom 0.4.3", "hmac", + "rayon", "sha1", "sha2", "zeroize", diff --git a/Cargo.toml b/Cargo.toml index dce37126..a126d5ee 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,7 +19,7 @@ members = [ ] # Solo compila en Windows: se queda fuera del workspace para que # `cargo build` siga funcionando en Linux y macOS. -exclude = ["windows/arca-shell", "arca-7z/vendor/sevenz-rust2"] +exclude = ["windows/arca-shell", "arca-7z/vendor/sevenz-rust2", "arca-rar/vendor/rars"] [workspace.package] version = "0.10.0" @@ -80,3 +80,4 @@ inherits = "release" [patch.crates-io] sevenz-rust2 = { path = "arca-7z/vendor/sevenz-rust2" } +rars = { path = "arca-rar/vendor/rars" } diff --git a/arca-rar/vendor/rars/.gitattributes b/arca-rar/vendor/rars/.gitattributes new file mode 100644 index 00000000..353faaa7 --- /dev/null +++ b/arca-rar/vendor/rars/.gitattributes @@ -0,0 +1,2 @@ +# Arca: the vendored crate is kept byte for byte as published. +* -text diff --git a/arca-rar/vendor/rars/COPYING b/arca-rar/vendor/rars/COPYING new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/arca-rar/vendor/rars/COPYING @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/arca-rar/vendor/rars/Cargo.toml b/arca-rar/vendor/rars/Cargo.toml new file mode 100644 index 00000000..c6223b8c --- /dev/null +++ b/arca-rar/vendor/rars/Cargo.toml @@ -0,0 +1,301 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +rust-version = "1.89" +name = "rars" +version = "0.10.2" +build = false +autolib = false +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = "High-level Rust API for reading, extracting, writing, and repairing RAR archives." +homepage = "https://github.com/bitplane/rars" +documentation = "https://docs.rs/rars" +readme = "README.md" +keywords = [ + "rar", + "archive", + "compression", +] +categories = ["compression"] +license = "Apache-2.0" +repository = "https://github.com/bitplane/rars" + +[package.metadata.docs.rs] +all-features = true + +[features] +default = [ + "write", + "parallel", + "recovery", + "encryption", +] +encryption = [ + "dep:aes", + "dep:hmac", + "dep:sha1", + "dep:sha2", + "dep:zeroize", +] +parallel = ["dep:rayon"] +recovery = ["dep:getrandom"] +write = ["dep:getrandom"] + +[lib] +name = "rars" +path = "src/lib.rs" + +[[test]] +name = "builder_directories" +path = "tests/builder_directories.rs" + +[[test]] +name = "builder_file_comments" +path = "tests/builder_file_comments.rs" + +[[test]] +name = "builder_identity" +path = "tests/builder_identity.rs" + +[[test]] +name = "builder_metadata" +path = "tests/builder_metadata.rs" + +[[test]] +name = "builder_output" +path = "tests/builder_output.rs" + +[[test]] +name = "builder_symlinks" +path = "tests/builder_symlinks.rs" + +[[test]] +name = "builder_timestamps" +path = "tests/builder_timestamps.rs" + +[[test]] +name = "comment_options" +path = "tests/comment_options.rs" + +[[test]] +name = "crypto_api" +path = "tests/crypto_api.rs" + +[[test]] +name = "extraction_control" +path = "tests/extraction_control.rs" + +[[test]] +name = "legacy_builder_sources" +path = "tests/legacy_builder_sources.rs" + +[[test]] +name = "legacy_codec_adapters" +path = "tests/legacy_codec_adapters.rs" + +[[test]] +name = "legacy_name_encoding" +path = "tests/legacy_name_encoding.rs" + +[[test]] +name = "legacy_parallel_retention" +path = "tests/legacy_parallel_retention.rs" + +[[test]] +name = "legacy_writer_cancellation" +path = "tests/legacy_writer_cancellation.rs" + +[[test]] +name = "legacy_writer_errors" +path = "tests/legacy_writer_errors.rs" + +[[test]] +name = "member_selection" +path = "tests/member_selection.rs" + +[[test]] +name = "ppmd_regressions" +path = "tests/ppmd_regressions.rs" + +[[test]] +name = "rar13_fixtures" +path = "tests/rar13_fixtures.rs" + +[[test]] +name = "rar15_40_fixtures" +path = "tests/rar15_40_fixtures.rs" + +[[test]] +name = "rar50_fixtures" +path = "tests/rar50_fixtures.rs" + +[[test]] +name = "rar50_golden" +path = "tests/rar50_golden.rs" + +[[test]] +name = "rar50_split_limits" +path = "tests/rar50_split_limits.rs" + +[[test]] +name = "rarvm_regressions" +path = "tests/rarvm_regressions.rs" + +[[test]] +name = "reader_32bit_lengths" +path = "tests/reader_32bit_lengths.rs" + +[[test]] +name = "reader_cancellation" +path = "tests/reader_cancellation.rs" + +[[test]] +name = "reader_dictionary_limit" +path = "tests/reader_dictionary_limit.rs" + +[[test]] +name = "reader_failure_output" +path = "tests/reader_failure_output.rs" + +[[test]] +name = "reader_failure_paths" +path = "tests/reader_failure_paths.rs" + +[[test]] +name = "reader_header_limits" +path = "tests/reader_header_limits.rs" + +[[test]] +name = "reader_output_limit" +path = "tests/reader_output_limit.rs" + +[[test]] +name = "reader_scratch" +path = "tests/reader_scratch.rs" + +[[test]] +name = "reader_signatures" +path = "tests/reader_signatures.rs" + +[[test]] +name = "reader_source" +path = "tests/reader_source.rs" + +[[test]] +name = "reader_stored_lengths" +path = "tests/reader_stored_lengths.rs" + +[[test]] +name = "reader_verification" +path = "tests/reader_verification.rs" + +[[test]] +name = "reader_workspace" +path = "tests/reader_workspace.rs" + +[[test]] +name = "repair_cancellation" +path = "tests/repair_cancellation.rs" + +[[test]] +name = "rewrite_settings" +path = "tests/rewrite_settings.rs" + +[[test]] +name = "rewrite_staging" +path = "tests/rewrite_staging.rs" + +[[test]] +name = "source_consistency" +path = "tests/source_consistency.rs" + +[[test]] +name = "write_progress" +path = "tests/write_progress.rs" + +[[test]] +name = "writer_aggregate_limit" +path = "tests/writer_aggregate_limit.rs" + +[[test]] +name = "writer_preparation_limit" +path = "tests/writer_preparation_limit.rs" + +[[test]] +name = "writer_spool_limit" +path = "tests/writer_spool_limit.rs" + +[dependencies.aes] +version = "0.9" +features = ["zeroize"] +optional = true + +[dependencies.aho-corasick] +version = "1.1" + +[dependencies.getrandom] +version = "0.4" +optional = true + +[dependencies.hmac] +version = "0.13" +optional = true + +[dependencies.sha1] +version = "0.11" +optional = true + +[dependencies.sha2] +version = "0.11" +optional = true + +[dependencies.zeroize] +version = "1.8" +features = [ + "alloc", + "zeroize_derive", +] +optional = true +default-features = false + +[dev-dependencies.criterion] +version = "0.8" +features = ["cargo_bench_support"] +default-features = false + +[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies.getrandom] +version = "0.4" +features = ["wasm_js"] +optional = true + +[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies.rayon] +version = "1.12.0" +optional = true + +[target."cfg(unix)".dev-dependencies.libc] +version = "0.2" + +[lints.clippy] +dbg_macro = "warn" +todo = "warn" +unimplemented = "warn" + +[lints.rust] +unsafe_code = "forbid" +unused_must_use = "deny" + +# Arca: tested on its own with --manifest-path, outside the workspace. +[workspace] diff --git a/arca-rar/vendor/rars/README.md b/arca-rar/vendor/rars/README.md new file mode 100644 index 00000000..b3e15eed --- /dev/null +++ b/arca-rar/vendor/rars/README.md @@ -0,0 +1,41 @@ +# rars + +A Rust implementation of RAR. + +* ðŸ�  [home](https://bitplane.net/dev/rust/rars) +* 📦 [downloads](https://github.com/bitplane/rars/releases) + * 🦀 [crates](https://crates.io/crates/rars) + * ðŸ�� [pypi](https://pypi.org/project/rars) + * 📜 [npm](https://www.npmjs.com/package/@bitplane/rars) +* ðŸ�± [source](https://github.com/bitplane/rars) + * 📃 [spec](https://github.com/bitplane/rar-research) + +`rars` is free software for compression, decompression and recovery of RAR +archives. It supports all the archive types I could find - from the early `RE~^` +ones from the DOS days all the way through to RAR 7. It comes with a Rust +library, a CLI, Python and TypeScript bindings. + +It started as an +[agentic development experiment](https://bitplane.net/log/2026/05/rars/), and +has since matured as it gained some users. It's still a bit slower than WinRAR, +uses more memory and has slightly worse compression. It could use more testing +at volume, too. Other than that it's in pretty good shape. + +## Install + +```sh +cargo install rars-cli # the CLI +cargo add rars # the Rust library +pip install rars # Python +npm install @bitplane/rars # JavaScript, as WebAssembly for Node or the browser +``` + +Then `rars --help`. For example: + +```sh +rars x archive.rar out/ +rars a --format rar29 --solid archive.rar files... +rars a --format rar70 --volume-size 10m archive.part1.rar files... +``` + +Licensed under the [Apache License, Version 2.0](COPYING). diff --git a/arca-rar/vendor/rars/src/atomic64.rs b/arca-rar/vendor/rars/src/atomic64.rs new file mode 100644 index 00000000..f4a1ecca --- /dev/null +++ b/arca-rar/vendor/rars/src/atomic64.rs @@ -0,0 +1,125 @@ +//! A 64-bit atomic counter for targets without 64-bit atomics. +//! +//! 32-bit PowerPC, MIPS and older ARM have no `std::sync::atomic::AtomicU64`. +//! Byte budgets can exceed 4 GiB there too, so a narrower atomic would wrap; +//! those targets get a mutex with the same interface instead. + +#[cfg(target_has_atomic = "64")] +pub(crate) use std::sync::atomic::AtomicU64; + +#[cfg(not(target_has_atomic = "64"))] +pub(crate) use fallback::AtomicU64; + +// Also built for tests so 64-bit hosts exercise it. +#[cfg(any(test, not(target_has_atomic = "64")))] +mod fallback { + use std::sync::atomic::Ordering; + use std::sync::Mutex; + + #[derive(Debug, Default)] + pub(crate) struct AtomicU64(Mutex); + + // Which methods are live depends on the enabled features. + #[allow(dead_code)] + impl AtomicU64 { + pub(crate) const fn new(value: u64) -> Self { + Self(Mutex::new(value)) + } + + fn lock(&self) -> std::sync::MutexGuard<'_, u64> { + self.0 + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + } + + pub(crate) fn load(&self, _: Ordering) -> u64 { + *self.lock() + } + + pub(crate) fn store(&self, value: u64, _: Ordering) { + *self.lock() = value; + } + + pub(crate) fn fetch_add(&self, value: u64, _: Ordering) -> u64 { + let mut current = self.lock(); + let previous = *current; + *current = previous.wrapping_add(value); + previous + } + + pub(crate) fn fetch_sub(&self, value: u64, _: Ordering) -> u64 { + let mut current = self.lock(); + let previous = *current; + *current = previous.wrapping_sub(value); + previous + } + + pub(crate) fn compare_exchange_weak( + &self, + expected: u64, + new: u64, + _: Ordering, + _: Ordering, + ) -> Result { + let mut current = self.lock(); + if *current == expected { + *current = new; + Ok(expected) + } else { + Err(*current) + } + } + } + + #[cfg(test)] + mod tests { + use super::AtomicU64; + use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed}; + + #[test] + fn counts_past_32_bits() { + let value = AtomicU64::new(u64::from(u32::MAX)); + assert_eq!(value.fetch_add(2, Relaxed), u64::from(u32::MAX)); + assert_eq!(value.load(Relaxed), 1 << 32 | 1); + assert_eq!(value.fetch_sub(1 << 32, AcqRel), 1 << 32 | 1); + assert_eq!(value.load(Relaxed), 1); + value.store(5 << 32, Relaxed); + assert_eq!(value.load(Relaxed), 5 << 32); + } + + #[test] + fn compare_exchange_reports_the_current_value() { + let value = AtomicU64::new(7); + assert_eq!(value.compare_exchange_weak(6, 9, AcqRel, Acquire), Err(7)); + assert_eq!(value.compare_exchange_weak(7, 9, AcqRel, Acquire), Ok(7)); + assert_eq!(value.load(Relaxed), 9); + } + + #[test] + fn concurrent_reservations_never_exceed_the_limit() { + let used = AtomicU64::new(0); + let limit = 1000; + let granted = AtomicU64::new(0); + std::thread::scope(|scope| { + for _ in 0..8 { + scope.spawn(|| { + for _ in 0..500 { + let mut current = used.load(Acquire); + while let Some(next) = Some(current + 3).filter(|n| *n <= limit) { + match used.compare_exchange_weak(current, next, AcqRel, Acquire) { + Ok(_) => { + granted.fetch_add(3, Relaxed); + break; + } + Err(actual) => current = actual, + } + } + } + }); + } + }); + assert_eq!(used.load(Relaxed), 999); + assert_eq!(granted.load(Relaxed), 999); + } + } +} diff --git a/arca-rar/vendor/rars/src/builder.rs b/arca-rar/vendor/rars/src/builder.rs new file mode 100644 index 00000000..11c1d4c0 --- /dev/null +++ b/arca-rar/vendor/rars/src/builder.rs @@ -0,0 +1,2736 @@ +//! One archive builder for every format. +//! +//! The writers underneath are per-family and take different entry types, and +//! choosing between them is the same twenty decisions in every binding. This +//! module makes that choice once: name the format, add members, ask for bytes +//! or a file or a volume set. The Python extension and the WebAssembly package +//! are thin translations of the type below, which is the point of it living +//! here rather than in one of them. + +use crate::write_progress::{check_cancelled, EmissionWriter, ProgressReporter, ResourceProgress}; +use crate::{ + rar13, rar15_40, rar50, ArchiveFamily, ArchiveVersion, EntrySource, Error, FeatureSet, Result, + WriteProgress, WriterResources, +}; +use std::fs; +use std::io::Write; +use std::path::Path; + +struct ConvertedEntries { + entries: Vec, + _charge: Option, +} + +/// The DOS archive bit, which is what a member gets when the caller offers no +/// mode of its own. Zero would be legal and would read as "no attributes", +/// which no real RAR writer emits. +const DOS_ARCHIVE_ATTR: u32 = 0x20; + +// Host IDs are format-specific: legacy RAR uses 3 for Unix, RAR 5 uses 1. +// Keep the host paired with its attributes. Merely correcting the RAR 5 ID +// while retaining DOS_ARCHIVE_ATTR would make reference extractors interpret +// 0x20 as Unix permissions, producing an unexpectedly restricted file. +const RAR15_HOST_UNIX: u8 = 3; +const RAR50_HOST_UNIX: u64 = 1; + +type PendingArchive = + crate::pending_archive::PendingArchive>; + +impl PendingArchive { + fn path_charge( + resources: &WriterResources, + capacity: usize, + ) -> Result> { + let mut charge = resources.execution_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(capacity as u64)?; + } + Ok(charge) + } + + fn with_resources(destination: &Path, resources: &WriterResources) -> Result<(Self, fs::File)> { + Self::with_admission(destination, |capacity| { + Self::path_charge(resources, capacity) + }) + } + + #[cfg(test)] + fn with_sequence( + destination: &Path, + resources: &WriterResources, + next_sequence: impl FnMut() -> u64, + ) -> Result<(Self, fs::File)> { + Self::create_with_sequence( + destination, + |capacity| Self::path_charge(resources, capacity), + next_sequence, + ) + } +} + +#[derive(Debug, Clone, Copy)] +enum EntryAttributes { + Dos(u64), + Unix(u32), +} + +/// A member queued for writing. +/// +/// The bytes are either held directly or fetched from an [`EntrySource`] when +/// the writer reaches the member. Sources are what keep a large archive off the +/// heap. Legacy single archives pass sources to the per-member writers; +/// legacy volume collection still materializes its one input. +#[derive(Debug, Clone)] +struct BuilderEntry { + id: usize, + name: Vec, + data: Vec, + source: Option, + is_directory: bool, + mtime: Option, + mtime_nanoseconds: Option, + file_times: Option, + legacy_extended_times: Option>, + legacy_unicode_name: Option>, + file_comment: Option>, + encryption: Option, + redirection: Option, + redirection_size: Option, + attributes: EntryAttributes, +} + +#[derive(Debug, Clone)] +struct EntryEncryption { + data_password: Option>, + comment_password: Option>, +} + +impl BuilderEntry { + fn attributes(&self) -> u64 { + match self.attributes { + // add_bytes/add_source can receive permission bits alone, whereas + // add_path supplies a complete st_mode. Supply regular-file type + // bits only when absent so both forms describe Unix metadata. + EntryAttributes::Unix(mode) if mode & 0o170000 == 0 => u64::from(mode | 0o100000), + EntryAttributes::Unix(mode) => u64::from(mode), + EntryAttributes::Dos(attributes) => attributes, + } + } + + fn rar50_attr(&self) -> u64 { + self.attributes() + } + + fn rar15_attr(&self) -> u32 { + // set_dos_attributes validates the target family's field width. + self.attributes() as u32 + } + + fn rar13_attr(&self) -> u8 { + match self.attributes { + EntryAttributes::Dos(attributes) => attributes as u8, + EntryAttributes::Unix(_) => DOS_ARCHIVE_ATTR as u8, + } + } + + fn rar50_host_os(&self) -> u64 { + if matches!(self.attributes, EntryAttributes::Unix(_)) { + RAR50_HOST_UNIX + } else { + 0 // Windows host, DOS attributes. + } + } + + fn rar15_host_os(&self) -> u8 { + // The RAR 1.5 writer still downgrades Unix metadata to DOS for old + // extractor compatibility; RAR 2.x-4.x retain the Unix host and mode. + if matches!(self.attributes, EntryAttributes::Unix(_)) { + RAR15_HOST_UNIX + } else { + 0 // MS-DOS host, DOS attributes. + } + } +} + +/// Assembles an archive from members added one at a time. +/// +/// Nothing is encoded until [`to_bytes`](Self::to_bytes), +/// [`write_to_path`](Self::write_to_path) or +/// [`build_volumes`](Self::build_volumes) is called, so the same builder can be +/// written more than once and to more than one format. +/// +/// ```no_run +/// # fn main() -> rars::Result<()> { +/// let mut builder = rars::Builder::new(rars::ArchiveVersion::Rar50); +/// builder.add_bytes(b"hello.txt".to_vec(), b"hello".to_vec(), None, None)?; +/// let archive = builder.to_bytes()?; +/// # let _ = archive; +/// # Ok(()) +/// # } +/// ``` +#[derive(Debug, Clone)] +pub struct Builder { + format: ArchiveVersion, + compression: Option, + store: bool, + solid: bool, + password: Option>, + encrypt_headers: bool, + comment: Option>, + comment_password: Option>, + recovery_percent: Option, + locked: bool, + quick_open: bool, + archive_metadata: Option, + legacy_archive_comment_metadata: Option<(u32, u8)>, + legacy_unpack_version: Option, + rar50_dictionary_size: Option, + volume_size: Option, + entries: Vec, + next_entry_id: usize, + allow_duplicate_names: bool, +} + +impl Builder { + /// A builder for `format`, with the writer's own default compression level. + pub fn new(format: ArchiveVersion) -> Self { + Self { + format, + compression: None, + store: false, + solid: false, + password: None, + encrypt_headers: false, + comment: None, + comment_password: None, + recovery_percent: None, + locked: false, + quick_open: false, + archive_metadata: None, + legacy_archive_comment_metadata: None, + legacy_unpack_version: None, + rar50_dictionary_size: None, + volume_size: None, + entries: Vec::new(), + next_entry_id: 0, + allow_duplicate_names: false, + } + } + + /// The format this builder writes. + pub fn format(&self) -> ArchiveVersion { + self.format + } + + /// Compression level, 0 to 5. `None` leaves the writer's default in place. + pub fn compression_level(mut self, level: Option) -> Self { + self.compression = level; + self + } + + /// Store members without compressing them. Storing is a compression level, + /// not a kind of member, so this wins over any level set above. + pub fn store(mut self, store: bool) -> Self { + self.store = store; + self + } + + /// Compress members against each other rather than independently. + pub fn solid(mut self, solid: bool) -> Self { + self.solid = solid; + self + } + + /// Encrypt member data with `password`. + pub fn password(mut self, password: Option>) -> Self { + self.password = password; + self + } + + /// Encrypt the headers as well as the data, hiding the member names. Needs + /// a password. + pub fn header_encryption(mut self, encrypt: bool) -> Self { + self.encrypt_headers = encrypt; + self + } + + /// An archive comment. + pub fn comment(mut self, comment: Option>) -> Self { + if comment.is_none() { + self.legacy_archive_comment_metadata = None; + self.comment_password = None; + } + self.comment = comment; + self + } + + pub(crate) fn legacy_unpack_version(mut self, version: Option) -> Self { + self.legacy_unpack_version = version; + self + } + + pub(crate) fn rar50_dictionary_size(mut self, size: Option) -> Self { + self.rar50_dictionary_size = size; + self + } + + pub(crate) fn legacy_archive_comment_metadata(mut self, metadata: Option<(u32, u8)>) -> Self { + self.legacy_archive_comment_metadata = metadata; + self + } + + /// Add a recovery record covering this percentage of the archive. + pub fn recovery_percent(mut self, percent: Option) -> Self { + self.recovery_percent = percent; + self + } + + /// Split the output into volumes of at most this many bytes. + /// [`build_volumes`](Self::build_volumes) requires it; the single-archive + /// entry points refuse to run while it is set. + pub fn volume_size(mut self, size: Option) -> Self { + self.volume_size = size; + self + } + + /// How many members are queued. + pub fn len(&self) -> usize { + self.entries.len() + } + + /// Whether no members are queued. + pub fn is_empty(&self) -> bool { + self.entries.is_empty() + } + + /// The queued member names, in the order they will be written. + pub fn names(&self) -> impl Iterator { + self.entries.iter().map(|entry| entry.name.as_slice()) + } + + /// Queue `data` under `name`. + /// + /// `name` is archive identity, not display text: legacy byte names are + /// accepted unchanged. RAR5 names use its wire UTF-8 encoding; use + /// [`crate::filename::encode_rar50`] for native Unix bytes and Unix `mode` + /// for those nonportable mapped names. [`Self::add_path`] handles this + /// conversion automatically for filesystem inputs. + /// + /// `mode` is a Unix mode, with optional file-type bits. Without a mode, + /// the member uses DOS archive attributes and the extractor's default permissions. + /// RAR 1.3-1.5 output uses DOS metadata even when a Unix mode is supplied. + pub fn add_bytes( + &mut self, + name: Vec, + data: Vec, + mtime: Option, + mode: Option, + ) -> Result<()> { + self.push(BuilderEntry { + id: 0, + name: self.validate_name(name)?, + data, + source: None, + is_directory: false, + mtime, + mtime_nanoseconds: None, + file_times: None, + legacy_extended_times: None, + legacy_unicode_name: None, + file_comment: None, + encryption: None, + redirection: None, + redirection_size: None, + attributes: mode.map_or( + EntryAttributes::Dos(u64::from(DOS_ARCHIVE_ATTR)), + EntryAttributes::Unix, + ), + }) + } + + /// Queue a member whose bytes are fetched from `source` when the writer + /// reaches it. + /// `mode` has the same meaning as in [`add_bytes`](Self::add_bytes). + pub fn add_source( + &mut self, + name: Vec, + source: EntrySource, + mtime: Option, + mode: Option, + ) -> Result<()> { + self.push(BuilderEntry { + id: 0, + name: self.validate_name(name)?, + data: Vec::new(), + source: Some(source), + is_directory: false, + mtime, + mtime_nanoseconds: None, + file_times: None, + legacy_extended_times: None, + legacy_unicode_name: None, + file_comment: None, + encryption: None, + redirection: None, + redirection_size: None, + attributes: mode.map_or( + EntryAttributes::Dos(u64::from(DOS_ARCHIVE_ATTR)), + EntryAttributes::Unix, + ), + }) + } + + /// Replace a queued file's payload while retaining its position and metadata. + /// Directories and redirections cannot be changed into payload entries. + /// The source is opened only when writing. Errors leave the entry unchanged. + pub fn set_source(&mut self, name: &[u8], source: EntrySource) -> Result<()> { + let id = self.entry_id(name)?; + self.set_source_by_id(id, source) + } + + /// Identity-based variant of [`set_source`](Self::set_source). + pub fn set_source_by_id(&mut self, id: usize, source: EntrySource) -> Result<()> { + let index = self.index_by_id(id)?; + let name = self.entries[index].name.clone(); + + let entry = &mut self.entries[index]; + if entry.is_directory || entry.redirection.is_some() { + return Err( + Error::InvalidArgument("payload source requires a regular entry") + .at_entry(name.to_vec(), "replacing payload"), + ); + } + entry.data = Vec::new(); + entry.source = Some(source); + Ok(()) + } + + /// Queue an explicit RAR1.3–4.x or RAR5/7 directory, including an empty one. + /// `mode` supplies Unix permission bits; otherwise DOS directory flags are used. + /// Legacy timestamps use raw DOS values; legacy volume output is unsupported. + pub fn add_directory( + &mut self, + name: Vec, + mtime: Option, + mode: Option, + ) -> Result<()> { + if matches!( + self.format, + ArchiveVersion::Rar13 | ArchiveVersion::Rar14 | ArchiveVersion::Rar15 + ) && mode.is_some() + { + return Err(Error::InvalidArgument( + "RAR1.x directory output requires DOS attributes", + )); + } + if self.format.family() != ArchiveFamily::Rar50Plus && self.volume_size.is_some() { + return Err(Error::InvalidArgument( + "explicit directories require RAR5/7 or single-archive RAR1.3–4.x output", + )); + } + self.push(BuilderEntry { + id: 0, + name: self.validate_name(name)?, + data: Vec::new(), + source: None, + is_directory: true, + mtime, + mtime_nanoseconds: None, + file_times: None, + legacy_extended_times: None, + legacy_unicode_name: None, + file_comment: None, + encryption: None, + redirection: None, + redirection_size: None, + attributes: mode.map_or(EntryAttributes::Dos(0x10), |mode| { + EntryAttributes::Unix((mode & 0o7777) | 0o040000) + }), + }) + } + + /// Queue a RAR2.0–4.x or RAR5/7 Unix symbolic link without following its target. + /// Name and target use archive wire bytes. Relative targets remain unchanged + /// through renames; the directory flag describes the target, not this entry. + /// Legacy targets use native bytes and cannot carry a target-directory flag. + pub fn add_unix_symlink( + &mut self, + name: Vec, + target: Vec, + target_is_directory: bool, + mtime: Option, + mode: Option, + ) -> Result<()> { + if matches!( + self.format, + ArchiveVersion::Rar20 + | ArchiveVersion::Rar29 + | ArchiveVersion::Rar30 + | ArchiveVersion::Rar40 + ) { + if self.volume_size.is_some() + || target_is_directory + || target.is_empty() + || target.contains(&0) + { + return Err(Error::InvalidArgument("legacy symbolic links require single-archive output, a nonempty native target without NUL and no target-directory flag")); + } + return self.add_bytes( + name, + target, + mtime, + Some(0o120000 | (mode.unwrap_or(0o777) & 0o7777)), + ); + } + let link = rar50::FileRedirection { + redirection_type: 1, + flags: u64::from(target_is_directory), + target_name: target, + }; + if self.format.family() != ArchiveFamily::Rar50Plus + || self.volume_size.is_some() + || !link.is_supported_unix_symlink() + { + return Err(Error::InvalidArgument("symbolic links require single-archive RAR5/7 output and a nonempty UTF-8 wire target without NUL")); + } + self.push(BuilderEntry { + id: 0, + name: self.validate_name(name)?, + data: Vec::new(), + source: None, + is_directory: false, + mtime, + mtime_nanoseconds: None, + file_times: None, + legacy_extended_times: None, + legacy_unicode_name: None, + file_comment: None, + encryption: None, + redirection: Some(link), + redirection_size: None, + attributes: EntryAttributes::Unix(0o120000 | (mode.unwrap_or(0o777) & 0o7777)), + }) + } + + /// Retain a supported RAR5 redirection and its header metadata, without + /// reading a target. Archive-internal targets are checked before output. + pub fn add_archive_redirection(&mut self, member: &crate::ArchiveMember) -> Result<()> { + let link = member + .supported_redirection() + .ok_or(Error::InvalidArgument("unsupported redirection metadata"))?; + if self.format.family() != ArchiveFamily::Rar50Plus || self.volume_size.is_some() { + return Err(Error::InvalidArgument( + "redirections require single-archive RAR5/7 output", + )); + } + let meta = &member.meta; + self.push(BuilderEntry { + id: 0, + name: self.validate_name(meta.name.clone())?, + data: Vec::new(), + source: None, + is_directory: meta.is_directory, + mtime: meta.file_time, + mtime_nanoseconds: meta.mtime_refinement.map(|time| time.nanoseconds), + file_times: None, + legacy_extended_times: None, + legacy_unicode_name: None, + file_comment: None, + encryption: None, + redirection: Some(link.clone()), + redirection_size: Some(meta.unpacked_size), + attributes: if meta.host_os == Some(1) { + EntryAttributes::Unix(meta.file_attr as u32) + } else { + EntryAttributes::Dos(meta.file_attr) + }, + }) + } + + fn check_redirection_targets(&self) -> Result<()> { + if !self.entries.iter().any(|entry| { + entry + .redirection + .as_ref() + .is_some_and(|link| link.redirection_type >= 4) + }) { + return Ok(()); + } + let mut preceding = std::collections::HashMap::new(); + for entry in &self.entries { + let size = entry.redirection_size.unwrap_or(match &entry.source { + Some(source) => source.len()?, + None => entry.data.len() as u64, + }); + if let Some(link) = &entry.redirection { + if link.redirection_type >= 4 && preceding.get(&link.target_name) != Some(&size) { + return Err(Error::InvalidArgument("hard-link and file-copy targets must precede the link and have the same size") + .at_entry(entry.name.clone(), "validating redirection target")); + } + } + if !entry.is_directory + && entry + .redirection + .as_ref() + .is_none_or(|link| link.redirection_type >= 4) + { + preceding.insert(entry.name.clone(), size); + } + } + Ok(()) + } + + /// Set per-member encryption for RAR1.3–4.x or RAR5/7 output. + /// Legacy output supports data passwords only, for single archives. + /// Explicit None passwords retain plaintext even when the builder has a default password. + pub fn set_entry_encryption( + &mut self, + name: &[u8], + data_password: Option>, + comment_password: Option>, + ) -> Result<()> { + let id = self.entry_id(name)?; + self.set_entry_encryption_by_id(id, data_password, comment_password) + } + + /// Identity-based variant of [`set_entry_encryption`](Self::set_entry_encryption). + pub fn set_entry_encryption_by_id( + &mut self, + id: usize, + data_password: Option>, + comment_password: Option>, + ) -> Result<()> { + let index = self.index_by_id(id)?; + + if (self.format.family() != ArchiveFamily::Rar50Plus + && (comment_password.is_some() || self.volume_size.is_some())) + || data_password.as_ref().is_some_and(Vec::is_empty) + || comment_password.as_ref().is_some_and(Vec::is_empty) + { + return Err(Error::InvalidArgument( + "per-entry encryption requires supported output and nonempty passwords; legacy output supports data encryption in single archives only", + )); + } + let entry = &mut self.entries[index]; + entry.encryption = Some(EntryEncryption { + data_password, + comment_password, + }); + Ok(()) + } + + /// Retain RAR5/7 archive-level metadata and advisory lock/index settings. + pub fn archive_metadata( + mut self, + metadata: Option, + locked: bool, + quick_open: bool, + ) -> Result { + if self.format.family() != ArchiveFamily::Rar50Plus { + return Err(Error::InvalidArgument( + "archive metadata settings require RAR5/7", + )); + } + if let Some(metadata) = &metadata { + rar50::write::headers::retained_archive_metadata( + metadata, + &WriterResources::default(), + )?; + } + self.archive_metadata = metadata; + self.locked = locked; + self.quick_open = quick_open; + Ok(self) + } + + /// Encrypt only the archive comment with this password. + pub fn archive_comment_password(mut self, password: Option>) -> Self { + self.comment_password = password; + self + } + + /// Retain a validated native Unicode name record for a queued legacy entry. + /// Renaming re-encodes Unicode; unchanged names retain their original bytes. + pub fn set_legacy_unicode_name(&mut self, name: &[u8], raw: Vec) -> Result<()> { + let id = self.entry_id(name)?; + self.set_legacy_unicode_name_by_id(id, raw) + } + + /// Identity-based variant of [`set_legacy_unicode_name`](Self::set_legacy_unicode_name). + pub fn set_legacy_unicode_name_by_id(&mut self, id: usize, raw: Vec) -> Result<()> { + let index = self.index_by_id(id)?; + let name = self.entries[index].name.clone(); + + if !matches!( + self.format, + ArchiveVersion::Rar20 + | ArchiveVersion::Rar29 + | ArchiveVersion::Rar30 + | ArchiveVersion::Rar40 + ) || self.volume_size.is_some() + { + return Err(Error::InvalidArgument( + "legacy Unicode names require single-archive RAR2–4 output", + )); + } + rar15_40::validate_unicode_name(&raw, &name)?; + let entry = &mut self.entries[index]; + entry.legacy_unicode_name = Some(raw); + Ok(()) + } + + /// Retain a native RAR2.9–4.x extended-time record, including archival time. + /// DOS values and fractional precision are copied without timezone conversion. + /// Unsupported output or invalid records leave the entry unchanged. + pub fn set_legacy_extended_times(&mut self, name: &[u8], raw: Option>) -> Result<()> { + let id = self.entry_id(name)?; + self.set_legacy_extended_times_by_id(id, raw) + } + + /// Identity-based variant of [`set_legacy_extended_times`](Self::set_legacy_extended_times). + pub fn set_legacy_extended_times_by_id( + &mut self, + id: usize, + raw: Option>, + ) -> Result<()> { + let index = self.index_by_id(id)?; + + if !matches!( + self.format, + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + ) || self.volume_size.is_some() + { + return Err(Error::InvalidArgument( + "legacy extended timestamps require single-archive RAR2.9–4.x output", + )); + } + if let Some(raw) = &raw { + crate::file_times::validate_legacy_extended_times(raw)?; + } + let entry = &mut self.entries[index]; + entry.legacy_extended_times = raw; + Ok(()) + } + + /// Set complete RAR5/7 timestamps without narrowing FILETIME or discarding fractions. + pub fn set_file_times(&mut self, name: &[u8], times: Option) -> Result<()> { + let id = self.entry_id(name)?; + self.set_file_times_by_id(id, times) + } + + /// Identity-based variant of [`set_file_times`](Self::set_file_times). + pub fn set_file_times_by_id( + &mut self, + id: usize, + times: Option, + ) -> Result<()> { + let index = self.index_by_id(id)?; + + if self.format.family() != ArchiveFamily::Rar50Plus { + return Err(Error::InvalidArgument( + "complete file times require RAR5/7 output", + )); + } + if let Some(times) = times { + times.encode()?; + } + let entry = &mut self.entries[index]; + if times.is_some_and(|times| times.modified.is_some()) { + entry.mtime = None; + } + // Preserve an existing fractional mtime when adding only ctime/atime. + let times = if let (Some(mut times), Some(seconds), Some(nanoseconds)) = + (times, entry.mtime, entry.mtime_nanoseconds) + { + times.modified = Some(crate::FileTimestamp::Unix { + seconds, + nanoseconds, + }); + times.encode()?; + entry.mtime = None; + Some(times) + } else { + times + }; + entry.mtime_nanoseconds = None; + entry.file_times = times; + Ok(()) + } + + /// Add nanosecond precision to a queued RAR5/7 modification time. + /// The member must already have whole seconds; legacy output is unsupported. + pub fn set_mtime_nanoseconds(&mut self, name: &[u8], nanoseconds: u32) -> Result<()> { + let id = self.entry_id(name)?; + self.set_mtime_nanoseconds_by_id(id, nanoseconds) + } + + /// Identity-based variant of [`set_mtime_nanoseconds`](Self::set_mtime_nanoseconds). + pub fn set_mtime_nanoseconds_by_id(&mut self, id: usize, nanoseconds: u32) -> Result<()> { + let index = self.index_by_id(id)?; + + if self.format.family() != crate::ArchiveFamily::Rar50Plus || nanoseconds >= 1_000_000_000 { + return Err(Error::InvalidArgument( + "nanosecond modification times require RAR5/7 and a fraction below one second", + )); + } + let entry = &mut self.entries[index]; + if entry.mtime.is_none() { + return Err(Error::InvalidArgument( + "fractional modification time requires whole seconds", + )); + } + entry.mtime_nanoseconds = Some(nanoseconds); + Ok(()) + } + + /// Sets or removes a queued member's comment. Comments follow the entry + /// through renames and reordering; `Some(Vec::new())` is an explicit empty comment. + /// RAR3/4 and volume output do not support comments. Errors leave the entry unchanged. + pub fn set_file_comment(&mut self, name: &[u8], comment: Option>) -> Result<()> { + let id = self.entry_id(name)?; + self.set_file_comment_by_id(id, comment) + } + + /// Identity-based variant of [`set_file_comment`](Self::set_file_comment). + pub fn set_file_comment_by_id(&mut self, id: usize, comment: Option>) -> Result<()> { + let index = self.index_by_id(id)?; + + if comment.is_some() { + crate::write_plan::validate_option( + self.format, + crate::write_plan::WriterOption::FileComment, + crate::write_plan::PlanShape::new().volumes(self.volume_size.is_some()), + )?; + } + let entry = &mut self.entries[index]; + entry.file_comment = comment; + Ok(()) + } + + /// Set DOS/Windows attributes for a queued entry, replacing any Unix mode. + /// + /// The output host is paired with these flags. Attribute width is checked + /// against the target format (8 bits for RAR 1.3/1.4, 32 for RAR 1.5-4.x). + /// The directory bit must agree with the entry kind: changing attributes + /// cannot change a file into a directory. Errors leave metadata unchanged. + pub fn set_dos_attributes(&mut self, name: &[u8], attributes: u64) -> Result<()> { + let id = self.entry_id(name)?; + self.set_dos_attributes_by_id(id, attributes) + } + + /// Identity-based variant of [`set_dos_attributes`](Self::set_dos_attributes). + pub fn set_dos_attributes_by_id(&mut self, id: usize, attributes: u64) -> Result<()> { + let index = self.index_by_id(id)?; + + use crate::ArchiveFamily; + let max = match self.format.family() { + ArchiveFamily::Rar13 => u64::from(u8::MAX), + ArchiveFamily::Rar15To40 => u64::from(u32::MAX), + ArchiveFamily::Rar50Plus => u64::MAX, + }; + if attributes > max { + return Err(Error::InvalidArgument( + "DOS attributes exceed the target format's field width", + )); + } + let entry = &mut self.entries[index]; + if entry + .redirection + .as_ref() + .is_some_and(|link| link.redirection_type == 1) + { + return Err(Error::InvalidArgument( + "Unix symbolic links require Unix attributes", + )); + } + if (attributes & 0x10 != 0) != entry.is_directory { + return Err(Error::InvalidArgument( + "DOS directory attributes must match the entry kind", + )); + } + entry.attributes = EntryAttributes::Dos(attributes); + Ok(()) + } + + /// Queue a file, or every file under a directory, named `archive_name` in + /// the archive. Children are added in sorted order so the same tree gives + /// the same archive twice. + /// `archive_name` and child names use native filename bytes on Unix and + /// UTF-8 elsewhere. Legacy output preserves these bytes; RAR5/7 applies + /// the reversible Unix byte mapping. Member lookup uses the encoded name. + /// + /// Symlinks are refused rather than followed, at the root and at every + /// level below it: a link is a name for someone else's file, and copying + /// what it points at is not what the caller asked for. + /// Other special files are refused instead of being silently omitted. + pub fn add_path(&mut self, path: &Path, archive_name: &[u8]) -> Result<()> { + let link_meta = fs::symlink_metadata(path)?; + if link_meta.file_type().is_symlink() { + return Err(Error::AtEntry { + name: archive_name.to_vec(), + operation: "adding", + source: Box::new(Error::InputSymlink), + }); + } + let meta = fs::metadata(path)?; + if meta.is_dir() { + let mut children = fs::read_dir(path)?.collect::, _>>()?; + children.sort_by_key(|entry| entry.file_name()); + for child in children { + let file_name = child.file_name(); + let file_name = crate::filename::native_bytes(&file_name)?; + let mut child_name = archive_name.to_vec(); + child_name.push(b'/'); + child_name.extend_from_slice(file_name); + self.add_path(&child.path(), &child_name)?; + } + } else if meta.is_file() { + // Validate native path syntax before a RAR5 mapping marker can + // precede the first component of the encoded archive name. + crate::filename::validate_relative(archive_name)?; + let name = if cfg!(unix) && self.format.family() == ArchiveFamily::Rar50Plus { + crate::filename::encode_rar50(archive_name).into_owned() + } else { + archive_name.to_vec() + }; + self.add_source(name, EntrySource::from_path(path), None, unix_mode(&meta))?; + } else { + return Err( + Error::InvalidArgument("input path is not a regular file or directory") + .at_entry(archive_name.to_vec(), "adding"), + ); + } + Ok(()) + } + + /// Stable IDs in current archive order, including directories and links. + /// IDs survive renames/removals and are never reused within this builder. + pub fn member_ids(&self) -> impl Iterator + '_ { + self.entries.iter().map(|entry| entry.id) + } + + /// Permit duplicate names when importing entries. Name-based editing still + /// rejects ambiguity; callers must select those members by ID. + pub fn allow_duplicate_names(mut self, allow: bool) -> Self { + self.allow_duplicate_names = allow; + self + } + + /// Resolve a unique queued name to its stable ID. + pub fn entry_id(&self, name: &[u8]) -> Result { + let mut matches = self.entries.iter().filter(|entry| entry.name == name); + let entry = matches + .next() + .ok_or_else(|| Error::EntryNotFound.at_entry(name.to_vec(), "selecting"))?; + if matches.next().is_some() { + return Err( + Error::InvalidArgument("ambiguous member name; select by member ID") + .at_entry(name.to_vec(), "selecting"), + ); + } + Ok(entry.id) + } + + fn index_by_id(&self, id: usize) -> Result { + self.entries + .iter() + .position(|entry| entry.id == id) + .ok_or(Error::EntryNotFound) + } + + /// Drop the uniquely named member. Ambiguous names are rejected. + pub fn remove(&mut self, name: &[u8]) -> Result<()> { + self.remove_by_id(self.entry_id(name)?) + } + + /// Drop exactly one member, identified by its stable ID. + pub fn remove_by_id(&mut self, id: usize) -> Result<()> { + let index = self.index_by_id(id)?; + let name = &self.entries[index].name; + if self + .entries + .iter() + .any(|entry| entry.id != id && entry.name == *name) + { + for entry in &self.entries[index + 1..] { + if entry + .redirection + .as_ref() + .is_some_and(|link| link.redirection_type >= 4 && link.target_name == *name) + { + return Err(Error::InvalidArgument( + "removing this duplicate would retarget a hard link or file copy", + )); + } + if entry.name == *name && !entry.is_directory { + break; + } + } + } + self.entries.remove(index); + Ok(()) + } + + /// Rename the uniquely named member. Ambiguous names are rejected. + pub fn rename(&mut self, old: &[u8], new: Vec) -> Result<()> { + self.rename_by_id(self.entry_id(old)?, new) + } + + /// Rename exactly one member. A new duplicate name is rejected. Name-based + /// hard-link/file-copy targets follow the nearest preceding target identity. + pub fn rename_by_id(&mut self, id: usize, new: Vec) -> Result<()> { + let new = self.validate_name(new)?; + let index = self.index_by_id(id)?; + let old = self.entries[index].name.clone(); + if old != new { + self.reject_duplicate_name(&new)?; + } + let unicode_name = if old != new && self.entries[index].legacy_unicode_name.is_some() { + Some(crate::filename::encode_legacy_unicode(&new)?) + } else { + self.entries[index].legacy_unicode_name.clone() + }; + // A later member with the same name shadows this target for later links. + let mut target = None; + for entry in &mut self.entries { + if let Some(link) = &mut entry.redirection { + if link.redirection_type >= 4 && link.target_name == old && target == Some(id) { + link.target_name = new.clone(); + } + } + if entry.name == old + && !entry.is_directory + && entry + .redirection + .as_ref() + .is_none_or(|link| link.redirection_type >= 4) + { + target = Some(entry.id); + } + } + self.entries[index].legacy_unicode_name = unicode_name; + self.entries[index].name = new; + Ok(()) + } + + fn validate_name(&self, name: Vec) -> Result> { + let name = validate_entry_name(name)?; + if self.format.family() == ArchiveFamily::Rar50Plus && std::str::from_utf8(&name).is_err() { + return Err(Error::InvalidArgument( + "RAR5 archive names require wire UTF-8; use filename::encode_rar50 for native Unix bytes", + )); + } + Ok(name) + } + + fn push(&mut self, mut entry: BuilderEntry) -> Result<()> { + if !self.allow_duplicate_names { + self.reject_duplicate_name(&entry.name)?; + } + let next = self + .next_entry_id + .checked_add(1) + .ok_or(Error::InvalidArgument("member ID overflow"))?; + entry.id = self.next_entry_id; + self.next_entry_id = next; + self.entries.push(entry); + Ok(()) + } + + fn reject_duplicate_name(&self, name: &[u8]) -> Result<()> { + if self.entries.iter().any(|entry| entry.name == name) { + return Err(Error::AtEntry { + name: name.to_vec(), + operation: "adding", + source: Box::new(Error::DuplicateEntry), + }); + } + Ok(()) + } + + /// Encode the whole archive into memory. + pub fn to_bytes(&self) -> Result> { + self.to_bytes_with_progress(None) + } + + /// As [`to_bytes`](Self::to_bytes), reporting progress as it goes. + pub fn to_bytes_with_progress(&self, progress: Option<&dyn WriteProgress>) -> Result> { + self.check_single()?; + if self.streams_rar50() { + let mut output = Vec::new(); + self.write_streaming_rar50(&mut output, &WriterResources::default(), progress)?; + return Ok(output); + } + let mut output = Vec::new(); + self.write_to(&mut output, &WriterResources::default(), progress)?; + Ok(output) + } + + /// Encode into a collector that remains charged until handoff or drop. + pub fn to_output( + &self, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result { + let mut output = crate::WriterOutput::new(resources); + self.write_to(&mut output, resources, progress)?; + Ok(output) + } + + /// Encode with an explicit resource policy, transferring output ownership + /// to the caller when this method returns. + pub fn to_bytes_with_resources( + &self, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result> { + Ok(self.to_output(resources, progress)?.into_vec()) + } + + /// Write the archive to `output`. + /// + /// RAR 5 and RAR 7 stream using the supplied workspace and spool policy; + /// see [`WriterResources`] for its scope and bare-WASM memory limits. + /// Legacy families emit headers and members directly, retaining compressed + /// members in memory. Stored sources are read twice to prepare and verify + /// checksums. Legacy managed-memory quotas are not supported. + /// On failure, `output` may contain a partial archive. Use + /// [`write_to_path`](Self::write_to_path) for atomic file publication. + pub fn write_to( + &self, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + self.check_single()?; + if self.streams_rar50() { + return self.write_streaming_rar50(output, resources, progress); + } + if resources.max_preparation_bytes().is_some() || resources.max_memory_bytes().is_some() { + return Err(Error::UnsupportedFamilyFeature { + family: self.format.family(), + feature: if resources.max_memory_bytes().is_some() { + "aggregate managed-memory limit" + } else { + "preparation memory quota" + }, + }); + } + let progress = ResourceProgress::new(resources, progress.map(ProgressReporter)); + let reporting = Some(ProgressReporter(&progress)); + check_cancelled(reporting)?; + let mut output = EmissionWriter::new(output, reporting); + self.write_legacy_to(&mut output, resources, Some(&progress))?; + output.finish() + } + + /// Write the archive to `path`, streaming where the format allows it. + /// The completed archive replaces the destination only after writing and syncing succeed. + /// + /// Any spooling the writer needs goes beside the output rather than in the + /// system temporary directory, which is often a memory-backed filesystem + /// too small for the archive being written. + pub fn write_to_path(&self, path: &Path, progress: Option<&dyn WriteProgress>) -> Result<()> { + let resources = match path + .parent() + .filter(|parent| !parent.as_os_str().is_empty()) + { + Some(parent) => WriterResources::default().with_temp_dir(parent), + None => WriterResources::default(), + }; + self.write_to_path_with_resources(path, &resources, progress) + } + + /// Publish atomically using an explicit writer policy and scratch directory. + pub fn write_to_path_with_resources( + &self, + path: &Path, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + if self.format.family() != ArchiveFamily::Rar50Plus + && resources.max_memory_bytes().is_some() + { + return Err(Error::UnsupportedFamilyFeature { + family: self.format.family(), + feature: "aggregate managed memory quota", + }); + } + let (mut pending, output) = PendingArchive::with_resources(path, resources)?; + // Close before rename or cleanup on platforms that disallow removing + // open files. Declaration order also closes it first during unwinding. + { + let mut output = output; + self.write_to(&mut output, resources, progress)?; + output.sync_all()?; + } + check_cancelled(progress.map(ProgressReporter))?; + fs::rename(pending.path.as_ref().unwrap(), path)?; + pending.path = None; + Ok(()) + } + + /// Encode the archive as a volume set, one `Vec` per volume. + /// + /// Requires [`volume_size`](Self::volume_size). Naming the parts on disk is + /// the caller's job, because the two families number them differently. + pub fn build_volumes(&self, progress: Option<&dyn WriteProgress>) -> Result>> { + self.build_volumes_with_resources(&WriterResources::default(), progress) + } + + pub fn build_volumes_with_resources( + &self, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result>> { + if self.format.family() == ArchiveFamily::Rar50Plus { + return self.to_volume_output(resources, progress)?.into_vec(); + } + if resources.max_memory_bytes().is_some() || resources.max_preparation_bytes().is_some() { + return Err(Error::UnsupportedFamilyFeature { + family: self.format.family(), + feature: "managed writer memory policy", + }); + } + let volume_size = self.volume_payload_size()?; + let control = ResourceProgress::new(resources, progress.map(ProgressReporter)); + let progress = Some(&control as &dyn WriteProgress); + check_cancelled(progress.map(ProgressReporter))?; + self.single_volume_entry()?; + let this = self.materialized_volume_input(progress.map(ProgressReporter))?; + let result = match self.format.family() { + ArchiveFamily::Rar15To40 => this.build_rar15_volumes(volume_size, progress), + ArchiveFamily::Rar13 => this.build_rar13_volumes(volume_size, progress), + ArchiveFamily::Rar50Plus => unreachable!("modern volume output handled above"), + }?; + check_cancelled(progress.map(ProgressReporter))?; + Ok(result) + } + + /// Collect modern volumes, retaining their charges for a binding handoff. + pub fn to_volume_output( + &self, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result { + if self.format.family() != ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedFamilyFeature { + family: self.format.family(), + feature: "streaming managed volume output", + }); + } + let mut sink = crate::streaming::output::VolumeCollector::new(resources)?; + self.write_volumes_to(&mut sink, resources, progress)?; + sink.finish() + } + + /// Stream RAR5/7 volumes to a caller-owned sink under the resource policy. + pub fn write_volumes_to( + &self, + sink: &mut dyn rar50::VolumeSink, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + if self.format.family() != ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedFamilyFeature { + family: self.format.family(), + feature: "streaming managed volume output", + }); + } + let volume_size = self.volume_payload_size()?; + if self.comment.is_some() { + return Err(Error::InvalidArgument( + "RAR 5 volume comments are not supported", + )); + } + let converted = self.rar50_entries_with_resources(resources)?; + rar50::write_streaming_volumes_with_progress( + &converted.entries, + self.rar50_options(), + rar50::ArchiveExtras::default() + .with_recovery_percent(self.recovery_percent) + .with_filter_policy(self.rar50_filter_policy()), + volume_size as u64, + sink, + resources, + progress, + ) + } + + fn volume_payload_size(&self) -> Result { + self.check_encryption_option()?; + self.check_recovery_option()?; + if self.legacy_unpack_version.is_some() { + return Err(Error::InvalidArgument( + "retained legacy unpacker version requires single-archive output", + )); + } + if self.entries.iter().any(|entry| { + entry.legacy_extended_times.is_some() || entry.legacy_unicode_name.is_some() + }) { + return Err(Error::InvalidArgument( + "legacy extended timestamps and Unicode names are unsupported in volume output", + )); + } + + if self.format.family() != ArchiveFamily::Rar50Plus + && self.entries.iter().any(|entry| entry.encryption.is_some()) + { + return Err(Error::InvalidArgument( + "legacy per-entry encryption is unsupported in volume output", + )); + } + if self.format.family() != ArchiveFamily::Rar50Plus && self.entries.iter().any(|entry| entry.is_directory || matches!(entry.attributes, EntryAttributes::Unix(mode) if mode & 0o170000 == 0o120000)) { + return Err(Error::InvalidArgument("legacy directories and symbolic links are unsupported in volume output")); + } + let volume_size = self + .volume_size + .ok_or(Error::InvalidArgument("volume_size is required"))?; + if self + .entries + .iter() + .any(|entry| entry.file_comment.is_some()) + { + crate::write_plan::validate_option( + self.format, + crate::write_plan::WriterOption::FileComment, + crate::write_plan::PlanShape::new().volumes(true), + )?; + } + if self.entries.is_empty() { + return Err(Error::InvalidArgument("archive builder has no entries")); + } + if self.archive_metadata.is_some() || self.locked || self.quick_open { + return Err(Error::InvalidArgument( + "archive metadata settings are not supported in volume output", + )); + } + if self.entries.iter().any(|entry| entry.redirection.is_some()) { + return Err(Error::InvalidArgument( + "symbolic links are not supported in volume output", + )); + } + Ok(volume_size) + } + + /// Whether writing goes through the streaming RAR 5 writer, which serves + /// everything this builder can ask for except volume sets. It validates + /// missing header passwords before opening member sources. + pub fn streams_rar50(&self) -> bool { + matches!(self.format, ArchiveVersion::Rar50 | ArchiveVersion::Rar70) + && self.volume_size.is_none() + } + + fn check_recovery_option(&self) -> Result<()> { + if self.recovery_percent.is_some() { + crate::write_plan::validate_option( + self.format, + crate::write_plan::WriterOption::RecoveryRecord, + crate::write_plan::PlanShape::new().volumes(self.volume_size.is_some()), + )?; + } + Ok(()) + } + + fn check_encryption_option(&self) -> Result<()> { + if cfg!(feature = "encryption") { + return Ok(()); + } + let encrypted_entry = self.entries.iter().any(|entry| { + let data_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.data_password.as_deref() + }); + let comment_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.comment_password.as_deref() + }); + data_password.is_some() || (entry.file_comment.is_some() && comment_password.is_some()) + }); + if self.encrypt_headers || self.comment_password.is_some() || encrypted_entry { + crate::crypto::require_encryption()?; + } + Ok(()) + } + + fn check_single(&self) -> Result<()> { + self.check_encryption_option()?; + self.check_recovery_option()?; + self.check_redirection_targets()?; + if !self.streams_rar50() + && (self.archive_metadata.is_some() || self.locked || self.quick_open) + { + return Err(Error::InvalidArgument( + "archive metadata settings require the RAR5/7 streaming writer", + )); + } + if self.entries.is_empty() && !self.streams_rar50() { + return Err(Error::InvalidArgument("archive builder has no entries")); + } + if self.volume_size.is_some() { + return Err(Error::InvalidArgument( + "use build_volumes for multivolume archives", + )); + } + Ok(()) + } + + /// Legacy volume collection needs its one input as a slice. Borrow an + /// inline input; read a source without copying any other member payloads. + fn materialized_volume_input( + &self, + progress: Option>, + ) -> Result> { + check_cancelled(progress)?; + // The caller has validated the legacy volume path and its one input. + if !self.entries.iter().any(|entry| entry.source.is_some()) { + return Ok(std::borrow::Cow::Borrowed(self)); + } + let mut owned = self.clone(); + for entry in &mut owned.entries { + if let Some(source) = entry.source.take() { + entry.data = crate::write_stream::MemberBytes::Source(&source) + .load_with_progress(progress) + .map_err(|error| { + crate::write_stream::member_error(error, &entry.name, "reading source") + })? + .into_owned(); + source.release(); + } + } + Ok(std::borrow::Cow::Owned(owned)) + } + + fn write_legacy_to( + &self, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + match self.format.family() { + ArchiveFamily::Rar50Plus => unreachable!("RAR 5/7 use the streaming writer"), + ArchiveFamily::Rar15To40 => self.write_rar15_single(output, resources, progress), + ArchiveFamily::Rar13 => self.write_rar13_single(output, resources, progress), + } + } + + fn features(&self) -> FeatureSet { + let mut features = FeatureSet::store_only(); + features.solid = self.solid; + features.header_encryption = self.encrypt_headers; + features.quick_open = self.quick_open; + features + } + + /// Storing is a compression level, not a kind of member, so `store` wins + /// over any level the caller asked for. + fn rar50_options(&self) -> rar50::WriterOptions { + let mut options = rar50::WriterOptions::new(self.format, self.features()); + if let Some(size) = self.rar50_dictionary_size { + options = options.with_dictionary_size(size); + } + if let Some(level) = self.compression { + options = options.with_compression_level(level); + } + if self.store { + options = options.with_compression_level(0); + } + options + } + + /// Whether to look for a data filter, which the archive has to be able to + /// carry. One answer for every RAR 5 path: when the streaming writer worked + /// this out for itself, an archive built from bytes came out unfiltered and + /// larger than the same archive built from files. + fn rar50_filter_policy(&self) -> rar50::FilterPolicy { + if self.solid || self.store { + rar50::FilterPolicy::None + } else { + rar50::FilterPolicy::Auto + } + } + + fn rar50_entries_with_resources( + &self, + resources: &WriterResources, + ) -> Result { + let mut charge = resources.execution_charge(); + if let Some(charge) = &mut charge { + let mut capacity = self + .entries + .len() + .checked_mul(std::mem::size_of::()) + .ok_or(Error::InvalidArgument("converted entry capacity overflows"))?; + for entry in &self.entries { + let data_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |e| e.data_password.as_deref()); + let comment_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |e| e.comment_password.as_deref()); + for bytes in [ + entry.name.len(), + entry + .redirection + .as_ref() + .map_or(0, |r| r.target_name.len()), + data_password.map_or(0, <[u8]>::len), + ] { + capacity = capacity + .checked_add(bytes) + .ok_or(Error::InvalidArgument("converted entry capacity overflows"))?; + } + if let Some(comment) = &entry.file_comment { + for bytes in [ + std::mem::size_of::(), + 3, + comment.len(), + comment_password.map_or(0, <[u8]>::len), + ] { + capacity = capacity.checked_add(bytes).ok_or(Error::InvalidArgument( + "converted service capacity overflows", + ))?; + } + } + } + charge.grow_to(capacity as u64)?; + } + let mut entries = Vec::with_capacity(self.entries.len()); + for entry in &self.entries { + let source = match &entry.source { + Some(source) => source.clone(), + None => EntrySource::copy_for_writer(&entry.data, resources)?, + }; + let built = rar50::ArchiveEntry::new(entry.name.clone(), source) + .with_directory(entry.is_directory) + .with_redirection(entry.redirection.clone()) + .with_redirection_size(entry.redirection_size) + .with_mtime(entry.mtime) + .with_mtime_nanoseconds(entry.mtime_nanoseconds) + .with_file_times(entry.file_times) + .with_attributes(entry.rar50_attr()) + .with_host_os(entry.rar50_host_os()); + let data_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.data_password.as_deref() + }); + let comment_password = entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.comment_password.as_deref() + }); + let built = match &entry.file_comment { + Some(comment) => { + let service = rar50::ServiceEntry::new(b"CMT".to_vec(), comment.clone()); + let service = match comment_password { + Some(password) => service.with_password(password.to_vec()), + None => service, + }; + let mut built = built; + built.services = vec![service]; + built + } + None => built, + }; + entries.push(match data_password { + Some(password) => built.with_password(password.to_vec()), + None => built, + }); + } + Ok(ConvertedEntries { + entries, + _charge: charge, + }) + } + + fn write_streaming_rar50( + &self, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + let mut extras = rar50::ArchiveExtras::default() + .with_recovery_percent(self.recovery_percent) + .with_filter_policy(self.rar50_filter_policy()); + extras.metadata_record = self.archive_metadata.as_ref(); + extras.locked = self.locked; + if self.encrypt_headers { + extras.header_password = self.password.as_deref(); + } + if let Some(comment) = self.comment.as_deref() { + extras = match self.comment_password.as_deref() { + Some(password) => extras.with_encrypted_comment(comment, password), + None => extras.with_comment(comment), + }; + } + let converted = self.rar50_entries_with_resources(resources)?; + rar50::write_streaming_archive_with_progress( + &converted.entries, + self.rar50_options(), + extras, + resources, + progress, + output, + ) + } + + fn rar15_options(&self) -> rar15_40::WriterOptions { + let mut options = rar15_40::WriterOptions::new(self.format, self.features()); + options.archive_comment_metadata = self.legacy_archive_comment_metadata; + if let Some(level) = self.compression { + options = options.with_compression_level(level); + } + options + } + + fn write_rar15_single( + &self, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + let entries: Vec<_> = self + .entries + .iter() + .map(|entry| rar15_40::RetainedFileEntry { + source: entry.source.as_ref(), + file: rar15_40::FileEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar15_attr(), + host_os: entry.rar15_host_os(), + password: entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.data_password.as_deref() + }), + file_comment: entry.file_comment.as_deref(), + }, + metadata: rar15_40::RetainedMemberMetadata { + unicode_name: entry.legacy_unicode_name.as_deref(), + unpack_version: self.legacy_unpack_version, + extended_times: entry.legacy_extended_times.as_deref(), + is_directory: entry.is_directory, + is_symlink: matches!(entry.attributes, EntryAttributes::Unix(mode) if mode & 0o170000 == 0o120000), + }, + }) + .collect(); + rar15_40::write_archive_with_retained_metadata( + &entries, + self.rar15_options(), + if self.store { + crate::write_plan::MemberCoding::Stored + } else { + crate::write_plan::MemberCoding::Compressed + }, + self.comment.as_deref(), + resources, + progress, + self.encrypt_headers + .then_some(self.password.as_deref()) + .flatten(), + self.comment_password.as_deref(), + output, + ) + } + + fn rar13_options(&self) -> rar13::WriterOptions { + let mut options = rar13::WriterOptions::new(self.format, self.features()); + if let Some(level) = self.compression { + options = options.with_compression_level(level); + } + options + } + + fn write_rar13_single( + &self, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + ) -> Result<()> { + let entries: Vec<_> = self + .entries + .iter() + .map(|entry| rar13::BorrowedFileEntry { + file: rar13::FileEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar13_attr(), + password: entry + .encryption + .as_ref() + .map_or(self.password.as_deref(), |encryption| { + encryption.data_password.as_deref() + }), + file_comment: entry.file_comment.as_deref(), + }, + source: entry.source.as_ref(), + }) + .collect(); + rar13::write_archive_with_sources( + &entries, + self.rar13_options(), + if self.store { + crate::write_plan::MemberCoding::Stored + } else { + crate::write_plan::MemberCoding::Compressed + }, + self.comment.as_deref(), + resources, + progress, + output, + ) + } + + fn single_volume_entry(&self) -> Result<&BuilderEntry> { + match self.entries.as_slice() { + [entry] => Ok(entry), + _ => Err(Error::InvalidArgument("legacy volumes support one input")), + } + } + + fn build_rar15_volumes( + &self, + volume_size: usize, + progress: Option<&dyn WriteProgress>, + ) -> Result>> { + let entry = self.single_volume_entry()?; + let options = self.rar15_options(); + if self.store { + rar15_40::write_stored_volumes_with_progress( + rar15_40::StoredEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar15_attr(), + host_os: entry.rar15_host_os(), + password: self.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + }, + options, + volume_size, + progress, + ) + } else { + rar15_40::write_compressed_volumes_with_progress( + rar15_40::FileEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar15_attr(), + host_os: entry.rar15_host_os(), + password: self.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + }, + options, + volume_size, + progress, + ) + } + } + + fn build_rar13_volumes( + &self, + volume_size: usize, + progress: Option<&dyn WriteProgress>, + ) -> Result>> { + let entry = self.single_volume_entry()?; + let options = self.rar13_options(); + if self.store { + rar13::write_stored_volumes_with_progress( + rar13::StoredEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar13_attr(), + password: self.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + }, + options, + volume_size, + progress, + ) + } else { + rar13::write_compressed_volumes_with_progress( + rar13::FileEntry { + name: &entry.name, + data: &entry.data, + file_time: entry.mtime.unwrap_or(0), + file_attr: entry.rar13_attr(), + password: self.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + }, + options, + volume_size, + progress, + ) + } + } +} + +// Retain the established public paths while the implementations live with +// the reader filename utilities. +pub use crate::filename::{entry_relative_path, validate_entry_name}; + +#[cfg(unix)] +fn unix_mode(metadata: &fs::Metadata) -> Option { + use std::os::unix::fs::PermissionsExt; + Some(metadata.permissions().mode()) +} + +#[cfg(not(unix))] +fn unix_mode(_metadata: &fs::Metadata) -> Option { + None +} + +#[cfg(test)] +mod tests { + #[test] + fn pending_archive_retries_name_collisions_and_reports_exhaustion() { + let root = crate::scratch::case("pending-archive-collision"); + let destination = root.join("archive.rar"); + let name = |sequence| format!(".rars-writing-{}-{sequence:016x}", std::process::id()); + std::fs::write(root.join(name(0)), b"occupied").unwrap(); + let resources = crate::WriterResources::default().with_temp_dir(&*root); + let mut sequence = 0; + let (pending, file) = + super::PendingArchive::with_sequence(&destination, &resources, || { + let value = sequence; + sequence += 1; + value + }) + .unwrap(); + assert_eq!(sequence, 2); + assert_eq!(pending.path.as_deref(), Some(root.join(name(1)).as_path())); + drop(file); + drop(pending); + + for sequence in 1..128 { + std::fs::write(root.join(name(sequence)), b"occupied").unwrap(); + } + let mut sequence = 0; + let error = super::PendingArchive::with_sequence(&destination, &resources, || { + let value = sequence; + sequence += 1; + value + }) + .err() + .unwrap(); + assert_eq!(sequence, 128); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!(std::fs::read(root.join(name(0))).unwrap(), b"occupied"); + + let missing = root.join("missing/archive.rar"); + let error = super::PendingArchive::with_sequence(&missing, &resources, || 0) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + } + + #[test] + fn converted_rar50_entries_charge_encrypted_comment_storage() { + let resources = crate::WriterResources::default().with_max_memory_bytes(1 << 20); + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50); + builder + .add_source( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".as_slice()), + None, + None, + ) + .unwrap(); + let baseline = builder.rar50_entries_with_resources(&resources).unwrap(); + let baseline_charge = resources.managed_memory_in_use(); + drop(baseline); + assert_eq!(resources.managed_memory_in_use(), 0); + + let comment = b"private comment"; + let password = b"password"; + builder + .set_file_comment(b"file", Some(comment.to_vec())) + .unwrap(); + builder + .set_entry_encryption(b"file", None, Some(password.to_vec())) + .unwrap(); + let converted = builder.rar50_entries_with_resources(&resources).unwrap(); + assert_eq!( + resources.managed_memory_in_use() - baseline_charge, + (std::mem::size_of::() + 3 + comment.len() + password.len()) + as u64 + ); + drop(converted); + assert_eq!(resources.managed_memory_in_use(), 0); + } + + #[test] + fn builder_rejects_legacy_volume_directory_and_metadata_settings() { + use crate::{ArchiveVersion, Builder, ErrorKind}; + + let mut volume = Builder::new(ArchiveVersion::Rar29).volume_size(Some(64)); + assert_eq!( + volume + .add_directory(b"dir".to_vec(), None, None) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + assert_eq!( + Builder::new(ArchiveVersion::Rar29) + .archive_metadata(None, false, false) + .err() + .unwrap() + .kind(), + ErrorKind::InvalidArgument + ); + } + + #[test] + fn builder_rejects_invalid_retained_archive_metadata_at_setter() { + let record = crate::rar50::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: None, + }; + let error = crate::Builder::new(crate::ArchiveVersion::Rar50) + .archive_metadata(Some(record), false, false) + .err() + .unwrap(); + assert_eq!( + error, + crate::Error::InvalidArgument("unsupported archive metadata record") + ); + } + + #[test] + fn builder_refuses_retained_archive_metadata_in_volume_output() { + let record = crate::rar50::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: Some(123), + }; + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50) + .archive_metadata(Some(record), false, false) + .unwrap() + .volume_size(Some(64)); + builder + .add_source( + b"file".to_vec(), + crate::EntrySource::from_opener(1, || panic!("volume refusal opened source")), + None, + None, + ) + .unwrap(); + assert_eq!( + builder.to_bytes().unwrap_err(), + crate::Error::InvalidArgument( + "archive metadata settings require the RAR5/7 streaming writer" + ) + ); + assert_eq!( + builder.build_volumes(None).unwrap_err(), + crate::Error::InvalidArgument( + "archive metadata settings are not supported in volume output" + ) + ); + } + + #[test] + fn renaming_a_member_to_its_existing_name_preserves_its_identity() { + use crate::{ArchiveReader, ArchiveVersion, Builder}; + + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let id = builder.entry_id(b"file").unwrap(); + builder.rename_by_id(id, b"file".to_vec()).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } + + #[test] + fn builder_rejects_unsupported_per_entry_password_shapes() { + use crate::{ArchiveVersion, Builder, ErrorKind}; + + for format in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert_eq!( + builder + .set_entry_encryption(b"file", Some(Vec::new()), None) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + assert_eq!( + builder + .set_entry_encryption(b"file", None, Some(Vec::new())) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + if format != ArchiveVersion::Rar50 { + assert_eq!( + builder + .set_entry_encryption(b"file", None, Some(b"comment".to_vec())) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + } + } + + let mut volume = Builder::new(ArchiveVersion::Rar29) + .store(true) + .volume_size(Some(64)); + volume + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert_eq!( + volume + .set_entry_encryption(b"file", Some(b"password".to_vec()), None) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn rar13_entry_encryption_override_can_clear_the_builder_password() { + use crate::{ArchiveReader, ArchiveVersion, Builder}; + + for store in [false, true] { + let mut builder = Builder::new(ArchiveVersion::Rar13) + .store(store) + .password(Some(b"default password".to_vec())); + builder + .add_bytes(b"plain".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.set_entry_encryption(b"plain", None, None).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"plain", None).unwrap().unwrap(), + b"payload" + ); + } + } + + #[test] + fn legacy_builder_combines_inline_and_source_members() { + use crate::{ArchiveReader, ArchiveVersion, Builder, EntrySource}; + + let mut builder = Builder::new(ArchiveVersion::Rar29).store(true); + builder + .add_bytes(b"bytes".to_vec(), b"in memory".to_vec(), None, None) + .unwrap(); + builder + .add_source( + b"source".to_vec(), + EntrySource::from_bytes(b"from source".as_slice()), + None, + None, + ) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"bytes", None).unwrap().unwrap(), + b"in memory" + ); + assert_eq!( + archive.read_member(b"source", None).unwrap().unwrap(), + b"from source" + ); + } + + #[test] + fn retained_unpack_version_cannot_be_written_to_legacy_volumes() { + use crate::{ArchiveVersion, Builder, Error}; + + let mut builder = Builder::new(ArchiveVersion::Rar29) + .store(true) + .volume_size(Some(64)) + .legacy_unpack_version(Some(29)); + builder + .add_bytes(b"file".to_vec(), b"data".to_vec(), None, None) + .unwrap(); + assert_eq!( + builder.build_volumes(None).unwrap_err(), + Error::InvalidArgument( + "retained legacy unpacker version requires single-archive output" + ) + ); + } + + #[test] + fn replacing_source_keeps_metadata_and_refuses_entry_kind_changes() { + use crate::{ArchiveReader, ArchiveVersion, Builder, EntrySource, ErrorKind}; + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"old".to_vec(), Some(123), Some(0o640)) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"comment".to_vec())) + .unwrap(); + builder.add_directory(b"dir".to_vec(), None, None).unwrap(); + builder + .add_unix_symlink(b"link".to_vec(), b"file".to_vec(), false, None, None) + .unwrap(); + for name in [b"dir".as_slice(), b"link"] { + assert_eq!( + builder + .set_source(name, EntrySource::from_bytes(b"bad".as_slice())) + .unwrap_err() + .kind(), + ErrorKind::InvalidArgument + ); + } + assert_eq!( + builder + .set_source(b"missing", EntrySource::from_bytes(b"bad".as_slice())) + .unwrap_err() + .kind(), + ErrorKind::EntryNotFound + ); + builder + .set_source(b"file", EntrySource::from_bytes(b"replacement".as_slice())) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members[0].meta.name, b"file"); + assert_eq!(members[0].meta.file_time, Some(123)); + assert_eq!(members[0].meta.file_attr & 0o7777, 0o640); + assert_eq!( + archive.member_comment_at(0, None).unwrap(), + Some(b"comment".to_vec()) + ); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"replacement" + ); + assert!(members[1].meta.is_directory); + assert!(members[2].meta.is_redirection); + } + + use super::*; + + #[test] + fn legacy_directory_metadata_and_link_payloads_survive_solid_output() { + let mut builder = Builder::new(ArchiveVersion::Rar29).solid(true); + builder + .add_bytes(b"file".to_vec(), b"payload".repeat(100), Some(0), None) + .unwrap(); + builder + .add_directory(b"directory".to_vec(), Some(0), Some(0o2750)) + .unwrap(); + builder + .set_file_comment(b"directory", Some(b"comment".to_vec())) + .unwrap(); + builder + .set_legacy_extended_times(b"directory", Some(vec![0, 0xb0, 1, 2, 3])) + .unwrap(); + builder + .add_unix_symlink(b"link".to_vec(), b"file".to_vec(), false, Some(0), None) + .unwrap(); + builder + .add_bytes(b"last".to_vec(), b"payload".repeat(100), Some(0), None) + .unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + let files: Vec<_> = archive.as_rar15_40().unwrap().files().collect(); + assert!(files[1].is_directory()); + assert_eq!(files[1].attr, 0o042750); + assert_eq!(files[1].pack_size, 0); + assert_eq!(files[1].ext_time, [0, 0xb0, 1, 2, 3]); + assert_eq!( + archive.member_comment_at(1, None).unwrap(), + Some(b"comment".to_vec()) + ); + assert!(files[2].is_stored()); + assert_eq!( + archive.legacy_symlink_target_at(2, None).unwrap(), + Some(b"file".to_vec()) + ); + assert_eq!( + archive.read_member(b"last", None).unwrap().unwrap(), + b"payload".repeat(100) + ); + assert!(builder.volume_size(Some(128)).build_volumes(None).is_err()); + } + + #[test] + #[cfg(feature = "encryption")] + fn legacy_comments_coexist_with_salt_and_extended_times() { + let mut builder = Builder::new(ArchiveVersion::Rar29) + .password(Some(b"secret".to_vec())) + .comment(Some(b"archive".to_vec())); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(0), None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"comment".to_vec())) + .unwrap(); + builder + .set_legacy_extended_times(b"file", Some(vec![0, 0xb0, 1, 2, 3])) + .unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + assert_eq!( + archive.member_comment_at(0, Some(b"secret")).unwrap(), + Some(b"comment".to_vec()) + ); + assert_eq!( + archive + .read_member(b"file", Some(b"secret")) + .unwrap() + .unwrap(), + b"payload" + ); + assert_eq!( + archive + .as_rar15_40() + .unwrap() + .files() + .next() + .unwrap() + .ext_time, + [0, 0xb0, 1, 2, 3] + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn legacy_header_encryption_survives_removing_encrypted_member() { + let mut builder = Builder::new(ArchiveVersion::Rar30) + .password(Some(b"secret".to_vec())) + .header_encryption(true); + builder + .add_bytes(b"plain".to_vec(), b"public".to_vec(), Some(0), None) + .unwrap(); + builder.set_entry_encryption(b"plain", None, None).unwrap(); + builder + .add_bytes(b"encrypted".to_vec(), b"private".to_vec(), Some(0), None) + .unwrap(); + // Salt and native extended times must coexist in encrypted file headers. + builder + .set_legacy_extended_times(b"encrypted", Some(vec![0, 0xb0, 1, 2, 3])) + .unwrap(); + for remove in [false, true] { + if remove { + builder.remove(b"encrypted").unwrap(); + } + let data = builder.to_bytes().unwrap(); + assert!(matches!( + crate::ArchiveReader::read(&data), + Err(Error::NeedPassword) + )); + let archive = crate::ArchiveReader::read_owned_with_options( + data, + crate::ArchiveReadOptions::with_password(b"secret"), + ) + .unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + assert!(archive.as_rar15_40().unwrap().main.has_encrypted_headers()); + assert!(!archive + .as_rar15_40() + .unwrap() + .files() + .next() + .unwrap() + .is_encrypted()); + assert_eq!( + archive + .read_member(b"plain", if remove { None } else { Some(b"secret") }) + .unwrap() + .unwrap(), + b"public" + ); + if !remove { + assert_eq!( + archive + .read_member(b"encrypted", Some(b"secret")) + .unwrap() + .unwrap(), + b"private" + ); + assert_eq!( + archive + .as_rar15_40() + .unwrap() + .files() + .nth(1) + .unwrap() + .ext_time, + [0, 0xb0, 1, 2, 3] + ); + } + } + assert!(builder + .clone() + .volume_size(Some(128)) + .build_volumes(None) + .is_err()); + builder + .set_entry_encryption(b"plain", Some(b"different".to_vec()), None) + .unwrap(); + assert!(builder.to_bytes().is_err()); + } + + #[test] + fn native_legacy_times_survive_writes_and_rejected_changes() { + // Fractional odd-second mtime and an archival DOS timestamp. + let raw = vec![0x08, 0xf0, 1, 2, 3, 0, 0, 0, 0]; + for store in [true, false] { + let mut builder = Builder::new(ArchiveVersion::Rar40).store(store); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(0), None) + .unwrap(); + builder + .set_legacy_extended_times(b"file", Some(raw.clone())) + .unwrap(); + let before = builder.to_bytes().unwrap(); + assert!(builder + .set_legacy_extended_times(b"file", Some(vec![0, 0xf0])) + .is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + let archive = crate::ArchiveReader::read_owned(before).unwrap(); + assert_eq!( + archive + .as_rar15_40() + .unwrap() + .files() + .next() + .unwrap() + .ext_time, + raw + ); + assert!(archive.rewrite_preservation_issues().is_empty()); + assert!(builder + .clone() + .volume_size(Some(128)) + .build_volumes(None) + .is_err()); + builder.set_legacy_extended_times(b"file", None).unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(!archive + .as_rar15_40() + .unwrap() + .files() + .next() + .unwrap() + .has_ext_time()); + } + } + + #[test] + fn empty_rewrites_retain_archive_settings() { + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for encrypted in crate::test_features::encryption_cases() { + let password = encrypted.then_some(b"secret".as_slice()); + let builder = Builder::new(format) + .solid(true) + .password(password.map(<[u8]>::to_vec)) + .header_encryption(encrypted) + .recovery_percent(cfg!(feature = "recovery").then_some(5)) + .comment(Some(b"comment".to_vec())); + let options = crate::ArchiveReadOptions { + password, + ..Default::default() + }; + let archive = crate::ArchiveReader::read_owned_with_options( + builder.to_bytes().unwrap(), + options, + ) + .unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + let rewritten = archive + .preserving_builder(password) + .unwrap() + .comment(Some(b"comment".to_vec())) + .to_bytes() + .unwrap(); + let output = + crate::ArchiveReader::read_owned_with_options(rewritten, options).unwrap(); + let raw = output.as_rar50().unwrap(); + assert!(raw.main.is_solid()); + assert_eq!(raw.main.has_recovery_record(), cfg!(feature = "recovery")); + assert_eq!(raw.main.encrypted_headers, encrypted); + assert_eq!(raw.files().count(), 0); + assert!(output.rewrite_preservation_issues().is_empty()); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn header_encryption_does_not_require_encrypted_members() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .password(Some(b"secret".to_vec())) + .header_encryption(true); + builder + .add_bytes(b"plain".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.set_entry_encryption(b"plain", None, None).unwrap(); + let archive = crate::ArchiveReader::read_owned_with_options( + builder.to_bytes().unwrap(), + crate::ArchiveReadOptions::with_password(b"secret"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.encrypted_headers); + assert!(!raw.files().next().unwrap().encrypted); + assert_eq!( + archive.read_member(b"plain", None).unwrap().unwrap(), + b"payload" + ); + assert!(archive.rewrite_preservation_issues().is_empty()); + } + + #[cfg(unix)] + #[test] + fn add_path_preserves_non_utf8_child_names() { + use std::ffi::OsStr; + use std::os::unix::ffi::OsStrExt; + + let root = crate::scratch::case("builder-non-utf8-name"); + let raw_source = root.join(OsStr::from_bytes(b"bad-\xff")); + let native_name = match fs::write(&raw_source, b"payload") { + Ok(()) => b"bad-\xff".as_slice(), + Err(error) + if error.kind() == std::io::ErrorKind::InvalidInput + || error.raw_os_error() == Some(libc::EILSEQ) => + { + // Some Unix filesystems reject byte names. The builder must + // report the missing/unrepresentable source, never queue a + // substituted filename or silently claim it was archived. + for format in ArchiveVersion::ALL { + let mut builder = Builder::new(format); + let error = builder.add_path(&raw_source, b"explicit").unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert!(builder.is_empty()); + } + // Continue exercising collection and explicit naming in every + // format with a name this filesystem can actually represent. + let name = "valid-日本語".as_bytes(); + fs::write(root.join(OsStr::from_bytes(name)), b"payload").unwrap(); + name + } + Err(error) => panic!("raw filename probe failed unexpectedly: {error}"), + }; + let source = root.join(OsStr::from_bytes(native_name)); + for format in ArchiveVersion::ALL { + let mut builder = Builder::new(format); + for unsafe_name in [b"../bad-\xff".as_slice(), b"/bad-\xff"] { + assert!(builder.add_path(&source, unsafe_name).is_err()); + assert!(builder.is_empty()); + } + builder.add_path(&root, b"root").unwrap(); + let native_archive_name = [b"root/".as_slice(), native_name].concat(); + let name = if format.family() == ArchiveFamily::Rar50Plus { + crate::filename::encode_rar50(&native_archive_name).into_owned() + } else { + native_archive_name + }; + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(&name, None).unwrap().unwrap(), + b"payload" + ); + // The same native source can also have an explicit archive name. + builder.add_path(&source, b"explicit").unwrap(); + assert_eq!( + builder.names().collect::>(), + vec![name.as_slice(), &b"explicit"[..]] + ); + } + } + + #[test] + fn add_path_preserves_unicode_child_names_and_contents() { + let root = crate::scratch::case("builder-unicode-names"); + fs::create_dir(root.join("日本語")).unwrap(); + for name in ["日本語", "кириллица", "replacement-\u{fffd}"] { + fs::write(root.join("日本語").join(name), name.as_bytes()).unwrap(); + } + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder.add_path(&root, b"root").unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + for name in ["日本語", "кириллица", "replacement-\u{fffd}"] { + let member_name = format!("root/日本語/{name}"); + assert_eq!( + archive + .read_member(member_name.as_bytes(), None) + .unwrap() + .unwrap(), + name.as_bytes() + ); + } + } + + fn builder_with(format: ArchiveVersion) -> Builder { + let mut builder = Builder::new(format); + builder + .add_bytes(b"a.txt".to_vec(), b"hello world".repeat(64), None, None) + .unwrap(); + builder + .add_bytes(b"dir/b.txt".to_vec(), b"second member".to_vec(), None, None) + .unwrap(); + builder + } + + /// Every version this crate can write, which is all of them. The loop is + /// over `ArchiveVersion::ALL` so a tenth version is a failing test rather + /// than a gap. + #[test] + fn writes_every_family() { + for format in ArchiveVersion::ALL { + let archive = builder_with(format).to_bytes().unwrap(); + let read = crate::ArchiveReader::read_owned(archive).unwrap(); + let names: Vec<_> = read + .members() + .map(|member| member.meta.name_bytes().to_vec()) + .collect(); + assert_eq!( + names, + vec![b"a.txt".to_vec(), b"dir/b.txt".to_vec()], + "{format}" + ); + } + } + + #[test] + fn stored_and_compressed_round_trip_to_the_same_bytes() { + for store in [false, true] { + let archive = builder_with(ArchiveVersion::Rar50) + .store(store) + .to_bytes() + .unwrap(); + let read = crate::ArchiveReader::read_owned(archive).unwrap(); + let data = read.read_member(b"a.txt", None).unwrap().unwrap(); + assert_eq!(data, b"hello world".repeat(64)); + } + } + + #[test] + fn rejects_a_duplicate_name() { + let mut builder = Builder::new(ArchiveVersion::Rar50); + builder + .add_bytes(b"a".to_vec(), vec![], None, None) + .unwrap(); + let error = builder + .add_bytes(b"a".to_vec(), vec![], None, None) + .unwrap_err(); + assert!(error.to_string().contains("duplicate archive entry name")); + assert_eq!(builder.names().collect::>(), vec![&b"a"[..]]); + } + + #[test] + fn rejected_edits_preserve_a_usable_archive() { + let mut builder = builder_with(ArchiveVersion::Rar50).store(true); + let before = builder.to_bytes().unwrap(); + assert!(builder.rename(b"a.txt", b"dir/b.txt".to_vec()).is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + assert!(builder + .add_bytes(b"a.txt".to_vec(), b"replacement".to_vec(), None, None) + .is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + + builder.rename(b"a.txt", b"a.txt".to_vec()).unwrap(); + assert_eq!(builder.to_bytes().unwrap(), before); + builder.rename(b"a.txt", b"renamed.txt".to_vec()).unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"renamed.txt", None).unwrap().unwrap(), + b"hello world".repeat(64) + ); + } + + #[test] + fn legacy_byte_identity_survives_edits_without_unicode_validation() { + for format in ArchiveVersion::ALL { + if format.family() == ArchiveFamily::Rar50Plus { + continue; + } + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"old-\xff".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.rename(b"old-\xff", b"new-\xfe".to_vec()).unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"new-\xfe", None).unwrap().unwrap(), + b"payload" + ); + builder.remove(b"new-\xfe").unwrap(); + assert!(builder.is_empty()); + } + let mut modern = Builder::new(ArchiveVersion::Rar50); + assert!(modern + .add_bytes(b"old-\xff".to_vec(), vec![], None, None) + .is_err()); + } + + #[test] + fn rejects_an_escaping_name() { + let mut builder = Builder::new(ArchiveVersion::Rar50); + for name in [&b"../escape"[..], b"/absolute", b"C:\\drive"] { + assert!(builder + .add_bytes(name.to_vec(), vec![], None, None) + .is_err()); + } + } + + #[test] + fn renames_and_removes() { + let mut builder = builder_with(ArchiveVersion::Rar50); + builder.rename(b"a.txt", b"c.txt".to_vec()).unwrap(); + builder.remove(b"dir/b.txt").unwrap(); + assert_eq!(builder.names().collect::>(), vec![&b"c.txt"[..]]); + assert!(builder.remove(b"gone").is_err()); + assert!(builder.rename(b"gone", b"x".to_vec()).is_err()); + } + + #[test] + fn refuses_a_single_archive_when_a_volume_size_is_set() { + let error = builder_with(ArchiveVersion::Rar50) + .volume_size(Some(4096)) + .to_bytes() + .unwrap_err(); + assert!(error.to_string().contains("build_volumes")); + } + + #[test] + fn splits_into_volumes() { + let mut builder = Builder::new(ArchiveVersion::Rar50); + builder + .add_bytes(b"big.bin".to_vec(), vec![7u8; 300_000], None, None) + .unwrap(); + let volumes = builder + .store(true) + .volume_size(Some(64 * 1024)) + .build_volumes(None) + .unwrap(); + assert!(volumes.len() > 1, "expected a split, got {}", volumes.len()); + } +} + +#[cfg(test)] +#[test] +fn parentless_output_path_uses_default_resources_and_publishes_readable_archives() { + struct Destination(std::path::PathBuf); + impl Drop for Destination { + fn drop(&mut self) { + let _ = std::fs::remove_file(&self.0); + } + } + static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); + let sequence = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + let destination = Destination(std::path::PathBuf::from(format!( + ".rars-parentless-test-{}-{sequence}.rar", + std::process::id() + ))); + assert!(destination.0.parent().unwrap().as_os_str().is_empty()); + for version in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.write_to_path(&destination.0, None).unwrap(); + let archive = + crate::ArchiveReader::read_owned(std::fs::read(&destination.0).unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } +} + +#[cfg(test)] +#[test] +fn converted_redirections_charge_targets_and_preserve_them_in_output() { + let resources = WriterResources::default().with_max_memory_bytes(1 << 20); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_unix_symlink(b"link".to_vec(), b"a".to_vec(), false, None, None) + .unwrap(); + let short = builder.rar50_entries_with_resources(&resources).unwrap(); + let short_charge = resources.managed_memory_in_use(); + drop(short); + assert_eq!(resources.managed_memory_in_use(), 0); + let target = "destination-😀".as_bytes(); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_unix_symlink(b"link".to_vec(), target.to_vec(), false, None, None) + .unwrap(); + let converted = builder.rar50_entries_with_resources(&resources).unwrap(); + assert_eq!( + resources.managed_memory_in_use() - short_charge, + (target.len() - 1) as u64 + ); + assert_eq!( + converted.entries[0] + .redirection + .as_ref() + .unwrap() + .target_name, + target + ); + drop(converted); + assert_eq!(resources.managed_memory_in_use(), 0); + let bytes = builder.to_bytes_with_resources(&resources, None).unwrap(); + let archive = crate::ArchiveReader::read_owned(bytes).unwrap(); + let member = archive.members().next().unwrap(); + assert_eq!(member.unix_symlink().unwrap().target_name, target); + assert_eq!(resources.managed_memory_in_use(), 0); +} + +#[cfg(all(test, not(all(target_arch = "wasm32", target_os = "unknown"))))] +#[test] +fn pending_archive_accepts_maximum_sequence_without_a_destination_parent() { + let destination = Path::new(""); + assert!(destination.parent().is_none()); + let expected = std::path::PathBuf::from(format!( + ".rars-writing-{}-{:016x}", + std::process::id(), + u64::MAX + )); + assert!( + !expected.exists(), + "unique maximum-sequence path is already occupied" + ); + let resources = WriterResources::default().with_max_memory_bytes(1 << 20); + let (pending, file) = + PendingArchive::with_sequence(destination, &resources, || u64::MAX).unwrap(); + assert_eq!(pending.path.as_ref().unwrap(), &expected); + assert!(expected.is_file()); + assert!(expected.as_os_str().len() <= 41); + drop(file); + drop(pending); + assert!(!expected.exists()); + assert_eq!(resources.managed_memory_in_use(), 0); +} diff --git a/arca-rar/vendor/rars/src/codec/canonical.rs b/arca-rar/vendor/rars/src/codec/canonical.rs new file mode 100644 index 00000000..495895ed --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/canonical.rs @@ -0,0 +1,218 @@ +//! Canonical decoder mechanics shared by the explicit-table RAR formats. +//! Code-length parsing, diagnostics and bit input remain format-specific. +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; + +#[derive(Debug)] +pub(super) struct Huffman { + symbols: Buffer, + first_code: [u16; 16], + first_index: [usize; 16], + counts: [u16; 16], +} + +impl Huffman { + pub(super) fn with_allowance(allowance: &B) -> Self { + Self { + symbols: Buffer::new(allowance), + first_code: [0; 16], + first_index: [0; 16], + counts: [0; 16], + } + } + + /// `counts` has been checked for oversubscription and corresponds to + /// `lengths`; only nonzero lengths 1..=15 contribute symbols. Incomplete + /// tables are accepted: unused alphabets and unassigned prefixes occur in + /// the supported formats. Invalid prefixes are rejected when decoded. + pub(super) fn from_counts(lengths: &[u8], counts: [u16; 16], allowance: &B) -> Result { + let mut first_code = [0u16; 16]; + let mut code = 0u16; + for len in 1..=15 { + code = (code + counts[len - 1]) << 1; + first_code[len] = code; + } + let mut first_index = [0usize; 16]; + let mut index = 0usize; + for len in 1..=15 { + first_index[len] = index; + index += usize::from(counts[len]); + } + // Codes of one length follow alphabet order. Scatter directly into + // those ranges instead of storing (code, length, symbol) and sorting. + // Keep usize indices: the public RAR5 constructor also accepts sparse + // alphabets whose symbol index exceeds a 16-bit value. + let mut symbols = Buffer::filled(index, 0, allowance)?; + let mut next_index = first_index; + for (symbol, &len) in lengths.iter().enumerate() { + if len == 0 { + continue; + } + symbols[next_index[len as usize]] = symbol; + next_index[len as usize] += 1; + } + Ok(Self { + symbols, + first_code, + first_index, + counts, + }) + } + + pub(super) fn try_clone(&self) -> Result { + Ok(Self { + symbols: Buffer::copied(&self.symbols, &self.symbols.allowance())?, + first_code: self.first_code, + first_index: self.first_index, + counts: self.counts, + }) + } + #[cfg(test)] + pub(super) fn len(&self) -> usize { + self.symbols.len() + } + pub(super) fn is_empty(&self) -> bool { + self.symbols.is_empty() + } + + /// Read only the bits of the selected code. A speculative wide peek would + /// change truncation and incremental-input behavior near an input boundary. + pub(super) fn decode( + &self, + mut read_bit: impl FnMut() -> Result, + empty: &'static str, + invalid: &'static str, + ) -> Result { + if self.is_empty() { + return Err(Error::InvalidData(empty)); + } + let mut code = 0u16; + for len in 1..=15 { + code = (code << 1) | read_bit()?; + let count = self.counts[len]; + if count != 0 { + let offset = code.wrapping_sub(self.first_code[len]); + if offset < count { + let index = self.first_index[len] + usize::from(offset); + return Ok(self.symbols[index]); + } + } + } + Err(Error::InvalidData(invalid)) + } +} + +pub(super) fn validate_counts(counts: &[u16; 16], oversubscribed: &'static str) -> Result<()> { + let mut available = 1i32; + for &count in counts.iter().skip(1) { + available = (available << 1) - i32::from(count); + if available < 0 { + return Err(Error::InvalidData(oversubscribed)); + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn pinned_codes_keep_alphabet_indices_and_consume_only_their_bits() { + let lengths = [3, 0, 1, 3, 2]; + let mut counts = [0; 16]; + counts[1] = 1; + counts[2] = 1; + counts[3] = 2; + let table = Huffman::from_counts(&lengths, counts, &Allowance::default()).unwrap(); + assert_eq!(table.len(), 4); + // Canonical order is (length, alphabet index): 2=0, 4=10, + // 0=110, 3=111. Each input ends exactly at the selected code. + for (symbol, bits) in [ + (2, vec![0]), + (4, vec![1, 0]), + (0, vec![1, 1, 0]), + (3, vec![1, 1, 1]), + ] { + let mut input = bits.into_iter(); + assert_eq!( + table.decode( + || input.next().ok_or(Error::NeedMoreInput), + "empty", + "invalid" + ), + Ok(symbol) + ); + assert_eq!(input.next(), None); + } + } + + #[test] + fn empty_invalid_truncated_and_cancelled_codes_keep_their_errors() { + let table = Huffman::with_allowance(&Allowance::default()); + assert_eq!( + table.decode( + || panic!("empty table must not read input"), + "empty", + "invalid" + ), + Err(Error::InvalidData("empty")) + ); + let mut counts = [0; 16]; + counts[2] = 1; + validate_counts(&counts, "oversubscribed").unwrap(); + let table = Huffman::from_counts(&[2], counts, &Allowance::default()).unwrap(); + assert_eq!( + table.decode(|| Ok(1), "empty", "invalid"), + Err(Error::InvalidData("invalid")) + ); + assert_eq!( + table.decode(|| Err(Error::NeedMoreInput), "empty", "invalid"), + Err(Error::NeedMoreInput) + ); + assert_eq!( + table.decode(|| Err(Error::Cancelled), "empty", "invalid"), + Err(Error::Cancelled) + ); + } + + #[test] + fn table_and_checkpoint_allocations_are_admitted_and_released() { + let mut counts = [0; 16]; + counts[1] = 2; + let allowance = Allowance::limited(64 * 1024); + let table = Huffman::from_counts(&[1, 1], counts, &allowance).unwrap(); + let retained = allowance.used(); + assert_eq!(retained, (2 * std::mem::size_of::()) as u64); + let copy = table.try_clone().unwrap(); + assert_eq!(allowance.used(), retained * 2); + drop(table); + assert_eq!(copy.decode(|| Ok(1), "empty", "invalid"), Ok(1)); + assert_eq!(allowance.used(), retained); + drop(copy); + assert_eq!(allowance.used(), 0); + let allowance = Allowance::limited(retained); + let table = Huffman::from_counts(&[1, 1], counts, &allowance).unwrap(); + assert!(matches!( + table.try_clone(), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(allowance.used(), retained); + drop(table); + assert_eq!(allowance.used(), 0); + assert!(matches!( + Huffman::from_counts(&[1, 1], counts, &Allowance::limited(0)), + Err(Error::WorkspaceLimitExceeded(_)) + )); + } + + #[test] + fn sparse_alphabet_keeps_the_full_symbol_index() { + let mut lengths = vec![0; 65_538]; + lengths[65_537] = 1; + let mut counts = [0; 16]; + counts[1] = 1; + let table = Huffman::from_counts(&lengths, counts, &Allowance::default()).unwrap(); + assert_eq!(table.decode(|| Ok(0), "empty", "invalid"), Ok(65_537)); + } +} diff --git a/arca-rar/vendor/rars/src/codec/fast.rs b/arca-rar/vendor/rars/src/codec/fast.rs new file mode 100644 index 00000000..a1c08871 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/fast.rs @@ -0,0 +1,246 @@ +/// Append the low `count` bits most-significant first. Complete bytes are +/// extracted from a word; only the two edge bytes need masking. The final +/// partial byte stays zero-padded so callers can inspect or resume the buffer. +#[inline] +#[cfg(any(test, feature = "write"))] +pub(crate) fn write_msb_bits( + bytes: &mut Vec, + bit_pos: &mut usize, + value: u64, + mut count: usize, +) { + debug_assert!(count <= 64); + debug_assert_eq!(bytes.len(), (*bit_pos).div_ceil(8)); + if count == 0 { + return; + } + let used = *bit_pos % 8; + *bit_pos += count; + if used != 0 { + let take = count.min(8 - used); + count -= take; + let mask = ((1u16 << take) - 1) as u8; + *bytes.last_mut().unwrap() |= (((value >> count) as u8) & mask) << (8 - used - take); + } + if count == 0 { + return; + } + let whole = count / 8; + if whole != 0 { + let aligned = (value << (64 - count)).to_be_bytes(); + bytes.extend_from_slice(&aligned[..whole]); + } + let tail = count % 8; + if tail != 0 { + bytes.push((value as u8) << (8 - tail)); + } +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn match_length(input: &[u8], pos: usize, distance: usize, max_length: usize) -> usize { + // Encoders supply older match-finder candidates or remembered distances + // already admitted at an earlier position in this forward-moving parse. + debug_assert!(distance != 0 && distance <= pos); + + let max_length = max_length.min(input.len().saturating_sub(pos)); + match_length_scalar(input, pos, distance, max_length, 0) +} + +#[cfg(any(test, feature = "write"))] +fn match_length_scalar( + input: &[u8], + pos: usize, + distance: usize, + max_length: usize, + mut length: usize, +) -> usize { + while length + 32 <= max_length { + for offset in [0, 8, 16, 24] { + let current = u64::from_le_bytes( + input[pos + length + offset..pos + length + offset + 8] + .try_into() + .unwrap(), + ); + let previous = u64::from_le_bytes( + input[pos + length + offset - distance..pos + length + offset - distance + 8] + .try_into() + .unwrap(), + ); + let difference = current ^ previous; + if difference != 0 { + return length + offset + (difference.trailing_zeros() / 8) as usize; + } + } + length += 32; + } + while length + 8 <= max_length { + let current = u64::from_le_bytes(input[pos + length..pos + length + 8].try_into().unwrap()); + let previous = u64::from_le_bytes( + input[pos + length - distance..pos + length - distance + 8] + .try_into() + .unwrap(), + ); + let difference = current ^ previous; + if difference != 0 { + return length + (difference.trailing_zeros() / 8) as usize; + } + length += 8; + } + while length < max_length && input[pos + length] == input[pos + length - distance] { + length += 1; + } + length +} + +pub(crate) fn next_x86_opcode( + data: &[u8], + start: usize, + end_exclusive: usize, + cmp_mask: u8, +) -> Option { + let end = end_exclusive.min(data.len()); + if start >= end { + return None; + } + + data[start..end] + .iter() + .position(|&byte| byte & cmp_mask == 0xe8) + .map(|offset| start + offset) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn opcode_scan_clamps_the_end_and_handles_empty_extents() { + assert_eq!(next_x86_opcode(b"a\xe8b", 0, usize::MAX, 0xff), Some(1)); + assert_eq!(next_x86_opcode(b"a\xe8b", 2, usize::MAX, 0xff), None); + assert_eq!( + next_x86_opcode(b"a\xe8b", usize::MAX, usize::MAX, 0xff), + None + ); + assert_eq!(next_x86_opcode(b"a\xe8b", 1, 1, 0xff), None); + assert_eq!(next_x86_opcode(b"", 0, usize::MAX, 0xff), None); + } + + fn reference_match_length( + input: &[u8], + pos: usize, + distance: usize, + max_length: usize, + ) -> usize { + let mut length = 0usize; + while length < max_length && input[pos + length] == input[pos + length - distance] { + length += 1; + } + length + } + + #[test] + fn match_length_clamps_the_requested_extent_at_input_end() { + let input = b"abcdabcdabcdabcd"; + for pos in 1..=input.len() { + for distance in 1..=pos { + for requested in [0, 1, 3, 8, 32, usize::MAX] { + let available = requested.min(input.len() - pos); + assert_eq!( + match_length(input, pos, distance, requested), + reference_match_length(input, pos, distance, available), + "pos={pos}, distance={distance}, requested={requested}" + ); + } + } + } + // The public RAR13 match finder also permits positions past EOF. + // There are no bytes to compare, so no indexing is attempted. + assert_eq!(match_length(input, input.len() + 1, 1, usize::MAX), 0); + assert_eq!(match_length(input, usize::MAX, usize::MAX, usize::MAX), 0); + } + + #[test] + fn match_length_matches_scalar_around_chunk_boundaries() { + let mut input = Vec::new(); + input.extend((0..192).map(|index| (index % 251) as u8)); + input.extend_from_within(64..192); + + for distance in 1..=64 { + let pos = 192usize; + let max = (input.len() - pos).min(96); + let expected = reference_match_length(&input, pos, distance, max); + assert_eq!(match_length(&input, pos, distance, max), expected); + } + } + + #[test] + fn match_length_stops_at_first_mismatch_in_chunk_tail() { + let mut input = b"abcdefghijklmnopqrstuvwxyz012345".repeat(4); + let pos = 64; + input[pos + 37] ^= 0x55; + + assert_eq!( + match_length(&input, pos, 32, 64), + reference_match_length(&input, pos, 32, 64) + ); + } + + #[test] + fn x86_opcode_scan_matches_scalar_for_e8_and_e8e9() { + let mut data = vec![0x41u8; 96]; + for pos in [0, 31, 32, 33, 63, 64, 91] { + data[pos] = 0xe8; + } + data[47] = 0xe9; + + for &include_e9 in &[false, true] { + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let mut pos = 0usize; + let mut found = Vec::new(); + while let Some(next) = next_x86_opcode(&data, pos, data.len() - 4, cmp_mask) { + found.push(next); + pos = next + 1; + } + + let expected: Vec<_> = data + .iter() + .take(data.len() - 4) + .enumerate() + .filter_map(|(pos, &byte)| (byte & cmp_mask == 0xe8).then_some(pos)) + .collect(); + assert_eq!(found, expected); + } + } +} + +#[cfg(test)] +mod bit_output_tests { + use super::write_msb_bits; + + #[test] + fn word_output_matches_bit_reference_at_every_alignment_and_width() { + for offset in 0..8 { + for width in 0..=64 { + for value in [0, u64::MAX, 0x0123456789abcdef, 0xfedcba9876543210] { + let mut actual = Vec::new(); + let mut at = 0; + let mut expected = Vec::new(); + let mut bits = 0usize; + for (value, count) in [(0x55, offset), (value, width), (0x1234, 13)] { + write_msb_bits(&mut actual, &mut at, value, count); + for bit in (0..count).rev() { + if bits.is_multiple_of(8) { + expected.push(0); + } + *expected.last_mut().unwrap() |= + (((value >> bit) & 1) as u8) << (7 - bits % 8); + bits += 1; + } + assert_eq!(actual, expected, "offset={offset} width={width}"); + assert_eq!(at, bits); + } + } + } + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/filters.rs b/arca-rar/vendor/rars/src/codec/filters.rs new file mode 100644 index 00000000..3f8c9480 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/filters.rs @@ -0,0 +1,526 @@ +use super::{Error, Result}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[cfg(any(test, feature = "write"))] +pub(crate) enum FilterOp { + #[cfg(test)] + E8, + #[cfg(test)] + E8E9, + Delta { + channels: usize, + }, +} + +#[derive(Debug, Clone, Copy)] +pub(crate) struct DeltaErrorMessages { + pub invalid_channels: &'static str, + pub zero_channels: &'static str, + pub truncated_source: &'static str, +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn encode_in_place( + op: FilterOp, + data: &mut [u8], + file_offset: u32, + messages: DeltaErrorMessages, +) -> Result<()> { + let _ = file_offset; + match op { + #[cfg(test)] + FilterOp::E8 => e8e9_encode(data, file_offset, false), + #[cfg(test)] + FilterOp::E8E9 => e8e9_encode(data, file_offset, true), + FilterOp::Delta { channels } => { + let encoded = delta_encode(data, channels, messages)?; + data.copy_from_slice(&encoded); + } + } + Ok(()) +} + +/// Channel ceiling on the decode side. +/// +/// RAR 5 cannot exceed 32: its filter record stores `channels - 1` in five +/// bits. The RAR 2.9 VM takes the count from register R[0] instead, and the +/// reference decoder accepts up to 1024 there, so a decoder that stops at 32 +/// refuses archives the official tools extract. The bound still has to exist, +/// because R[0] is a full 32-bit value from the archive and the deinterleave +/// loop runs once per channel whether or not the channel has any bytes. +pub(crate) const MAX_DELTA_CHANNELS: usize = 1024; + +#[cfg(test)] +pub(crate) fn decode_in_place( + op: FilterOp, + data: &mut Vec, + file_offset: u32, + messages: DeltaErrorMessages, +) -> Result<()> { + decode_in_place_with_control( + op, + data, + file_offset, + messages, + &crate::read_control::ReadControl::default(), + ) +} + +#[cfg(test)] +pub(crate) fn decode_in_place_with_control( + op: FilterOp, + data: &mut Vec, + file_offset: u32, + messages: DeltaErrorMessages, + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + + match op { + #[cfg(test)] + FilterOp::E8 => e8e9_decode_with_control(data, file_offset, false, control)?, + #[cfg(test)] + FilterOp::E8E9 => e8e9_decode_with_control(data, file_offset, true, control)?, + FilterOp::Delta { channels } => { + *data = delta_decode_with_control(data, channels, messages, control)?; + } + } + Ok(()) +} + +#[cfg(test)] +pub(crate) fn e8e9_decode(data: &mut [u8], file_offset: u32, include_e9: bool) { + e8e9_decode_with_control( + data, + file_offset, + include_e9, + &crate::read_control::ReadControl::default(), + ) + .expect("uncancelled filter"); +} + +pub(crate) fn e8e9_decode_with_control( + data: &mut [u8], + file_offset: u32, + include_e9: bool, + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + let mut poller = control.poller(); + if data.len() <= 4 { + return Ok(()); + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let opcode_limit = data.len() - 4; + let mut opcode_pos = 0usize; + while opcode_pos < opcode_limit { + poller.check_codec(opcode_pos)?; + let scan_end = if control.is_enabled() { + opcode_limit.min(opcode_pos.saturating_add(64 * 1024)) + } else { + opcode_limit + }; + let Some(pos) = super::fast::next_x86_opcode(data, opcode_pos, scan_end, cmp_mask) else { + opcode_pos = scan_end; + continue; + }; + let cur_pos = pos + 1; + let offset = file_offset.wrapping_add(cur_pos as u32); + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let new_addr = if addr < 0x0100_0000 { + Some(addr.wrapping_sub(offset)) + } else if addr & 0x8000_0000 != 0 && addr.wrapping_add(offset) & 0x8000_0000 == 0 { + Some(addr.wrapping_add(0x0100_0000)) + } else { + None + }; + if let Some(value) = new_addr { + data[cur_pos..cur_pos + 4].copy_from_slice(&value.to_le_bytes()); + } + opcode_pos = pos + 5; + } + + Ok(()) +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn e8e9_encode(data: &mut [u8], file_offset: u32, include_e9: bool) { + if data.len() <= 4 { + return; + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let opcode_limit = data.len() - 4; + let mut opcode_pos = 0usize; + while let Some(pos) = super::fast::next_x86_opcode(data, opcode_pos, opcode_limit, cmp_mask) { + let cur_pos = pos + 1; + let offset = file_offset.wrapping_add(cur_pos as u32); + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let candidate = addr.wrapping_add(offset); + if candidate < 0x0100_0000 { + data[cur_pos..cur_pos + 4].copy_from_slice(&candidate.to_le_bytes()); + } else { + let candidate = addr.wrapping_sub(0x0100_0000); + if candidate & 0x8000_0000 != 0 && candidate.wrapping_add(offset) & 0x8000_0000 == 0 { + data[cur_pos..cur_pos + 4].copy_from_slice(&candidate.to_le_bytes()); + } + } + opcode_pos = pos + 5; + } +} + +#[cfg(test)] +pub(crate) fn delta_decode_with_control( + data: &[u8], + channels: usize, + messages: DeltaErrorMessages, + control: &crate::read_control::ReadControl, +) -> Result> { + delta_decode_with_allowance( + data, + channels, + messages, + control, + &super::workspace::Allowance::default(), + ) + .map(super::workspace::Buffer::into_vec) +} + +pub(crate) fn delta_decode_with_allowance( + data: &[u8], + channels: usize, + messages: DeltaErrorMessages, + control: &crate::read_control::ReadControl, + allowance: &B, +) -> Result> { + control.check_codec()?; + let mut poller = control.poller(); + if channels == 0 { + return Err(Error::InvalidData(messages.zero_channels)); + } + if channels > MAX_DELTA_CHANNELS { + return Err(Error::InvalidData(messages.invalid_channels)); + } + let mut out = super::workspace::Buffer::filled(data.len(), 0, allowance)?; + let mut src = 0usize; + for channel in 0..channels { + let mut prev = 0u8; + let mut dest = channel; + while dest < out.len() { + poller.check_codec(src)?; + let byte = *data + .get(src) + .ok_or(Error::InvalidData(messages.truncated_source))?; + prev = prev.wrapping_sub(byte); + out[dest] = prev; + src += 1; + dest += channels; + } + } + Ok(out) +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn delta_encode( + data: &[u8], + channels: usize, + messages: DeltaErrorMessages, +) -> Result> { + delta_encode_with_allowance( + data, + channels, + messages, + &super::workspace::Allowance::default(), + ) + .map(super::workspace::Buffer::into_vec) +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn delta_encode_with_allowance( + data: &[u8], + channels: usize, + messages: DeltaErrorMessages, + allowance: &B, +) -> Result> { + if channels == 0 || channels > 32 { + return Err(Error::InvalidData(messages.invalid_channels)); + } + let mut out = super::workspace::Buffer::with_capacity(data.len(), allowance)?; + for channel in 0..channels { + let mut prev = 0u8; + let mut src = channel; + while src < data.len() { + let byte = data[src]; + out.push(prev.wrapping_sub(byte)).map_err(Into::into)?; + prev = byte; + src += channels; + } + } + Ok(out) +} + +#[cfg(test)] +mod tests { + #[test] + fn short_x86_operands_are_unchanged_and_still_observe_cancellation() { + for length in 0..=4 { + for include_e9 in [false, true] { + let original = vec![0xe8; length]; + let mut data = original.clone(); + super::e8e9_encode(&mut data, u32::MAX, include_e9); + assert_eq!(data, original); + super::e8e9_decode(&mut data, u32::MAX, include_e9); + assert_eq!(data, original); + let token = crate::ReadCancellation::new(); + token.cancel(); + let control = crate::read_control::ReadControl::new(Some(&token)); + assert_eq!( + super::e8e9_decode_with_control(&mut data, 0, include_e9, &control), + Err(super::Error::Cancelled) + ); + assert_eq!(data, original); + } + } + } + + #[test] + fn configured_x86_scanning_matches_default_across_poll_boundaries() { + let mut input = vec![0; 192 * 1024]; + for pos in [65530, 65535, 65541, 131070, 131080] { + input[pos] = 0xe8; + input[pos + 1..pos + 5].copy_from_slice(&123456u32.to_le_bytes()); + } + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + let mut expected = input.clone(); + e8e9_decode(&mut expected, 4096, true); + e8e9_decode_with_control(&mut input, 4096, true, &control).unwrap(); + assert_eq!(input, expected); + } + + #[test] + fn cancellation_interrupts_delta_and_opcode_free_x86_scans() { + for x86 in [false, true] { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let mut bytes = vec![0; 384 * 1024]; + let result = if x86 { + e8e9_decode_with_control(&mut bytes, 0, true, &control) + } else { + delta_decode_with_control(&bytes, 2, generic_messages(), &control).map(|_| ()) + }; + assert_eq!(result.unwrap_err(), Error::Cancelled); + } + } + use super::*; + + fn generic_messages() -> DeltaErrorMessages { + DeltaErrorMessages { + invalid_channels: "DELTA filter channel count is invalid", + zero_channels: "DELTA filter has zero channels", + truncated_source: "DELTA filter source is truncated", + } + } + + /// Filters a copy, going through the same dispatch the writers use. + fn encode(op: FilterOp, data: &[u8], file_offset: u32) -> Result> { + let mut out = data.to_vec(); + encode_in_place(op, &mut out, file_offset, generic_messages())?; + Ok(out) + } + + fn x86_sample() -> Vec { + let mut data = b"prefix ".to_vec(); + data.extend_from_slice(&[0xe8, 0x10, 0x20, 0x00, 0x00]); + data.extend_from_slice(b" middle "); + data.extend_from_slice(&[0xe9, 0xf0, 0xff, 0xff, 0xff]); + data.extend_from_slice(b" suffix"); + data + } + + fn reference_e8e9_encode(data: &mut [u8], file_offset: u32, include_e9: bool) { + if data.len() <= 4 { + return; + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let mut cur_pos = 0usize; + while cur_pos < data.len() - 4 { + cur_pos += 1; + let opcode = data[cur_pos - 1]; + if opcode & cmp_mask == 0xe8 { + let offset = file_offset.wrapping_add(cur_pos as u32); + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let candidate = addr.wrapping_add(offset); + if candidate < 0x0100_0000 { + data[cur_pos..cur_pos + 4].copy_from_slice(&candidate.to_le_bytes()); + } else { + let candidate = addr.wrapping_sub(0x0100_0000); + if candidate & 0x8000_0000 != 0 + && candidate.wrapping_add(offset) & 0x8000_0000 == 0 + { + data[cur_pos..cur_pos + 4].copy_from_slice(&candidate.to_le_bytes()); + } + } + cur_pos += 4; + } + } + } + + fn reference_e8e9_decode(data: &mut [u8], file_offset: u32, include_e9: bool) { + if data.len() <= 4 { + return; + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let mut cur_pos = 0usize; + while cur_pos < data.len() - 4 { + cur_pos += 1; + let opcode = data[cur_pos - 1]; + if opcode & cmp_mask == 0xe8 { + let offset = file_offset.wrapping_add(cur_pos as u32); + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let new_addr = if addr < 0x0100_0000 { + Some(addr.wrapping_sub(offset)) + } else if addr & 0x8000_0000 != 0 && addr.wrapping_add(offset) & 0x8000_0000 == 0 { + Some(addr.wrapping_add(0x0100_0000)) + } else { + None + }; + if let Some(value) = new_addr { + data[cur_pos..cur_pos + 4].copy_from_slice(&value.to_le_bytes()); + } + cur_pos += 4; + } + } + } + + #[test] + fn e8_transform_round_trips_representative_bytes() { + let input = x86_sample(); + let mut filtered = encode(FilterOp::E8, &input, 4096).unwrap(); + + decode_in_place(FilterOp::E8, &mut filtered, 4096, generic_messages()).unwrap(); + + assert_eq!(filtered, input); + } + + #[test] + fn e8e9_transform_round_trips_representative_bytes() { + let input = x86_sample(); + let mut filtered = encode(FilterOp::E8E9, &input, 8192).unwrap(); + + decode_in_place(FilterOp::E8E9, &mut filtered, 8192, generic_messages()).unwrap(); + + assert_eq!(filtered, input); + } + + #[test] + fn e8e9_transform_matches_reference_at_chunk_boundaries_and_skips_payloads() { + let mut input = vec![0x41u8; 104]; + for (pos, address) in [ + (0usize, 0x0000_00e8u32), + (31, 0x0000_0100), + (36, 0x0000_0200), + (64, 0x0000_0300), + (96, 0xffff_ff00), + ] { + input[pos] = if pos == 36 { 0xe9 } else { 0xe8 }; + input[pos + 1..pos + 5].copy_from_slice(&address.to_le_bytes()); + } + input[32] = 0xe8; + input[65] = 0xe9; + + for &include_e9 in &[false, true] { + let mut expected = input.clone(); + let mut actual = input.clone(); + reference_e8e9_encode(&mut expected, 0x1000, include_e9); + e8e9_encode(&mut actual, 0x1000, include_e9); + assert_eq!(actual, expected); + + reference_e8e9_decode(&mut expected, 0x1000, include_e9); + e8e9_decode(&mut actual, 0x1000, include_e9); + assert_eq!(actual, expected); + assert_eq!(actual, input); + } + } + + #[test] + fn delta_transform_round_trips_interleaved_channels() { + let input = b"abcdefghijklmnopqrstuvwxyz0123456789".repeat(3); + let mut filtered = encode(FilterOp::Delta { channels: 3 }, &input, 0).unwrap(); + + decode_in_place( + FilterOp::Delta { channels: 3 }, + &mut filtered, + 0, + generic_messages(), + ) + .unwrap(); + + assert_eq!(filtered, input); + } + + #[test] + fn delta_decode_accepts_channel_counts_the_rar29_vm_can_ask_for() { + // 33 is past what RAR 5 can encode and well inside what the RAR 2.9 + // VM can put in R[0]. Refusing it here refused whole archives. + let mut filtered = vec![0; 64]; + + assert_eq!( + decode_in_place( + FilterOp::Delta { channels: 33 }, + &mut filtered, + 0, + generic_messages(), + ), + Ok(()) + ); + } + + #[test] + fn delta_decode_rejects_channel_counts_above_the_vm_limit() { + let mut filtered = vec![0; 64]; + + assert_eq!( + decode_in_place( + FilterOp::Delta { + channels: MAX_DELTA_CHANNELS + 1, + }, + &mut filtered, + 0, + generic_messages(), + ), + Err(Error::InvalidData("DELTA filter channel count is invalid")) + ); + } + + #[test] + fn encode_in_place_matches_allocating_encode() { + let input = x86_sample(); + let expected = encode(FilterOp::E8E9, &input, 1234).unwrap(); + let mut actual = input; + + encode_in_place(FilterOp::E8E9, &mut actual, 1234, generic_messages()).unwrap(); + + assert_eq!(actual, expected); + } +} diff --git a/arca-rar/vendor/rars/src/codec/huffman.rs b/arca-rar/vendor/rars/src/codec/huffman.rs new file mode 100644 index 00000000..51700bd8 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/huffman.rs @@ -0,0 +1,617 @@ +#[cfg(any(test, feature = "write"))] +use super::workspace::Allowance; +use super::workspace::{Budget, Buffer}; +use super::Result; + +/// Like [`lengths_for_frequencies`], but guarantees the returned code lengths +/// form a *complete* canonical prefix code (Kraft equality) whenever at least +/// one symbol is used. +/// +/// Strict RAR 5 decoders build their tables with 7-Zip's +/// `k_BuildMode_Full_or_Empty`, which rejects any under-full table (a table +/// whose codes leave part of the code space unassigned). A frequency table +/// with a single used symbol otherwise yields one length-1 code — Kraft sum +/// `0.5` — and such archives decode fine in unRAR but fail in 7-Zip / WinRAR +/// with a spurious "Data Error". Real Huffman codes for two or more symbols are +/// already complete, so this only adjusts the degenerate single-symbol case (and +/// the rare uniform-length fallback), padding with phantom codes that are never +/// emitted. +#[cfg(test)] +pub(crate) fn complete_lengths_for_frequencies(frequencies: &[usize], max_bits: u8) -> Vec { + complete_lengths_with_allowance(frequencies, max_bits, &Allowance::default()) + .expect("unlimited Huffman allocation") + .into_vec() +} + +/// Returns true if the non-zero code lengths form a complete prefix code +/// (Kraft sum exactly 1), or if the table is empty (no used symbol). +fn is_complete_code(lengths: &[u8]) -> bool { + // Kraft sum in units of 2^-max_len, accumulated as an integer to avoid + // floating point. A complete code has sum == 2^max_len. + let max_len = lengths.iter().copied().max().unwrap_or(0); + if max_len == 0 { + return true; // empty table + } + let mut sum: u64 = 0; + for &len in lengths { + if len != 0 { + sum += 1u64 << (max_len - len); + } + } + sum == (1u64 << max_len) +} + +/// Overwrites `lengths` with a complete near-uniform canonical code over the +/// currently-used symbols (those with a non-zero length), preserving symbol +/// order. A single used symbol is padded with one phantom length-1 code so the +/// result satisfies Kraft equality. The alphabet must have at least two slots +/// and at least one used symbol. Callers that need a guaranteed-complete code +/// (e.g. tables a strict decoder builds +/// with `Full`/`Full_or_Empty`) can mark used symbols with any non-zero length +/// and call this to normalise them. +pub(crate) fn assign_flat_complete_code(lengths: &mut [u8]) { + let n = lengths.iter().filter(|&&length| length != 0).count(); + // Level tables always encode a nonempty main-table description. Empty + // frequency tables in complete_lengths_with_allowance skip this helper. + debug_assert!(n != 0 && lengths.len() >= 2); + if n == 1 { + let symbol = lengths.iter().position(|&length| length != 0).unwrap(); + lengths[symbol] = 1; + let phantom = usize::from(symbol == 0); + lengths[phantom] = 1; + return; + } + let k = (usize::BITS - (n - 1).leading_zeros()) as u8; + let short_count = (1usize << k) - n; + for (index, length) in lengths + .iter_mut() + .filter(|length| **length != 0) + .enumerate() + { + *length = if index < short_count { k - 1 } else { k }; + } +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn lengths_for_frequencies(frequencies: &[usize], max_bits: u8) -> Vec { + lengths_with_allowance(frequencies, max_bits, &Allowance::default()) + .expect("unlimited Huffman allocation") + .into_vec() +} + +pub(crate) fn complete_lengths_with_allowance( + frequencies: &[usize], + max_bits: u8, + allowance: &B, +) -> Result> { + let mut lengths = lengths_with_allowance(frequencies, max_bits, allowance)?; + if !is_complete_code(&lengths) { + assign_flat_complete_code(&mut lengths); + } + Ok(lengths) +} + +pub(crate) fn lengths_with_allowance( + frequencies: &[usize], + max_bits: u8, + allowance: &B, +) -> Result> { + let used_count = frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count(); + let mut lengths = Buffer::filled(frequencies.len(), 0u8, allowance)?; + if used_count <= 1 { + uniform_lengths_into(&mut lengths, frequencies); + return Ok(lengths); + } + + // Parents replace the old per-node symbol vectors. Node order breaks ties + // exactly as the original heap did; every parent is created after its children. + let capacity = frequencies + .len() + .checked_add(used_count - 1) + .ok_or(super::Error::InvalidData("Huffman node count overflows"))?; + let mut parents = Buffer::filled(capacity, usize::MAX, allowance)?; + let mut heap = Buffer::with_capacity(used_count, allowance)?; + let mut order = 0; + for (symbol, &frequency) in frequencies.iter().enumerate() { + if frequency != 0 { + heap.push((frequency, order, symbol)).map_err(Into::into)?; + order += 1; + } + } + // Sorting once constructs a valid min-heap without auxiliary allocation. + heap.sort_unstable(); + let mut next = frequencies.len(); + while heap.len() > 1 { + let (left_frequency, _, left) = pop_min(&mut heap); + let (right_frequency, _, right) = pop_min(&mut heap); + parents[left] = next; + parents[right] = next; + heap.push((left_frequency.saturating_add(right_frequency), order, next)) + .map_err(Into::into)?; + let mut child = heap.len() - 1; + while child != 0 { + let parent = (child - 1) / 2; + if heap[parent] <= heap[child] { + break; + } + heap.swap(parent, child); + child = parent; + } + next += 1; + order += 1; + } + // Replace parent indices with depths in reverse creation order. + for node in (0..next).rev() { + parents[node] = if parents[node] == usize::MAX { + 0 + } else { + parents[parents[node]] + 1 + }; + } + for (length, &depth) in lengths.iter_mut().zip(parents.iter()) { + *length = depth as u8; + } + if lengths.iter().any(|&length| length > max_bits) { + limit_code_lengths(&mut lengths, frequencies, max_bits); + } + Ok(lengths) +} + +fn pop_min(heap: &mut Buffer<(usize, usize, usize), B>) -> (usize, usize, usize) { + let last = heap.pop().expect("frequency heap has a node"); + if heap.is_empty() { + return last; + } + let first = std::mem::replace(&mut heap[0], last); + let mut parent = 0; + loop { + let left = parent * 2 + 1; + if left >= heap.len() { + break; + } + let right = left + 1; + let child = if right < heap.len() && heap[right] < heap[left] { + right + } else { + left + }; + if heap[parent] <= heap[child] { + break; + } + heap.swap(parent, child); + parent = child; + } + first +} + +fn uniform_lengths_into(lengths: &mut [u8], frequencies: &[usize]) { + let bits = bits_for_symbol_count( + frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count(), + ); + for (length, &frequency) in lengths.iter_mut().zip(frequencies) { + *length = if frequency == 0 { 0 } else { bits }; + } +} + +/// Bring every code length down to `max_bits`, keeping the code complete. +/// +/// A code deeper than the format allows used to be replaced by a uniform one +/// over the same symbols. That is a far worse code: on a skewed 289 symbol main +/// table a flat code spends nine bits on every token where the Huffman code it +/// replaced averaged closer to six, and the codes that trip the limit overflow +/// it by a bit or two, not by enough to justify giving up. +/// +/// Clamping the over-long lengths breaks Kraft equality, so this pays the +/// difference back by lengthening the symbols that cost least per bit, then +/// spends whatever is left over on the most frequent ones so the code comes out +/// complete. Package-merge would be optimal; this is within a fraction of a +/// percent of it and much shorter. +fn limit_code_lengths(lengths: &mut [u8], frequencies: &[usize], max_bits: u8) { + // Writers use the format's 15-bit limit. The generic limiter requires a + // positive limit representable as a prefix-space size on this host. + debug_assert!((1..usize::BITS as u8).contains(&max_bits)); + // No prefix code over this many symbols fits in this many bits however it + // is arranged, so there is nothing to repair towards. + let used = lengths.iter().filter(|&&length| length != 0).count(); + if used > (1usize << max_bits) { + uniform_lengths_into(lengths, frequencies); + return; + } + + for length in lengths.iter_mut() { + if *length > max_bits { + *length = max_bits; + } + } + + // Kraft sum in units of 2^-max_bits, so it stays exact in integers. + let target: u64 = 1 << max_bits; + let mut sum: u64 = lengths + .iter() + .filter(|&&length| length != 0) + .map(|&length| 1u64 << (max_bits - length)) + .sum(); + + while sum > target { + // If every used length were max_bits, sum would equal used, which + // the capacity check above bounds by target. An overfull code must + // therefore have a symbol whose length can still be increased. + let symbol = (0..lengths.len()) + .filter(|&symbol| lengths[symbol] != 0 && lengths[symbol] < max_bits) + .min_by_key(|&symbol| (frequencies[symbol], std::cmp::Reverse(lengths[symbol]))) + .expect("overfull prefix code has a short symbol"); + sum -= 1u64 << (max_bits - lengths[symbol] - 1); + lengths[symbol] += 1; + } + + while let Some(symbol) = (0..lengths.len()) + .filter(|&symbol| lengths[symbol] > 1) + .filter(|&symbol| sum + (1u64 << (max_bits - lengths[symbol])) <= target) + .max_by_key(|&symbol| (frequencies[symbol], lengths[symbol])) + { + sum += 1u64 << (max_bits - lengths[symbol]); + lengths[symbol] -= 1; + } +} + +#[cfg(feature = "write")] +pub(crate) fn lengths_for_frequency_array( + frequencies: &[usize; N], + max_bits: u8, +) -> [u8; N] { + let mut lengths = [0u8; N]; + lengths.copy_from_slice(&lengths_for_frequencies(frequencies, max_bits)); + lengths +} + +pub(crate) fn bits_for_symbol_count(count: usize) -> u8 { + match count { + 0 | 1 => 1, + _ => usize::BITS as u8 - (count - 1).leading_zeros() as u8, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn charged_tree_preserves_heap_ties_and_saturating_frequencies() { + // Independent reference for the replaced per-node symbol-list tree. + fn reference(frequencies: &[usize]) -> Vec { + use std::{cmp::Reverse, collections::BinaryHeap}; + let mut lengths = vec![0u8; frequencies.len()]; + let mut heap = BinaryHeap::new(); + let mut order = 0; + for (symbol, &frequency) in frequencies.iter().enumerate() { + if frequency != 0 { + heap.push(Reverse((frequency, order, vec![symbol]))); + order += 1; + } + } + if heap.len() <= 1 { + uniform_lengths_into(&mut lengths, frequencies); + return lengths; + } + while heap.len() > 1 { + let Reverse((left, _, mut symbols)) = heap.pop().unwrap(); + let Reverse((right, _, mut other)) = heap.pop().unwrap(); + for &symbol in symbols.iter().chain(&other) { + lengths[symbol] += 1; + } + symbols.append(&mut other); + heap.push(Reverse((left.saturating_add(right), order, symbols))); + order += 1; + } + if lengths.iter().any(|&length| length > 15) { + limit_code_lengths(&mut lengths, frequencies, 15); + } + lengths + } + let allowance = Allowance::limited(1024 * 1024); + let mut state = 71u64; + for count in [0, 1, 2, 20, 64, 306, 1024] { + for shape in 0..8 { + let frequencies: Vec<_> = (0..count) + .map(|_| { + state = state.wrapping_mul(6364136223846793005).wrapping_add(1); + match shape { + 0 => 0, + 1 => 1, + 2 => usize::MAX, + 3 => (state % 3) as usize, + _ => (state >> (shape * 7)) as usize, + } + }) + .collect(); + let actual = lengths_with_allowance(&frequencies, 15, &allowance).unwrap(); + assert_eq!(&*actual, reference(&frequencies)); + assert_eq!(allowance.used(), count as u64); + drop(actual); + assert_eq!(allowance.used(), 0); + } + } + } + + #[test] + fn tree_refusal_releases_scratch_and_success_retains_only_lengths() { + let frequencies = [1, 3, 7, 11]; + let peak = 4 + + 7 * std::mem::size_of::() as u64 + + 4 * std::mem::size_of::<(usize, usize, usize)>() as u64; + for limit in [0, 4, peak - 1] { + let allowance = Allowance::limited(limit); + assert!(matches!( + lengths_with_allowance(&frequencies, 15, &allowance), + Err(super::super::Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(allowance.used(), 0); + } + let allowance = Allowance::limited(peak); + let lengths = complete_lengths_with_allowance(&frequencies, 15, &allowance).unwrap(); + assert_eq!(allowance.used(), 4); + drop(lengths); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn weighted_lengths_favour_common_symbols() { + let frequencies = [1, 1, 16, 1]; + let lengths = lengths_for_frequencies(&frequencies, 15); + + assert!(lengths[2] < lengths[0]); + assert!(lengths.iter().all(|&length| length <= 15)); + } + + #[test] + fn lengths_too_deep_to_limit_fall_back_to_uniform_lengths() { + // 1024 symbols cannot be spelled in one bit however they are arranged, + // so there is no length-limited code to find. + let frequencies = (1..=1024).collect::>(); + let lengths = lengths_for_frequencies(&frequencies, 1); + + assert!(lengths.iter().all(|&length| length == 10)); + } + + #[test] + fn deep_codes_are_limited_rather_than_flattened() { + // Fibonacci frequencies are the worst case for Huffman depth, and this + // alphabet wants codes far deeper than fifteen bits. + let mut frequencies = vec![1usize, 1]; + while frequencies.len() < 40 { + let next = frequencies[frequencies.len() - 1] + frequencies[frequencies.len() - 2]; + frequencies.push(next); + } + let mut sparse = vec![0; 306]; + for (symbol, &frequency) in frequencies.iter().enumerate() { + sparse[symbol * 7 + 3] = frequency; + } + for frequencies in [frequencies, sparse] { + let lengths = lengths_for_frequencies(&frequencies, 15); + + assert!(lengths.iter().all(|&length| length <= 15), "{lengths:?}"); + assert!(is_complete_code(&lengths), "{lengths:?}"); + for (&frequency, &length) in frequencies.iter().zip(&lengths) { + assert_eq!(frequency == 0, length == 0); + } + // A flat code over forty symbols is six bits each, and on frequencies + // this skewed the limited code has to beat that. + let flat: usize = frequencies.iter().sum::() * 6; + let limited: usize = frequencies + .iter() + .zip(&lengths) + .map(|(&frequency, &length)| frequency * usize::from(length)) + .sum(); + assert!(limited < flat, "limited {limited} flat {flat}"); + } + } + + #[test] + fn limited_codes_stay_decodable_for_every_shape_of_input() { + // rar29 feeds this straight into a table it writes, with no validation + // pass behind it, so the one thing that must always hold is that the + // result is a usable prefix code inside the format's bit limit. + let mut seed = 0x2545_f491_4f6c_dd1du64; + let mut next = move || { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + seed + }; + for symbols in [2usize, 3, 17, 64, 255, 299] { + for skew in 0..8 { + let frequencies: Vec = (0..symbols) + .map(|_| match skew { + // Increasingly lopsided distributions, which is what + // drives a Huffman code past the depth limit. + 0 => 1, + s => 1 + (next() % (1u64 << (s * 8).min(60))) as usize, + }) + .collect(); + let lengths = lengths_for_frequencies(&frequencies, 15); + + assert_eq!(lengths.len(), symbols); + assert!( + lengths.iter().all(|&length| length <= 15), + "over the limit: {symbols} symbols, skew {skew}" + ); + let deepest = lengths.iter().copied().max().unwrap_or(0); + if deepest > 0 { + let kraft: u64 = lengths + .iter() + .filter(|&&length| length != 0) + .map(|&length| 1u64 << (deepest - length)) + .sum(); + assert!( + kraft <= 1u64 << deepest, + "not a prefix code: {symbols} symbols, skew {skew}" + ); + } + } + } + } + + fn kraft_sum_is_one(lengths: &[u8]) -> bool { + let max_len = lengths.iter().copied().max().unwrap_or(0); + if max_len == 0 { + return lengths.iter().all(|&len| len == 0); + } + let sum: u64 = lengths + .iter() + .filter(|&&len| len != 0) + .map(|&len| 1u64 << (max_len - len)) + .sum(); + sum == (1u64 << max_len) + } + + #[test] + fn flat_codes_complete_every_small_nonempty_symbol_subset() { + for slots in 2..=8 { + for mask in 1usize..1 << slots { + let mut lengths: Vec<_> = (0..slots) + .map(|symbol| if mask & (1 << symbol) != 0 { 7 } else { 0 }) + .collect(); + assign_flat_complete_code(&mut lengths); + let used = mask.count_ones() as usize; + assert_eq!(lengths.iter().filter(|&&n| n != 0).count(), used.max(2)); + for (symbol, &length) in lengths.iter().enumerate() { + if mask & (1 << symbol) != 0 { + assert_ne!(length, 0); + } else if used > 1 { + assert_eq!(length, 0); + } + } + // Count concrete fixed-width bit strings owned by each code + // length. A complete prefix code fills the entire space. + let deepest = lengths.iter().copied().max().unwrap(); + let mut ordered: Vec<_> = lengths.iter().copied().filter(|&n| n != 0).collect(); + ordered.sort_unstable(); + let mut next = 0usize; + for length in ordered { + let width = 1usize << (deepest - length); + assert_eq!(next % width, 0); + next += width; + } + assert_eq!(next, 1 << deepest); + let shallowest = lengths.iter().copied().filter(|&n| n != 0).min().unwrap(); + assert!(deepest - shallowest <= 1); + } + } + } + + #[test] + fn small_alphabets_have_non_overlapping_canonical_codes() { + for symbols in 2u32..=7 { + for mut pattern in 0..3usize.pow(symbols) { + let frequencies: Vec<_> = (0..symbols) + .map(|_| { + let frequency = pattern % 3; + pattern /= 3; + frequency + }) + .collect(); + let used = frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count(); + for max_bits in 1..=4 { + let lengths = lengths_for_frequencies(&frequencies, max_bits); + for (&frequency, &length) in frequencies.iter().zip(&lengths) { + assert_eq!(frequency == 0, length == 0); + } + if used > 1usize << max_bits { + // An impossible limit retains the documented uniform fallback. + let uniform = (usize::BITS - (used - 1).leading_zeros()) as u8; + assert!(lengths + .iter() + .all(|&length| length == 0 || length == uniform)); + } else { + assert!(lengths.iter().all(|&length| length <= max_bits)); + } + + // Assign canonical integers independently, then occupy every + // suffix below each prefix. No two symbols may share a slot. + let depth = lengths.iter().copied().max().unwrap_or(0); + let mut occupied = vec![false; 1usize << depth]; + let mut ordered: Vec<_> = lengths.iter().copied().filter(|&n| n != 0).collect(); + ordered.sort_unstable(); + let mut code = 0usize; + let mut previous = 0; + for length in ordered { + code <<= length - previous; + let start = code << (depth - length); + let end = start + (1usize << (depth - length)); + assert!(end <= occupied.len(), "{frequencies:?}: {lengths:?}"); + for slot in &mut occupied[start..end] { + assert!(!*slot, "{frequencies:?}: {lengths:?}"); + *slot = true; + } + code += 1; + previous = length; + } + } + } + } + } + + #[test] + fn single_symbol_table_is_completed_with_a_phantom_code() { + // A lone used symbol would otherwise get one length-1 code (Kraft 0.5), + // which strict RAR 5 decoders reject. It must be padded to a complete + // code without disturbing the used symbol's own length. + for used in [0usize, 1, 7, 40] { + let mut frequencies = vec![0usize; 44]; + frequencies[used] = 123; + let lengths = complete_lengths_for_frequencies(&frequencies, 15); + assert_eq!(lengths[used], 1, "used symbol {used} keeps a length-1 code"); + assert_eq!( + lengths.iter().filter(|&&len| len != 0).count(), + 2, + "exactly one phantom code was added for used symbol {used}" + ); + assert!( + kraft_sum_is_one(&lengths), + "used symbol {used} yields a complete code" + ); + } + } + + #[test] + fn empty_table_stays_empty() { + let lengths = complete_lengths_for_frequencies(&[0usize; 16], 15); + assert!(lengths.iter().all(|&len| len == 0)); + } + + #[test] + fn completed_codes_are_always_complete_for_any_symbol_count() { + for used_count in 1..=64usize { + let mut frequencies = vec![0usize; 306]; + for (i, freq) in frequencies.iter_mut().take(used_count).enumerate() { + *freq = 1 + i; // distinct frequencies, still a valid Huffman input + } + let lengths = complete_lengths_for_frequencies(&frequencies, 15); + assert!( + kraft_sum_is_one(&lengths), + "code for {used_count} symbols must be complete" + ); + assert!(lengths.iter().all(|&len| len <= 15)); + } + } + + #[test] + fn multi_symbol_huffman_code_is_left_optimal() { + // A skewed distribution already yields a complete Huffman code; the + // completeness pass must not flatten it into a uniform code. + let frequencies = [100usize, 1, 1, 1, 1]; + let optimal = lengths_for_frequencies(&frequencies, 15); + let completed = complete_lengths_for_frequencies(&frequencies, 15); + assert_eq!(optimal, completed); + assert!(kraft_sum_is_one(&completed)); + } +} diff --git a/arca-rar/vendor/rars/src/codec/match_finder.rs b/arca-rar/vendor/rars/src/codec/match_finder.rs new file mode 100644 index 00000000..ec5d11f2 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/match_finder.rs @@ -0,0 +1,479 @@ +//! Match finders shared by the LZ encoders. +//! +//! [`MatchFinder`] is a hash chain. Positions are indexed into a +//! single-bucket-per-hash chain: `head` maps a hash of the `MIN_MATCH` bytes +//! at a position to the most recently inserted position, and `prev` links each +//! inserted position to the previous position with the same hash. Walking a +//! chain therefore visits candidates from the smallest distance to the +//! largest, so callers can stop as soon as a candidate falls outside their +//! window. Inserting costs one store, so a caller can skip past bytes it has +//! already decided about for free, which is what the lazy encoders do. +//! +//! [`TreeMatchFinder`] keeps the positions sharing a hash in a binary tree +//! ordered by the bytes that follow them, after LZMA. One descent finds every +//! improving match and re-hangs the tree under the new position, and each node +//! on the way down narrows a proven-prefix bound, so the descent never re-reads +//! bytes it has already matched. That is what a deep chain walk cannot avoid, +//! and why the tree serves the optimal parse, which searches at every position +//! anyway. The price is that inserting *is* a descent, so history cannot be +//! seeded cheaply, and the tree costs eight bytes per byte of window against +//! the chain's four. +//! +//! `prev` holds one link per position in a window rather than one per position +//! in the input, indexed by position modulo the window. A link is only followed +//! while the candidate it names is inside the window, and a slot is only reused +//! once the position it held has fallen out, so the two never overlap. That +//! bounds the finder by the window instead of by the data, which is what lets +//! one finder span every block of a member: rebuilding it per block meant +//! rehashing the whole history each time, which measured at about 40% of the +//! encode on a 16 MiB member. +//! +//! Links are 32 bits, so the window costs four bytes per byte it covers rather +//! than eight, and twice as many links share a cache line. Positions past four +//! gigabytes keep only their low half; `resolve` measures back from the newest +//! position inserted to recover the rest. + +use super::workspace::{Allowance, Budget, Buffer}; +use super::Result; + +/// Sentinel for "no position" in `head`/`prev` chains. +pub(crate) const NO_POSITION: usize = usize::MAX; + +/// The sentinel as it is stored. A position whose low 32 bits are all set is +/// indistinguishable from it and ends its chain one link early. That costs one +/// candidate every four gigabytes and cannot cost correctness: a caller +/// confirms every candidate by comparing the bytes at it. +const NO_LINK: u32 = u32::MAX; + +/// Reads a stored link back as the position it names, given the newest position +/// the finder holds. +/// +/// Only the low 32 bits of a position survive storage. No link names a position +/// newer than `newest`, so measuring back from `newest` recovers it exactly +/// whenever the input fits in 32 bits, and within four gigabytes of the true one +/// when it does not. Neither case can underflow: below four gigabytes the stored +/// link is the position itself and so no higher than `newest`, and above it the +/// distance is a `u32` and `newest` is not. +fn resolve(newest: usize, link: u32) -> usize { + if link == NO_LINK { + return NO_POSITION; + } + newest - (newest as u32).wrapping_sub(link) as usize +} + +/// The multiplicative mix every finder hashes with. +fn mix(value: u32, bits: u32) -> usize { + (value.wrapping_mul(0x9E37_79B1) >> (32 - bits)) as usize +} + +#[derive(Debug)] +pub(crate) struct MatchFinder { + head: Buffer, + prev: Buffer, + mask: usize, + /// The highest position inserted so far, and so at least as high as any + /// position a link can name. Truncated links are read back against it. + newest: usize, +} + +#[cfg(any(test, feature = "write"))] +impl MatchFinder { + pub(crate) fn new(window: usize) -> Self { + Self::with_allowance(window, &Allowance::default()).expect("unlimited finder allocation") + } +} + +impl MatchFinder { + const HASH_BITS: u32 = match MIN_MATCH { + 3 => 16, + 4 => 17, + _ => panic!("match finder supports MIN_MATCH of 3 or 4"), + }; + + /// Builds a finder that remembers the last `window` positions. + /// + /// The caller must not accept a match further back than `window`, which is + /// the check it already makes against its own maximum distance. A link to a + /// position that has fallen out of the window is still readable, and still + /// names the position it named, so that check rejects it the same way it + /// rejects a match that is merely too far away. + pub(crate) fn with_allowance(window: usize, allowance: &B) -> Result { + let window = window + .max(1) + .checked_next_power_of_two() + .ok_or(super::Error::InvalidData("finder window overflows"))?; + Ok(Self { + head: Buffer::filled(1 << Self::HASH_BITS, NO_LINK, allowance)?, + // Zero rather than the sentinel, and nothing reads it either way: a + // link is only ever followed from a position that has been + // inserted, and inserting a position writes its slot first. Zero + // lets the allocator hand back pages it has not had to touch, so a + // window wider than the data has reached costs nothing yet. + prev: Buffer::filled(window, 0, allowance)?, + mask: window - 1, + newest: 0, + }) + } + + #[cfg(feature = "write")] + pub(crate) fn allowance(&self) -> B { + self.head.allowance() + } + + fn hash(input: &[u8], pos: usize) -> usize { + let value = if MIN_MATCH == 3 { + u32::from(input[pos]) + | (u32::from(input[pos + 1]) << 8) + | (u32::from(input[pos + 2]) << 16) + } else { + u32::from_le_bytes([input[pos], input[pos + 1], input[pos + 2], input[pos + 3]]) + }; + mix(value, Self::HASH_BITS) + } + + /// Records `pos` as a future match candidate. Positions too close to the + /// end of the input to fit `MIN_MATCH` bytes are ignored. + pub(crate) fn insert(&mut self, input: &[u8], pos: usize) { + if pos + MIN_MATCH <= input.len() { + let hash = Self::hash(input, pos); + self.prev[pos & self.mask] = self.head[hash]; + self.head[hash] = pos as u32; + self.newest = self.newest.max(pos); + } + } + + /// Returns the most recently inserted candidate sharing `pos`'s hash, or + /// [`NO_POSITION`]. The caller must ensure at least `MIN_MATCH` bytes are + /// readable at `pos`. + pub(crate) fn first(&self, input: &[u8], pos: usize) -> usize { + resolve(self.newest, self.head[Self::hash(input, pos)]) + } + + /// Returns the next-older candidate in `candidate`'s chain, or + /// [`NO_POSITION`]. + pub(crate) fn previous(&self, candidate: usize) -> usize { + let older = resolve(self.newest, self.prev[candidate & self.mask]); + // Chains run newest to oldest. A link that does not step back is one + // whose slot has been reused, or whose position wrapped past four + // gigabytes; either way the chain ends here, which is what keeps the + // walk finite. This also covers the sentinel, which is above every + // position. + if older >= candidate { + return NO_POSITION; + } + older + } +} + +/// A binary-tree match finder, after LZMA's BT4. +/// +/// Positions sharing a hash of their first four bytes form a binary search +/// tree ordered by the bytes at them, newest position at the root. The two +/// children of each position live in `son`, one window slot per position as +/// with the chain finder's `prev`, and the same rules keep slot reuse and the +/// window from ever overlapping. Truncated links are read back with the +/// position being searched for as the reference, which is always the newest. +#[derive(Debug)] +pub(crate) struct TreeMatchFinder { + head: Buffer, + /// Two links per window slot: the child whose bytes compare lesser first, + /// then the greater-or-equal one, in LZMA's layout. + son: Buffer, + mask: usize, +} + +impl TreeMatchFinder { + #[cfg(test)] + pub(crate) fn new(window: usize) -> Self { + Self::with_allowance(window, &Allowance::default()).expect("unlimited finder allocation") + } +} + +impl TreeMatchFinder { + const HASH_BITS: u32 = 17; + const MIN_MATCH: usize = 4; + + /// Builds a finder that remembers the last `window` positions, at eight + /// bytes of links per byte of window. + pub(crate) fn with_allowance(window: usize, allowance: &B) -> Result { + let window = window + .max(1) + .checked_next_power_of_two() + .ok_or(super::Error::InvalidData("finder window overflows"))?; + Ok(Self { + head: Buffer::filled(1 << Self::HASH_BITS, NO_LINK, allowance)?, + // Zero rather than the sentinel for the same reason as the chain + // finder's `prev`: a slot is always written during its position's + // own insertion before any link can lead to it, and untouched + // zeroes let the allocator defer the pages. + son: Buffer::filled( + window + .checked_mul(2) + .ok_or(super::Error::InvalidData("finder window overflows"))?, + 0, + allowance, + )?, + mask: window - 1, + }) + } + + #[cfg(feature = "write")] + pub(crate) fn allowance(&self) -> B { + self.head.allowance() + } + + /// Finds the matches at `pos` and inserts `pos`, in one descent. + /// + /// Pushes `(length, distance)` pairs onto `out` with both strictly + /// increasing, so each pair is the nearest distance found that reaches its + /// length, and nothing shorter than four bytes or further than + /// `max_distance` is reported. Comparing stops at `len_limit`, which must + /// leave `pos + len_limit` readable; a pair whose length equals it may + /// really extend further, which the caller measures if it cares. A node + /// that matches the whole limit gives its place to the new position, since + /// the two are interchangeable prefixes and the new one is nearer + /// everything to come. `cut` bounds the nodes visited, + /// and whatever hangs below the last one is cut off rather than left + /// dangling. The caller must skip positions with fewer than four bytes + /// left, as the tree collector does. On allocation refusal, discard the finder: + /// the insertion may have been partially applied before output growth failed. + pub(crate) fn matches( + &mut self, + input: &[u8], + pos: usize, + len_limit: usize, + max_distance: usize, + cut: usize, + out: &mut Buffer<(u32, u32), B>, + ) -> std::result::Result<(), B::Failure> { + // The tree collector calls this only when at least four bytes remain. + // Unlike the chain finder, it skips near-end positions before calling. + debug_assert!(len_limit >= Self::MIN_MATCH && pos + len_limit <= input.len()); + let hash = mix( + u32::from_le_bytes([input[pos], input[pos + 1], input[pos + 2], input[pos + 3]]), + Self::HASH_BITS, + ); + let mut current = resolve(pos, self.head[hash]); + self.head[hash] = pos as u32; + // The two attachment points still waiting for a subtree, starting as + // the new position's own child slots. Each step down hangs the node + // just compared on one of them and moves that side into the node's + // matching child slot. + let mut ptr0 = ((pos & self.mask) << 1) + 1; + let mut ptr1 = (pos & self.mask) << 1; + // How much of the prefix is proven to match on each side of the + // descent. Everything below a node compares the same way the node + // did up to its recorded length, so bytes before the smaller of the + // two never need reading again. + let mut len0 = 0usize; + let mut len1 = 0usize; + let mut longest = Self::MIN_MATCH - 1; + let mut budget = cut; + let mut floor = pos; + loop { + // A candidate that does not step back is a reused slot or the + // sentinel; one further back than the window has fallen out of it. + // Either ends the descent, sealing both attachment points so no + // stale link survives below them. A spent budget ends it the same + // way, dropping whatever subtree the budget could not reach. + if current >= floor || pos - current > self.mask || budget == 0 { + self.son[ptr0] = NO_LINK; + self.son[ptr1] = NO_LINK; + return Ok(()); + } + budget -= 1; + floor = current; + let pair = (current & self.mask) << 1; + let mut len = len0.min(len1); + if input[current + len] == input[pos + len] { + len += 1; + while len < len_limit && input[current + len] == input[pos + len] { + len += 1; + } + if len > longest { + if pos - current <= max_distance { + out.push((len as u32, (pos - current) as u32))?; + } + longest = len; + if len == len_limit { + // The node's whole comparable prefix is the new + // position's prefix, so the new position adopts its + // children and the node drops out as the farther of + // two interchangeable candidates. + self.son[ptr1] = self.son[pair]; + self.son[ptr0] = self.son[pair + 1]; + return Ok(()); + } + } + } + if input[current + len] < input[pos + len] { + self.son[ptr1] = current as u32; + ptr1 = pair + 1; + len1 = len; + current = resolve(pos, self.son[ptr1]); + } else { + self.son[ptr0] = current as u32; + ptr0 = pair; + len0 = len; + current = resolve(pos, self.son[ptr0]); + } + } + } +} + +#[cfg(test)] +mod tests { + use super::{resolve, MatchFinder, TreeMatchFinder, NO_LINK, NO_POSITION}; + + /// Four repeats of the same four bytes, so every position shares a hash and + /// they form one chain. + const REPEATED: &[u8] = b"abcdabcdabcdabcd"; + + #[test] + fn a_chain_walks_from_the_nearest_candidate_to_the_furthest() { + let mut finder = MatchFinder::<4>::new(REPEATED.len()); + for pos in [0, 4, 8] { + finder.insert(REPEATED, pos); + } + + let mut walked = Vec::new(); + let mut candidate = finder.first(REPEATED, 12); + while candidate != NO_POSITION { + walked.push(candidate); + candidate = finder.previous(candidate); + } + assert_eq!(walked, [8, 4, 0]); + } + + #[test] + fn a_position_that_has_fallen_out_of_the_window_still_names_itself() { + // A candidate three thousand bytes back, found through a window of + // sixty-four. It reads back as the position it named rather than as + // something inside the window, which is what leaves the caller to + // reject it on distance. + let data = vec![b'x'; 4096]; + let mut finder = MatchFinder::<4>::new(64); + finder.insert(&data, 0); + finder.insert(&data, 2048); + assert_eq!(finder.first(&data, 3000), 2048); + assert_eq!(finder.previous(2048), 0); + } + + #[test] + fn resolving_recovers_a_position_stored_below_four_gigabytes() { + assert_eq!(resolve(1_000, 0), 0); + assert_eq!(resolve(1_000, 999), 999); + assert_eq!(resolve(1_000, 1_000), 1_000); + assert_eq!(resolve(1_000, NO_LINK), NO_POSITION); + } + + /// Every improving match at each position of `input`, walked in order the + /// way the optimal parse's collector does. + fn tree_matches_at_every_position(input: &[u8], cut: usize) -> Vec> { + let mut finder = TreeMatchFinder::new(input.len()); + let mut all = Vec::new(); + for pos in 0..input.len() { + let mut out = super::Buffer::new(&super::Allowance::default()); + if pos + 4 <= input.len() { + let len_limit = input.len() - pos; + finder + .matches(input, pos, len_limit, pos, cut, &mut out) + .unwrap(); + } + all.push(out.into_vec()); + } + all + } + + #[test] + fn the_tree_reports_the_nearest_distance_for_each_length() { + // At the last "abcd" the nearest candidate matches everything there is, + // so it is the only report; nothing farther can improve on it. + let all = tree_matches_at_every_position(REPEATED, usize::MAX); + assert_eq!(all[12], [(4, 4)]); + // At position 8 both distances 4 and 8 match 8 bytes; only the nearer + // is worth reporting. + assert_eq!(all[8], [(8, 4)]); + } + + #[test] + fn the_tree_reports_runs_of_increasing_length_and_distance() { + // "abc" twelve bytes back, "abcde" twenty-two back. The parse wants + // both: the nearer is cheaper at its length, the farther reaches + // longer. + let input = b"abcdeXXXXX_abcdfYYYY__abcdeZZ"; + let all = tree_matches_at_every_position(input, usize::MAX); + assert_eq!(all[22], [(4, 11), (5, 22)]); + } + + #[test] + fn a_spent_budget_ends_the_descent_but_keeps_what_it_found() { + let input = b"abcdeXXXXX_abcdfYYYY__abcdeZZ"; + let all = tree_matches_at_every_position(input, 1); + assert_eq!(all[22], [(4, 11)]); + } + + #[test] + fn the_tree_drops_candidates_outside_its_window() { + let input = vec![b'x'; 4096]; + let mut finder = TreeMatchFinder::new(64); + let mut matches = super::Buffer::new(&super::Allowance::default()); + finder.matches(&input, 0, 16, 0, 8, &mut matches).unwrap(); + finder + .matches(&input, 2048, 16, 2048, 8, &mut matches) + .unwrap(); + assert!(matches.is_empty()); + } + + #[test] + fn the_tree_does_not_report_matches_beyond_the_requested_distance() { + let input = vec![b'x'; 64]; + let mut finder = TreeMatchFinder::new(64); + let mut matches = super::Buffer::new(&super::Allowance::default()); + finder.matches(&input, 0, 16, 0, 8, &mut matches).unwrap(); + finder.matches(&input, 16, 16, 8, 8, &mut matches).unwrap(); + assert!(matches.is_empty()); + } + + #[test] + fn a_refused_tree_child_table_releases_its_head_table() { + let head_bytes = (1 << 17) * std::mem::size_of::(); + let allowance = super::Allowance::limited(head_bytes as u64); + assert!(TreeMatchFinder::with_allowance(64, &allowance).is_err()); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn a_node_matching_the_whole_limit_hands_its_children_to_the_new_position() { + // Degenerate data: every position matches every earlier one to the + // limit, so each descent must stop at its first node rather than walk + // them all. Matching to the limit and improving on nothing are the + // only exits that leave a single report. + let input = vec![b'z'; 512]; + let all = tree_matches_at_every_position(&input, usize::MAX); + for (pos, matches) in all.iter().enumerate().skip(1).take(507) { + assert_eq!( + matches.as_slice(), + [((input.len() - pos) as u32, 1)], + "position {pos} did not stop at its nearest candidate", + ); + } + } + + #[test] + #[cfg(target_pointer_width = "64")] + fn resolving_recovers_a_position_stored_past_four_gigabytes() { + // The one path no member that fits in this machine's memory reaches: an + // input long enough that positions lose their high half. Measuring back + // from the newest position recovers them while the two are within four + // gigabytes of each other, which the window guarantees. + const FOUR_GIB: usize = 1 << 32; + let newest = FOUR_GIB + 16; + assert_eq!(resolve(newest, 16), newest); + assert_eq!(resolve(newest, 1), FOUR_GIB + 1); + assert_eq!(resolve(newest, 0), FOUR_GIB); + // Below the boundary the stored half wrapped and `newest` did not, so + // the two are only comparable through the subtraction. + assert_eq!(resolve(newest, u32::MAX - 1), FOUR_GIB - 2); + } +} diff --git a/arca-rar/vendor/rars/src/codec/mod.rs b/arca-rar/vendor/rars/src/codec/mod.rs new file mode 100644 index 00000000..5b326371 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/mod.rs @@ -0,0 +1,145 @@ +//! RAR compression codecs, filters, PPMd, and RARVM components used by `rars`. + +mod canonical; +pub(crate) mod fast; +pub(crate) mod filters; +#[cfg(any(test, feature = "write"))] +mod huffman; +#[cfg(any(test, feature = "write"))] +mod match_finder; +mod ppmd; +pub mod rar13; +pub mod rar20; +pub mod rar29; +pub mod rar50; +pub mod rarvm; +pub(crate) mod workspace; + +pub type Result = std::result::Result; + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + InvalidData(&'static str), + NeedMoreInput, + Cancelled, + WorkspaceLimitExceeded(Box), + /// An error carried by a reader or writer, including typed library errors + /// transported through `io::Error`. Successful decoding allocates no + /// diagnostic storage. + Io(Box), +} + +/// A refused codec allocation. Boxed by `Error` so successful codec operations +/// keep the existing compact Result layout. Diagnostic storage is not workspace. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct WorkspaceLimitError { + pub limit: u64, + /// Capacity required by this owner, including a simultaneous replacement. + pub required: u64, + pub used: u64, +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::InvalidData(msg) => write!(f, "{msg}"), + Self::NeedMoreInput => write!(f, "codec input is truncated"), + Self::Cancelled => f.write_str("codec operation was cancelled"), + Self::WorkspaceLimitExceeded(details) => { + write!(f, + "codec workspace limit {} exceeded: owner requires {} bytes with {} bytes in use", + details.limit, details.required, details.used) + } + Self::Io(error) => write!(f, "{error}"), + } + } +} + +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + Self::Io(error) => Some(error.as_ref()), + _ => None, + } + } +} + +impl From for Error { + fn from(error: std::io::Error) -> Self { + match crate::Error::from(error) { + crate::Error::Cancelled => Self::Cancelled, + crate::Error::Codec(error) => error, + error => Self::Io(Box::new(error)), + } + } +} + +impl Error { + fn from_read_error(error: std::io::Error) -> Self { + if error.kind() == std::io::ErrorKind::UnexpectedEof { + Self::NeedMoreInput + } else { + Self::from(error) + } + } +} + +impl From for Error { + fn from(never: std::convert::Infallible) -> Self { + match never {} + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::error::Error as _; + + #[test] + fn codec_io_errors_expose_the_library_cause_and_leaf_errors_have_no_source() { + let cause = crate::Error::InvalidHeader("bad block").at_archive_offset(42); + let error = Error::Io(Box::new(cause.clone())); + assert_eq!( + error.to_string(), + "at archive offset 0x2a: invalid header: bad block" + ); + let source = error.source().unwrap(); + assert_eq!(source.downcast_ref::(), Some(&cause)); + assert_eq!( + source.source().unwrap().to_string(), + "invalid header: bad block" + ); + for error in [ + Error::InvalidData("bad symbol"), + Error::NeedMoreInput, + Error::Cancelled, + Error::WorkspaceLimitExceeded(Box::new(WorkspaceLimitError { + limit: 1, + required: 2, + used: 1, + })), + ] { + assert!(error.source().is_none()); + } + } + + #[test] + fn codec_diagnostics_propagate_formatter_failure() { + struct RefuseFormatting; + impl std::fmt::Write for RefuseFormatting { + fn write_str(&mut self, _: &str) -> std::fmt::Result { + Err(std::fmt::Error) + } + } + let error = Error::WorkspaceLimitExceeded(Box::new(WorkspaceLimitError { + limit: 1, + required: 2, + used: 1, + })); + assert_eq!( + std::fmt::write(&mut RefuseFormatting, format_args!("{error}")), + Err(std::fmt::Error), + ); + } +} diff --git a/arca-rar/vendor/rars/src/codec/ppmd.rs b/arca-rar/vendor/rars/src/codec/ppmd.rs new file mode 100644 index 00000000..009a5d73 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/ppmd.rs @@ -0,0 +1,1971 @@ +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; + +const MAX_FREQ: u32 = 124; +const MIN_MODEL_CONTEXTS: usize = 1; + +// PPMd-H suballocator parameters, per the format-level spec at +// rar-research/doc/PPMD_ALGORITHM_SPECIFICATION.md §4. +const ALLOC_UNIT_BYTES: usize = 12; +const N_BUCKETS: usize = 38; +const MAX_BUCKET_UNITS: usize = 128; +// Spec §4.3: countdown reset value after a successful glue pass. +const GLUE_RESET: u32 = 255; +// Sentinel offset for "no allocation" (binary contexts carry their state +// inline; their array_offset field is unused but typed `u32`). +const NULL_OFFSET: u32 = u32::MAX; + +// Lookup tables built once from the spec's bucket-construction algorithm +// (§4.2): +// for i in 0..38: step = if i >= 12 { 4 } else { i / 4 + 1 } +// repeat step times: units_to_index[k++] = i +// index_to_units[i] = k +struct AllocTables { + units_to_index: [u8; MAX_BUCKET_UNITS], + index_to_units: [u8; N_BUCKETS], +} + +fn build_alloc_tables() -> AllocTables { + let mut units_to_index = [0u8; MAX_BUCKET_UNITS]; + let mut index_to_units = [0u8; N_BUCKETS]; + let mut k: usize = 0; + for (i, index_to_unit) in index_to_units.iter_mut().enumerate() { + let step = if i >= 12 { 4 } else { i / 4 + 1 }; + for _ in 0..step { + // The bucket construction has exactly 128 entries: the first + // 12 buckets contribute 24 and the remaining 26 contribute 104. + units_to_index[k] = i as u8; + k += 1; + } + *index_to_unit = k.min(u8::MAX as usize) as u8; + } + AllocTables { + units_to_index, + index_to_units, + } +} + +fn alloc_tables() -> &'static AllocTables { + use std::sync::OnceLock; + static TABLES: OnceLock = OnceLock::new(); + TABLES.get_or_init(build_alloc_tables) +} + +// Spec §4.1 layout: contexts grow downward from `hi_unit`, state arrays +// grow upward from `lo_unit`. Tracking the side matters for adjacency +// patterns (gluing) and for which bump pointer advances. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum AllocSide { + Lo, // state arrays + Hi, // context headers +} + +#[derive(Debug)] +struct Suballocator { + read_control: crate::read_control::ReadControl, + // Original pool size in bytes (C's p->Size). Preserved across restarts so + // the text/units split — which depends on the exact byte size, not the + // unit-truncated one — stays identical to the reference each restart. + size_bytes: usize, + // Total unit budget (= dict_mb * 1 MiB / 12, capped at u32::MAX). + pool_units: u32, + // Byte slack at the pool top (= Size % UNIT_SIZE). The C reference sets + // HiUnit = Base + Size with Size not necessarily a unit multiple, so all + // its pointers sit at `unit*12 + rem`. We keep unit offsets but fold this + // remainder into byte-domain comparisons (text capacity / fallback bump) + // so restart timing matches the reference exactly. + rem: u32, + // Text region capacity in bytes. text_ptr reaching this triggers a + // restart. Mirrors C's UnitsStart byte pointer (= Size - 84*text_units). + text_capacity_bytes: usize, + // Bump pointers (in units). lo_bump grows up, hi_bump grows down; + // valid bumpable space is [lo_bump, hi_bump). Both start at units_start. + units_start: u32, + lo_bump: u32, + hi_bump: u32, + // Free lists hold released block offsets (in units), one list per bucket. + free_lists: [Buffer; N_BUCKETS], + // Countdown for the glue pass (spec §4.3). Starts at 0, gets refreshed + // to GLUE_RESET after each successful glue. + glue_count: u32, + // Test escape hatch: when reset hasn't been called (pool_units == 0), + // act as unbounded so unit tests bypassing decode_init still work. + unbounded: bool, +} + +impl Suballocator { + fn try_clone(&self) -> Result { + let allowance = self.free_lists[0].allowance(); + let mut free_lists = std::array::from_fn(|_| Buffer::new(&allowance)); + for (copy, original) in free_lists.iter_mut().zip(&self.free_lists) { + *copy = Buffer::copied(original, &allowance)?; + } + Ok(Self { + read_control: self.read_control.clone(), + size_bytes: self.size_bytes, + pool_units: self.pool_units, + rem: self.rem, + text_capacity_bytes: self.text_capacity_bytes, + units_start: self.units_start, + lo_bump: self.lo_bump, + hi_bump: self.hi_bump, + free_lists, + glue_count: self.glue_count, + unbounded: self.unbounded, + }) + } + fn with_allowance(allowance: &B) -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + size_bytes: 0, + pool_units: 0, + rem: 0, + text_capacity_bytes: 0, + units_start: 0, + lo_bump: 0, + hi_bump: 0, + free_lists: std::array::from_fn(|_| Buffer::new(allowance)), + glue_count: 0, + unbounded: true, + } + } +} + +impl Suballocator { + fn reset(&mut self, pool_bytes: usize) { + let pool_units_usize = pool_bytes / ALLOC_UNIT_BYTES; + // Cap at u32::MAX-1 (NULL_OFFSET is u32::MAX). Even 256 MiB / 12 = + // ~22M fits comfortably, so this is theoretical. + let pool_units = pool_units_usize.min(u32::MAX as usize - 1) as u32; + // Ppmd7_RestartModel byte layout: + // text_units = Size / 8 / UNIT_SIZE + // UnitsStart = HiUnit - 7 * text_units * UNIT_SIZE + // i.e. the units region is exactly 7*text_units units carved off the + // top; the leftover slack (Size % 96, plus Size % 12) all stays in the + // text region. The previous code took `pool_units / 8` for text and + // gave the slack to the units region — 5+ extra bump units versus the + // reference, which desynchronised restart timing on large inputs. + let text_units = (pool_bytes / 8 / ALLOC_UNIT_BYTES) as u32; + let units_region = text_units.saturating_mul(7).min(pool_units); + self.size_bytes = pool_bytes; + self.pool_units = pool_units; + self.rem = (pool_bytes % ALLOC_UNIT_BYTES) as u32; + self.units_start = pool_units - units_region; + self.lo_bump = self.units_start; + self.hi_bump = pool_units; + // UnitsStart byte pointer = units_start*12 + rem (= Size - 84*text_units). + self.text_capacity_bytes = self.units_start as usize * ALLOC_UNIT_BYTES + self.rem as usize; + for fl in &mut self.free_lists { + fl.clear(); + } + self.glue_count = 0; + self.unbounded = pool_bytes == 0; + } + + fn bucket_for(units: usize) -> Option { + if units == 0 || units > MAX_BUCKET_UNITS { + return None; + } + Some(alloc_tables().units_to_index[units - 1] as usize) + } + + fn bucket_units(bucket: usize) -> usize { + alloc_tables().index_to_units[bucket] as usize + } + + fn try_alloc( + &mut self, + units: usize, + side: AllocSide, + text_len_bytes: usize, + ) -> Result> { + let Some(bucket) = Self::bucket_for(units) else { + return Ok(None); + }; + // Reference ordering differs by side. Lo-side state arrays go through + // `Ppmd7_AllocUnits` (free_list first, then lo-bump, then rare). Hi-side + // 1-unit context headers go through the inlined sequence in + // `Ppmd7_CreateSuccessors` (hi-bump first, then free_list[0], then + // `Ppmd7_AllocUnitsRare(0)`). The two are not interchangeable: every + // time a free 1-unit block exists alongside hi-side headroom, the two + // orderings consume different memory cells. Adjacency at the next glue + // diverges, and the drift compounds across millions of decode steps. + match side { + AllocSide::Hi => { + if let Some(offset) = self.try_bump(bucket, side) { + return Ok(Some(offset)); + } + if let Some(offset) = self.free_lists[bucket].pop() { + return Ok(Some(offset)); + } + } + AllocSide::Lo => { + if let Some(offset) = self.free_lists[bucket].pop() { + return Ok(Some(offset)); + } + if let Some(offset) = self.try_bump(bucket, side) { + return Ok(Some(offset)); + } + } + } + // Rare path (mirrors Ppmd7_AllocUnitsRare): + // 1. If glue_count == 0, glue and retry the bucket's free list. + // 2. Walk upward through larger buckets; if found, split. + // 3. Otherwise shrink units_start (consume text-reservation). + if self.glue_count == 0 { + self.glue_inner()?; + self.glue_count = GLUE_RESET; + if let Some(offset) = self.free_lists[bucket].pop() { + return Ok(Some(offset)); + } + } + for i in (bucket + 1)..N_BUCKETS { + if let Some(offset) = self.free_lists[i].pop() { + let large_size = Self::bucket_units(i) as u32; + let need = Self::bucket_units(bucket) as u32; + let leftover = large_size - need; + self.emit_run(offset + need, leftover)?; + return Ok(Some(offset)); + } + } + self.glue_count = self.glue_count.saturating_sub(1); + Ok(self.fallback_bump(bucket, text_len_bytes)) + } + + // Spec / ref Ppmd7_AllocUnitsRare bump-fallback: when no free block at + // any bucket size satisfies the request, shrink `units_start` downward + // (into the text-reservation zone). Succeeds only if the new units + // floor would still sit above the current text-write position. + fn fallback_bump(&mut self, bucket: usize, text_len_bytes: usize) -> Option { + // An unbounded allocator always succeeds in try_bump, so only a + // bounded pool reaches this fallback. + let need_units = Self::bucket_units(bucket) as u32; + let need_bytes = need_units as u64 * ALLOC_UNIT_BYTES as u64; + // UnitsStart byte pointer includes the pool-top remainder, matching + // the C reference (all its pointers sit at unit*12 + rem). + let units_start_bytes = self.units_start as u64 * ALLOC_UNIT_BYTES as u64 + self.rem as u64; + // Match C: `(us - Text) > numBytes`. Strict greater-than (not ≥). + if units_start_bytes <= text_len_bytes as u64 + need_bytes { + return None; + } + let new_units_start = self.units_start - need_units; + self.units_start = new_units_start; + // Lower the text capacity so text_has_room reflects the new boundary. + self.text_capacity_bytes = new_units_start as usize * ALLOC_UNIT_BYTES + self.rem as usize; + Some(new_units_start) + } + + fn try_bump(&mut self, bucket: usize, side: AllocSide) -> Option { + let block = Self::bucket_units(bucket) as u32; + if self.unbounded { + // No real pool; hand out monotonic offsets so each alloc is + // distinguishable but never adjacent to another (so gluing is + // a no-op for the tests). + let off = self.lo_bump; + self.lo_bump = self.lo_bump.saturating_add(block); + return Some(off); + } + // hi_bump - lo_bump is the bumpable headroom in units. + if self.hi_bump.saturating_sub(self.lo_bump) < block { + return None; + } + match side { + AllocSide::Lo => { + let off = self.lo_bump; + self.lo_bump += block; + Some(off) + } + AllocSide::Hi => { + self.hi_bump -= block; + Some(self.hi_bump) + } + } + } + + fn try_free(&mut self, offset: u32, units: usize) -> Result<()> { + if offset == NULL_OFFSET { + return Ok(()); + } + if let Some(bucket) = Self::bucket_for(units) { + self.free_lists[bucket].try_push(offset)?; + } + Ok(()) + } + + // Ppmd7_SplitBlock: carve a block of `old_units` (bucket I2U value) down + // to `new_units` (bucket I2U value) in place. The first `new_units` + // stay at `base_offset`; the (old_units - new_units) residue is pushed + // onto the appropriate smaller bucket(s). The "kept" prefix is NOT + // pushed — the caller is still using it as live storage. + fn try_split_in_place( + &mut self, + base_offset: u32, + old_units: u32, + new_units: u32, + ) -> Result<()> { + let nu = old_units - new_units; + let residue_offset = base_offset + new_units; + // Both inputs are distinct bucket sizes; their difference is 1..128. + let mut i = Self::bucket_for(nu as usize).expect("split residue is a valid bucket size"); + if Self::bucket_units(i) as u32 != nu { + // Inexact fit: the C reference pushes the smaller piece first + // (at offset + bucket_units(i-1)) onto bucket index `nu - k - 1`, + // then the i-1-sized prefix onto bucket i-1. Order across + // buckets is irrelevant; per-bucket LIFO is unaffected. + let k = Self::bucket_units(i - 1) as u32; + let small_bucket = (nu - k - 1) as usize; + self.free_lists[small_bucket].try_push(residue_offset + k)?; + i -= 1; + } + self.free_lists[i].try_push(residue_offset)?; + Ok(()) + } + + // Faithful port of Ppmd7_GlueFreeBlocks (§4.4). The earlier + // sort-by-offset version diverged from the reference in three ways that + // all change the resulting free-list state — and therefore the timing of + // the next allocation failure / model restart: + // 1. Threading order: the reference walks free_list[0..38], each list + // head-first (most-recent first), prepending every node to a single + // glue list. We rebuild that exact order so the fill pass re-buckets + // runs in the same sequence (per-bucket LIFO must match). + // 2. Merge cap: a merged run may not reach 0x10000 units (NU is 16-bit). + // 3. Fill split: runs are emitted as repeated 128-unit blocks, then the + // <=128 remainder via Ppmd7_SplitBlock's exact-or-two-piece rule — + // not "largest bucket fitting" greedily. + fn glue_inner(&mut self) -> Result<()> { + let mut poller = self.read_control.poller(); + // Step 1: thread free blocks into the reference's list order. + // list[k] = (offset, nu). The reference's prepend walk ends with + // bucket 37 first, each bucket in its original Vec order. + let allowance = self.free_lists[0].allowance(); + let count = self.free_lists.iter().try_fold(0usize, |total, list| { + total + .checked_add(list.len()) + .ok_or(Error::InvalidData("PPMd free-list size overflows")) + })?; + let mut list = Buffer::with_capacity(count, &allowance)?; + // Reversing the bucket order and visiting each bucket oldest-first + // produces exactly the prior head-first/prepend walk, without moving + // all previous entries for each insertion. + for bucket in (0..N_BUCKETS).rev() { + let nu = Self::bucket_units(bucket) as u32; + for &off in &self.free_lists[bucket] { + poller.check_codec(0)?; + list.push_admitted((off, nu)); + } + self.free_lists[bucket].clear(); + } + if list.is_empty() { + return Ok(()); + } + + // Step 2: glue pass. Absorb the physically-next free block while the + // combined size stays < 0x10000. `nu_at` maps a block's start offset + // to its current size; absorbed blocks are set to 0. + let mut nu_at = GlueIndex::new(&list, &allowance, &self.read_control)?; + for &(off, _) in list.iter() { + poller.check_codec(0)?; + let mut cur = match nu_at.get(&off) { + Some(&n) if n != 0 => n, + _ => continue, + }; + loop { + poller.check_codec(0)?; + let next_off = off + cur; + match nu_at.get(&next_off) { + Some(&n2) => { + let new = cur + n2; + if new >= 0x10000 { + break; + } + cur = new; + nu_at.insert(next_off, 0); + } + None => break, + } + } + nu_at.insert(off, cur); + } + + // Step 3: fill pass in list order. + for &(off, _) in list.iter() { + poller.check_codec(0)?; + let nu = match nu_at.get(&off) { + Some(&n) if n != 0 => n, + _ => continue, + }; + self.emit_run(off, nu)?; + } + Ok(()) + } + + // Re-bucket a single merged run exactly as Ppmd7_GlueFreeBlocks' fill / + // Ppmd7_SplitBlock do: peel 128-unit (bucket 37) blocks, then split the + // <=128 remainder into its exact bucket, or two pieces when inexact. + fn emit_run(&mut self, mut offset: u32, mut remaining: u32) -> Result<()> { + const LAST_BUCKET: usize = N_BUCKETS - 1; // 37 == 128 units + while remaining > MAX_BUCKET_UNITS as u32 { + self.push_free(LAST_BUCKET, offset)?; + offset += MAX_BUCKET_UNITS as u32; + remaining -= MAX_BUCKET_UNITS as u32; + } + // Callers pass positive runs; the loop leaves 1..=128 units. + let mut i = Self::bucket_for(remaining as usize).expect("run remainder fits a bucket"); + if Self::bucket_units(i) as u32 != remaining { + let k = Self::bucket_units(i - 1) as u32; + let small_bucket = (remaining - k - 1) as usize; + self.push_free(small_bucket, offset + k)?; + i -= 1; + } + self.push_free(i, offset)?; + Ok(()) + } + + fn push_free(&mut self, bucket: usize, offset: u32) -> Result<()> { + self.free_lists[bucket].try_push(offset) + } + + fn text_has_room(&self, text_len: usize) -> bool { + // When pool isn't initialised (test fixtures that bypass decode_init), + // text_capacity is 0 — treat that as "unbounded" so we don't break + // out-of-band callers. + self.text_capacity_bytes == 0 || text_len < self.text_capacity_bytes + } +} +const BIN_SCALE: u32 = 1 << 14; +const INT_BITS: u32 = 7; +const PERIOD_BITS: u8 = 7; +const TOP: u32 = 1 << 24; +const BOT: u32 = 1 << 15; +const INIT_BIN_ESC: [u16; 8] = [ + 0x3cdd, 0x1f3f, 0x59bf, 0x48f3, 0x64a1, 0x5abc, 0x6632, 0x6051, +]; +const EXP_ESCAPE: [u8; 16] = [25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2]; + +pub trait PpmdByteReader { + fn read_ppmd_byte(&mut self) -> Result; +} + +#[derive(Debug, Clone)] +#[cfg(any(test, feature = "write"))] +pub struct PpmdDecoder { + state: PpmdState, +} +impl Clone for PpmdState { + fn clone(&self) -> Self { + self.try_clone().expect("unlimited PPMd model copy") + } +} +#[cfg(any(test, feature = "write"))] +impl PpmdDecoder { + pub fn new() -> Self { + Self { + state: PpmdState::with_allowance(&Allowance::default()), + } + } +} +#[cfg(test)] +impl PpmdState { + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } +} +#[derive(Debug)] +pub(crate) struct PpmdState { + min_context: usize, + max_context: usize, + found_state: StateRef, + order_fall: usize, + init_esc: u32, + prev_success: u32, + max_order: usize, + hi_bits_flag: u32, + run_length: i32, + init_rl: i32, + ns2bs_indx: [u8; 256], + ns2indx: [u8; 256], + bin_summ: [[u16; 64]; 128], + see: [[See; 16]; 25], + dummy_see: See, + contexts: Buffer, B>, + text: Buffer, + range: RangeDecoder, + allocated: bool, + max_contexts: usize, + suballoc: Suballocator, +} + +#[derive(Debug, Clone)] +#[cfg(any(test, feature = "write"))] +pub struct PpmdEncoder { + model: PpmdDecoder, + range: RangeEncoder, + esc_char: u8, +} + +#[derive(Debug)] +struct Context { + states: Buffer, + summ_freq: u16, + suffix: Option, + // Simulated suballoc offsets so gluing (spec §4.3) can detect adjacency. + // header_offset: from Hi side (1 unit). array_offset: from Lo side, + // set to NULL_OFFSET for binary contexts (states.len() == 1) which + // carry their state inline. + header_offset: u32, + array_offset: u32, +} + +impl Context { + fn try_clone(&self) -> Result { + Ok(Self { + states: Buffer::copied(&self.states, &self.states.allowance())?, + summ_freq: self.summ_freq, + suffix: self.suffix, + header_offset: self.header_offset, + array_offset: self.array_offset, + }) + } +} + +#[derive(Debug, Clone, Copy)] +struct State { + symbol: u8, + freq: u8, + successor: Successor, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Successor { + None, + Raw(usize), + Context(usize), +} + +#[derive(Debug, Clone, Copy)] +struct StateRef { + context: usize, + index: usize, +} + +#[derive(Debug, Clone, Copy)] +struct See { + summ: u16, + shift: u8, + count: u8, +} + +#[derive(Debug, Clone)] +struct RangeDecoder { + range: u32, + code: u32, + low: u32, +} + +impl PpmdState { + pub(crate) fn set_read_control(&mut self, control: crate::read_control::ReadControl) { + self.suballoc.read_control = control; + } + pub(crate) fn with_allowance(allowance: &B) -> Self { + let mut ns2bs_indx = [0u8; 256]; + ns2bs_indx[0] = 0; + ns2bs_indx[1] = 2; + ns2bs_indx[2..11].fill(4); + ns2bs_indx[11..].fill(6); + + let mut ns2indx = [0u8; 256]; + ns2indx[0] = 0; + ns2indx[1] = 1; + ns2indx[2] = 2; + let mut m = 3u8; + let mut k = 1u8; + for item in ns2indx.iter_mut().skip(3) { + *item = m; + k -= 1; + if k == 0 { + m += 1; + k = m - 2; + } + } + + Self { + min_context: 0, + max_context: 0, + found_state: StateRef { + context: 0, + index: 0, + }, + order_fall: 0, + init_esc: 0, + prev_success: 0, + max_order: 0, + hi_bits_flag: 0, + run_length: 0, + init_rl: 0, + ns2bs_indx, + ns2indx, + bin_summ: [[0; 64]; 128], + see: [[See { + summ: 0, + shift: 0, + count: 0, + }; 16]; 25], + dummy_see: See { + summ: 0, + shift: PERIOD_BITS, + count: 64, + }, + contexts: Buffer::new(allowance), + text: Buffer::new(allowance), + range: RangeDecoder::new(), + allocated: false, + max_contexts: MIN_MODEL_CONTEXTS, + suballoc: Suballocator::with_allowance(allowance), + } + } + + // Units occupied by a context's state array. Single-state (binary) + // contexts store the state inline, so the array is 0 units. Otherwise + // ceil(n/2) units fit n states at 2-per-unit (states are 6 bytes each). + fn state_array_units(n: usize) -> usize { + if n < 2 { + 0 + } else { + n.div_ceil(2) + } + } + + pub(crate) fn try_clone(&self) -> Result { + Ok(Self { + min_context: self.min_context, + max_context: self.max_context, + found_state: self.found_state, + order_fall: self.order_fall, + init_esc: self.init_esc, + prev_success: self.prev_success, + max_order: self.max_order, + hi_bits_flag: self.hi_bits_flag, + run_length: self.run_length, + init_rl: self.init_rl, + ns2bs_indx: self.ns2bs_indx, + ns2indx: self.ns2indx, + bin_summ: self.bin_summ, + see: self.see, + dummy_see: self.dummy_see, + contexts: Buffer::try_collect( + self.contexts.iter().map(Context::try_clone), + &self.contexts.allowance(), + )?, + text: Buffer::copied(&self.text, &self.text.allowance())?, + range: self.range.clone(), + allocated: self.allocated, + max_contexts: self.max_contexts, + suballoc: self.suballoc.try_clone()?, + }) + } + pub fn decode_init( + &mut self, + first_byte: u8, + input: &mut impl PpmdByteReader, + esc_char: &mut u8, + ) -> Result<()> { + let reset = first_byte & 0x20 != 0; + let max_mb = if reset { + Some(input.read_ppmd_byte()?) + } else { + None + }; + if first_byte & 0x40 != 0 { + *esc_char = input.read_ppmd_byte()?; + } + self.range.init(input)?; + if reset { + let mut max_order = ((first_byte & 0x1f) as usize) + 1; + if max_order > 16 { + max_order = 16 + (max_order - 16) * 3; + } + if max_order == 1 { + return Err(Error::InvalidData("RAR PPMd order is invalid")); + } + let dictionary_mb = max_mb.unwrap_or(0) as usize + 1; + self.max_contexts = model_context_limit(dictionary_mb); + self.suballoc + .reset(dictionary_mb.saturating_mul(1024 * 1024)); + self.init_model(max_order)?; + self.allocated = true; + } else if !self.allocated { + return Err(Error::InvalidData("RAR PPMd block reuses missing model")); + } + Ok(()) + } + + pub fn decode_symbol(&mut self, input: &mut impl PpmdByteReader) -> Result> { + // Ordinary symbol/context work is bounded by the model order and the + // 256-symbol alphabet; the enclosing decoder polls between symbols. + // Free-list maintenance can traverse the whole model and polls itself. + self.decode_symbol_inner(input) + } + + fn decode_symbol_inner(&mut self, input: &mut impl PpmdByteReader) -> Result> { + let mut mask = [true; 256]; + let min = self.min_context; + if self.contexts[min].states.len() != 1 { + let summ_freq = self.contexts[min].summ_freq as u32; + if summ_freq > self.range.range { + return Err(Error::InvalidData("RAR PPMd range is invalid")); + } + let mut count = self.range.get_threshold(summ_freq)?; + let mut hi_cnt = 0u32; + let mut found = None; + for (index, state) in self.contexts[min].states.iter().enumerate() { + if count < state.freq as u32 { + found = Some((index, hi_cnt, state.freq as u32, state.symbol)); + break; + } + count -= state.freq as u32; + hi_cnt += state.freq as u32; + } + if let Some((index, start, size, symbol)) = found { + self.range.decode(start, size); + self.found_state = StateRef { + context: min, + index, + }; + if index == 0 { + self.update1_0()?; + } else { + self.prev_success = 0; + self.update1()?; + } + self.range.normalize(input)?; + return Ok(Some(symbol)); + } + if hi_cnt >= summ_freq { + return Err(Error::InvalidData("RAR PPMd frequency sum is invalid")); + } + self.prev_success = 0; + self.range.decode(hi_cnt, summ_freq - hi_cnt); + self.hi_bits_flag = hi_bits_flag(self.state(self.found_state)?.symbol, 3); + for state in &self.contexts[min].states { + mask[state.symbol as usize] = false; + } + } else { + let state = self.contexts[min].states[0]; + let idx = self.bin_summ_index(state)?; + let prob = self.bin_summ[idx.0][idx.1] as u32; + let size0 = (self.range.range >> 14).wrapping_mul(prob); + let next_prob = update_prob_1(prob); + if self.range.code.wrapping_sub(self.range.low) < size0 { + self.bin_summ[idx.0][idx.1] = (next_prob + (1 << INT_BITS)) as u16; + self.range.decode_bit0(size0); + self.found_state = StateRef { + context: min, + index: 0, + }; + self.update_bin()?; + self.range.normalize(input)?; + return Ok(Some(state.symbol)); + } + self.bin_summ[idx.0][idx.1] = next_prob as u16; + self.init_esc = EXP_ESCAPE[(next_prob >> 10) as usize] as u32; + self.range.decode_bit1(size0); + mask[state.symbol as usize] = false; + self.prev_success = 0; + } + + loop { + self.range.normalize(input)?; + let mut mc = self.min_context; + let num_masked = self.contexts[mc].states.len(); + loop { + self.order_fall += 1; + let Some(suffix) = self.contexts[mc].suffix else { + return Ok(None); + }; + mc = suffix; + if self.contexts[mc].states.len() != num_masked { + break; + } + } + self.min_context = mc; + + let hi_cnt = self.contexts[mc] + .states + .iter() + .filter(|state| mask[state.symbol as usize]) + .map(|state| state.freq as u32) + .sum::(); + let (see_ref, esc_freq) = self.make_esc_freq(num_masked)?; + let freq_sum = hi_cnt + esc_freq; + if freq_sum > self.range.range { + return Err(Error::InvalidData("RAR PPMd escape range is invalid")); + } + let mut count = self.range.get_threshold(freq_sum)?; + if count < hi_cnt { + let mut start = 0u32; + let mut selected = None; + for (index, state) in self.contexts[mc].states.iter().enumerate() { + if !mask[state.symbol as usize] { + continue; + } + let freq = state.freq as u32; + if count < freq { + selected = Some((index, start, freq, state.symbol)); + break; + } + count -= freq; + start += freq; + } + // hi_cnt was summed from these same unmodified, unmasked + // frequencies, so count < hi_cnt must select a state. + let (index, start, freq, symbol) = + selected.expect("masked threshold selects a state"); + self.range.decode(start, freq); + self.update_see(see_ref); + self.found_state = StateRef { context: mc, index }; + self.update2()?; + self.range.normalize(input)?; + return Ok(Some(symbol)); + } + if count >= freq_sum { + return Err(Error::InvalidData("RAR PPMd escape symbol is invalid")); + } + self.range.decode(hi_cnt, freq_sum - hi_cnt); + self.add_see_summ(see_ref, freq_sum); + for state in &self.contexts[mc].states { + mask[state.symbol as usize] = false; + } + } + } + + #[cfg(any(test, feature = "write"))] + fn encode_symbol(&mut self, symbol: u8, output: &mut RangeEncoder) -> Result<()> { + let mut mask = [true; 256]; + let min = self.min_context; + if self.contexts[min].states.len() != 1 { + let summ_freq = self.contexts[min].summ_freq as u32; + let mut start = 0u32; + let mut found = None; + for (index, state) in self.contexts[min].states.iter().enumerate() { + if state.symbol == symbol { + found = Some((index, start, state.freq as u32)); + break; + } + start += state.freq as u32; + } + if let Some((index, start, size)) = found { + output.encode(start, size, summ_freq); + self.found_state = StateRef { + context: min, + index, + }; + if index == 0 { + self.update1_0()?; + } else { + self.prev_success = 0; + self.update1()?; + } + output.normalize(); + return Ok(()); + } + if start >= summ_freq { + return Err(Error::InvalidData("RAR PPMd frequency sum is invalid")); + } + self.prev_success = 0; + output.encode(start, summ_freq - start, summ_freq); + self.hi_bits_flag = hi_bits_flag(self.state(self.found_state)?.symbol, 3); + for state in &self.contexts[min].states { + mask[state.symbol as usize] = false; + } + } else { + let state = self.contexts[min].states[0]; + let idx = self.bin_summ_index(state)?; + let prob = self.bin_summ[idx.0][idx.1] as u32; + let size0 = (output.range >> 14).wrapping_mul(prob); + let next_prob = update_prob_1(prob); + if state.symbol == symbol { + self.bin_summ[idx.0][idx.1] = (next_prob + (1 << INT_BITS)) as u16; + output.encode_bit0(size0); + self.found_state = StateRef { + context: min, + index: 0, + }; + self.update_bin()?; + output.normalize(); + return Ok(()); + } + self.bin_summ[idx.0][idx.1] = next_prob as u16; + self.init_esc = EXP_ESCAPE[(next_prob >> 10) as usize] as u32; + output.encode_bit1(size0); + mask[state.symbol as usize] = false; + self.prev_success = 0; + } + + loop { + output.normalize(); + let mut mc = self.min_context; + let num_masked = self.contexts[mc].states.len(); + loop { + self.order_fall += 1; + let Some(suffix) = self.contexts[mc].suffix else { + return Err(Error::InvalidData("RAR PPMd symbol is not encodable")); + }; + mc = suffix; + if self.contexts[mc].states.len() != num_masked { + break; + } + } + self.min_context = mc; + + let hi_cnt = self.contexts[mc] + .states + .iter() + .filter(|state| mask[state.symbol as usize]) + .map(|state| state.freq as u32) + .sum::(); + let (see_ref, esc_freq) = self.make_esc_freq(num_masked)?; + let freq_sum = hi_cnt + esc_freq; + let mut start = 0u32; + let mut found = None; + for (index, state) in self.contexts[mc].states.iter().enumerate() { + if !mask[state.symbol as usize] { + continue; + } + let freq = state.freq as u32; + if state.symbol == symbol { + found = Some((index, start, freq)); + break; + } + start += freq; + } + if let Some((index, start, freq)) = found { + output.encode(start, freq, freq_sum); + self.update_see(see_ref); + self.found_state = StateRef { context: mc, index }; + self.update2()?; + output.normalize(); + return Ok(()); + } + output.encode(hi_cnt, freq_sum - hi_cnt, freq_sum); + self.add_see_summ(see_ref, freq_sum); + for state in &self.contexts[mc].states { + mask[state.symbol as usize] = false; + } + } + } + + fn init_model(&mut self, max_order: usize) -> Result<()> { + self.suballoc.read_control.check_codec()?; + self.contexts.clear(); + self.text.clear(); + // Spec §5.2 RestartModel: clear free lists, reserve root context + // (1 unit from Hi) + its 256-state array (128 units from Lo). + // Reuse the exact original byte size (C's p->Size) so the text/units + // split and the pool-top remainder survive the restart unchanged. + let unbounded_before = self.suballoc.unbounded; + let reset_arg = if unbounded_before { + 0 + } else { + self.suballoc.size_bytes + }; + self.suballoc.reset(reset_arg); + // At init time text is empty. + let header_offset = self + .suballoc + .try_alloc(1, AllocSide::Hi, 0)? + .unwrap_or(NULL_OFFSET); + let array_offset = self + .suballoc + .try_alloc(128, AllocSide::Lo, 0)? + .unwrap_or(NULL_OFFSET); + self.max_order = max_order; + self.order_fall = max_order; + self.init_rl = -(max_order.min(12) as i32) - 1; + self.run_length = self.init_rl; + self.prev_success = 0; + + let states = Buffer::collect( + (0..=255).map(|symbol| State { + symbol, + freq: 1, + successor: Successor::None, + }), + &self.contexts.allowance(), + )?; + self.contexts.try_push(Context { + states, + summ_freq: 257, + suffix: None, + header_offset, + array_offset, + })?; + self.min_context = 0; + self.max_context = 0; + self.found_state = StateRef { + context: 0, + index: 0, + }; + + for i in 0..128 { + for (k, &init_bin_esc) in INIT_BIN_ESC.iter().enumerate() { + let value = BIN_SCALE - u32::from(init_bin_esc) / (i as u32 + 2); + for m in (0..64).step_by(8) { + self.bin_summ[i][k + m] = value as u16; + } + } + } + for i in 0..25 { + let summ = ((5 * i + 10) << (PERIOD_BITS - 4)) as u16; + for k in 0..16 { + self.see[i][k] = See { + summ, + shift: PERIOD_BITS - 4, + count: 4, + }; + } + } + self.dummy_see = See { + summ: 0, + shift: PERIOD_BITS, + count: 64, + }; + Ok(()) + } + + fn bin_summ_index(&mut self, state: State) -> Result<(usize, usize)> { + let suffix = self.contexts[self.min_context] + .suffix + .ok_or(Error::InvalidData("RAR PPMd binary context has no suffix"))?; + let suffix_stats = self.contexts[suffix].states.len(); + self.hi_bits_flag = hi_bits_flag(self.state(self.found_state)?.symbol, 3); + let row = state.freq as usize - 1; + let col = self.prev_success as usize + + ((self.run_length >> 26) as usize & 0x20) + + self.ns2bs_indx[suffix_stats - 1] as usize + + hi_bits_flag(state.symbol, 4) as usize + + self.hi_bits_flag as usize; + Ok((row, col)) + } + + fn make_esc_freq(&mut self, num_masked: usize) -> Result<(SeeRef, u32)> { + let mc = self.min_context; + let num_stats = self.contexts[mc].states.len(); + if num_stats == 256 { + return Ok((SeeRef::Dummy, 1)); + } + if num_masked >= num_stats { + return Err(Error::InvalidData("RAR PPMd masked-state count is invalid")); + } + // The guard above establishes num_masked < num_stats. + let non_masked = num_stats - num_masked; + let suffix = self.contexts[mc].suffix.unwrap_or(mc); + let suffix_stats = self.contexts[suffix].states.len(); + // Spec §9.1: the subtraction is unsigned C wraparound — when + // `suffix.num_stats < min_context.num_stats`, the underflow yields a + // very large value and the `non_masked < suffix_delta` comparison + // evaluates to TRUE. Replicate the wraparound here. + let suffix_delta = suffix_stats.wrapping_sub(num_stats); + let col = (non_masked < suffix_delta) as usize + + 2 * ((self.contexts[mc].summ_freq as usize) < 11 * num_stats) as usize + + 4 * (num_masked > non_masked) as usize + + self.hi_bits_flag as usize; + let row = self.ns2indx[non_masked - 1] as usize; + let see = &mut self.see[row][col]; + let summ = see.summ; + let r = (summ >> see.shift) as u32; + see.summ = summ.wrapping_sub(r as u16); + Ok((SeeRef::Table(row, col), r + u32::from(r == 0))) + } + + fn update_see(&mut self, see_ref: SeeRef) { + let see = match see_ref { + SeeRef::Dummy => &mut self.dummy_see, + SeeRef::Table(row, col) => &mut self.see[row][col], + }; + if see.shift < PERIOD_BITS { + see.count = see.count.wrapping_sub(1); + if see.count == 0 { + see.summ = see.summ.wrapping_shl(1); + see.count = 3 << see.shift; + see.shift += 1; + } + } + } + + fn add_see_summ(&mut self, see_ref: SeeRef, value: u32) { + let see = match see_ref { + SeeRef::Dummy => &mut self.dummy_see, + SeeRef::Table(row, col) => &mut self.see[row][col], + }; + see.summ = see.summ.wrapping_add(value as u16); + } + + fn update1_0(&mut self) -> Result<()> { + let fs = self.found_state; + let freq = self.state(fs)?.freq as u32; + let summ_freq = self.contexts[fs.context].summ_freq as u32; + self.prev_success = u32::from(2 * freq > summ_freq); + self.run_length += self.prev_success as i32; + self.contexts[fs.context].summ_freq = self.contexts[fs.context].summ_freq.wrapping_add(4); + self.state_mut(fs)?.freq = (freq + 4) as u8; + if freq + 4 > MAX_FREQ { + self.rescale()?; + } + self.next_context() + } + + fn update1(&mut self) -> Result<()> { + let fs = self.found_state; + let freq = self.state(fs)?.freq as u32 + 4; + self.contexts[fs.context].summ_freq = self.contexts[fs.context].summ_freq.wrapping_add(4); + self.state_mut(fs)?.freq = freq as u8; + // Both decode and encode call update1 only for a non-first state. + if self.contexts[fs.context].states[fs.index].freq + > self.contexts[fs.context].states[fs.index - 1].freq + { + self.contexts[fs.context] + .states + .swap(fs.index, fs.index - 1); + self.found_state.index -= 1; + if freq > MAX_FREQ { + self.rescale()?; + } + } + self.next_context() + } + + fn update2(&mut self) -> Result<()> { + let fs = self.found_state; + let freq = self.state(fs)?.freq as u32 + 4; + self.run_length = self.init_rl; + self.contexts[fs.context].summ_freq = self.contexts[fs.context].summ_freq.wrapping_add(4); + self.state_mut(fs)?.freq = freq as u8; + if freq > MAX_FREQ { + self.rescale()?; + } + self.update_model() + } + + fn update_bin(&mut self) -> Result<()> { + let fs = self.found_state; + let freq = self.state(fs)?.freq; + self.state_mut(fs)?.freq = freq.wrapping_add(u8::from(freq < 128)); + self.prev_success = 1; + self.run_length += 1; + self.next_context() + } + + fn next_context(&mut self) -> Result<()> { + let successor = self.state(self.found_state)?.successor; + if let Successor::Context(context) = successor { + if self.order_fall == 0 { + self.max_context = context; + self.min_context = context; + return Ok(()); + } + } + self.update_model() + } + + fn update_model(&mut self) -> Result<()> { + let fs = self.state(self.found_state)?; + let found_symbol = fs.symbol; + if fs.freq < (MAX_FREQ / 4) as u8 && self.contexts[self.min_context].suffix.is_some() { + let suffix = self.contexts[self.min_context].suffix.unwrap(); + if self.contexts[suffix].states.len() == 1 { + let freq = self.contexts[suffix].states[0].freq; + if freq < 32 { + self.contexts[suffix].states[0].freq += 1; + } + } else if let Some(mut index) = self.contexts[suffix] + .states + .iter() + .position(|state| state.symbol == found_symbol) + { + if index > 0 + && self.contexts[suffix].states[index].freq + >= self.contexts[suffix].states[index - 1].freq + { + self.contexts[suffix].states.swap(index, index - 1); + index -= 1; + } + if self.contexts[suffix].states[index].freq < (MAX_FREQ - 9) as u8 { + self.contexts[suffix].states[index].freq += 2; + self.contexts[suffix].summ_freq = + self.contexts[suffix].summ_freq.wrapping_add(2); + } + } + } + + if self.order_fall == 0 { + let Some(context) = self.create_successors()? else { + self.init_model(self.max_order)?; + return Ok(()); + }; + self.max_context = context; + self.min_context = context; + self.state_mut(self.found_state)?.successor = Successor::Context(context); + return Ok(()); + } + + // Match Ppmd7_UpdateModel exactly: advance text first, then check + // `text >= UnitsStart`. The previous "check then push" version + // restarted one symbol later than the reference, advancing the range + // coder by one extra symbol before resetting — which left the + // post-restart state out of sync. + self.text.try_push(found_symbol)?; + let max_successor = Successor::Raw(self.text.len()); + if !self.suballoc.text_has_room(self.text.len()) { + self.init_model(self.max_order)?; + return Ok(()); + } + let (min_context, had_successor) = match fs.successor { + Successor::None => { + self.state_mut(self.found_state)?.successor = max_successor; + (self.min_context, false) + } + Successor::Context(context) => (context, true), + Successor::Raw(_) => { + let Some(context) = self.create_successors()? else { + self.init_model(self.max_order)?; + return Ok(()); + }; + (context, true) + } + }; + if had_successor { + self.order_fall -= 1; + if self.order_fall == 0 && self.max_context != self.min_context { + self.text.pop(); + } + } + let min_successor = Successor::Context(min_context); + + let mc = self.min_context; + let mut c = self.max_context; + self.min_context = min_context; + self.max_context = min_context; + if c == mc { + return Ok(()); + } + + let ns = self.contexts[mc].states.len() as u32; + let s0 = self.contexts[mc] + .summ_freq + .checked_sub(ns as u16) + .map(u32::from) + .and_then(|value| value.checked_sub(fs.freq as u32 - 1)) + .ok_or(Error::InvalidData("RAR PPMd model frequency is invalid"))?; + while c != mc { + let ns1 = self.contexts[c].states.len() as u32; + let mut sum; + if ns1 != 1 { + sum = self.contexts[c].summ_freq as u32; + sum += u32::from(2 * ns1 < ns) + 2 * u32::from(4 * ns1 <= ns && sum <= 8 * ns1); + } else { + let old = self.contexts[c].states[0]; + let freq = if old.freq < (MAX_FREQ / 4 - 1) as u8 { + old.freq * 2 + } else { + (MAX_FREQ - 4) as u8 + }; + self.contexts[c].states[0].freq = freq; + sum = freq as u32 + self.init_esc + u32::from(ns > 3); + } + + // sum is at most u16::MAX + 3 here, s0 at most u16::MAX, + // and fs.freq at most u8::MAX. Even the largest product is + // below 34 million, so u32 arithmetic cannot overflow. + let mut cf = (sum + 6) * 2 * fs.freq as u32; + let sf = s0 + sum; + if sf == 0 { + return Err(Error::InvalidData("RAR PPMd model frequency is invalid")); + } + if cf < 6 * sf { + cf = 1 + u32::from(cf > sf) + u32::from(cf >= 4 * sf); + sum += 3; + } else { + cf = 4 + + u32::from(cf >= 9 * sf) + + u32::from(cf >= 12 * sf) + + u32::from(cf >= 15 * sf); + sum += cf; + } + let old_n = self.contexts[c].states.len(); + if !self.grow_state_array(c, old_n + 1)? { + self.init_model(self.max_order)?; + return Ok(()); + } + self.contexts[c].states.try_push(State { + symbol: found_symbol, + freq: cf as u8, + successor: if self.order_fall == 0 { + min_successor + } else { + max_successor + }, + })?; + self.contexts[c].summ_freq = u16::try_from(sum) + .map_err(|_| Error::InvalidData("RAR PPMd model frequency overflows"))?; + c = self.contexts[c].suffix.unwrap_or(mc); + } + Ok(()) + } + + fn create_successors(&mut self) -> Result> { + // Missing links retain the reference model's restart path. Workspace + // refusal is propagated separately and must never restart the model. + macro_rules! pressure { + ($value:expr) => { + match $value { + Some(value) => value, + None => return Ok(None), + } + }; + } + let up_branch = match pressure!(self.state(self.found_state).ok()).successor { + Successor::Raw(pos) => pos, + Successor::Context(context) if self.order_fall == 0 => return Ok(Some(context)), + _ => return Ok(None), + }; + let mut c = self.min_context; + let allowance = self.contexts.allowance(); + let mut ps = Buffer::new(&allowance); + if self.order_fall != 0 { + ps.try_push(self.found_state)?; + } + while let Some(suffix) = self.contexts[c].suffix { + c = suffix; + let found_symbol = pressure!(self.state(self.found_state).ok()).symbol; + let index = pressure!(self.contexts[c] + .states + .iter() + .position(|state| state.symbol == found_symbol)); + let successor = self.contexts[c].states[index].successor; + if successor != Successor::Raw(up_branch) { + if let Successor::Context(context) = successor { + c = context; + if ps.is_empty() { + return Ok(Some(c)); + } + break; + } + return Ok(None); + } + ps.try_push(StateRef { context: c, index })?; + } + if ps.is_empty() { + return Ok(Some(c)); + } + let new_sym = *pressure!(self.text.get(up_branch)); + let up_successor = Successor::Raw(up_branch + 1); + let new_freq = if self.contexts[c].states.len() == 1 { + self.contexts[c].states[0].freq + } else { + let state = pressure!(self.contexts[c] + .states + .iter() + .find(|state| state.symbol == new_sym)); + let cf = state.freq as u32 - 1; + let s0 = self.contexts[c].summ_freq as u32 - self.contexts[c].states.len() as u32 - cf; + (1 + if 2 * cf <= s0 { + u32::from(5 * cf > s0) + } else { + (2 * cf + 3 * s0 - 1) / (2 * s0) + }) as u8 + }; + while let Some(state_ref) = ps.pop() { + let context = pressure!(self.push_context(Context { + states: Buffer::filled( + 1, + State { + symbol: new_sym, + freq: new_freq, + successor: up_successor + }, + &allowance + )?, + summ_freq: 0, + suffix: Some(c), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + })?); + pressure!(self.state_mut(state_ref).ok()).successor = Successor::Context(context); + c = context; + } + Ok(Some(c)) + } + + fn push_context(&mut self, mut context: Context) -> Result> { + if self.contexts.len() >= self.max_contexts { + return Ok(None); + } + // 1 unit for the context header (Hi side); binary contexts (1 state) + // carry their state inline, multi-state contexts also need a state + // array (Lo side). + let text_len = self.text.len(); + let Some(header_offset) = self.suballoc.try_alloc(1, AllocSide::Hi, text_len)? else { + return Ok(None); + }; + let array_units = Self::state_array_units(context.states.len()); + let array_offset = if array_units > 0 { + match self + .suballoc + .try_alloc(array_units, AllocSide::Lo, text_len)? + { + Some(off) => off, + None => { + self.suballoc.try_free(header_offset, 1)?; + return Ok(None); + } + } + } else { + NULL_OFFSET + }; + context.header_offset = header_offset; + context.array_offset = array_offset; + let index = self.contexts.len(); + self.contexts.try_push(context)?; + Ok(Some(index)) + } + + // Grow a context's state array from its current size → `new_n` states. + // Models ExpandUnits: if the same bucket still fits, no realloc happens; + // otherwise allocate the new size first, then release the old slot. The + // context's array_offset is updated to point at the new block when + // moved. + fn grow_state_array(&mut self, ctx_idx: usize, new_n: usize) -> Result { + let old_n = self.contexts[ctx_idx].states.len(); + let old_units = Self::state_array_units(old_n); + let new_units = Self::state_array_units(new_n); + // Called only for old_n + 1 during UpdateModel. The new array has + // positive size; unchanged bucket sizes are handled below. + if old_units > 0 { + let old_b = Suballocator::::bucket_for(old_units); + let new_b = Suballocator::::bucket_for(new_units); + if old_b == new_b { + return Ok(true); + } + } + let text_len = self.text.len(); + let new_offset = match self + .suballoc + .try_alloc(new_units, AllocSide::Lo, text_len)? + { + Some(off) => off, + None => return Ok(false), + }; + if old_units > 0 { + let old_offset = self.contexts[ctx_idx].array_offset; + self.suballoc.try_free(old_offset, old_units)?; + } + self.contexts[ctx_idx].array_offset = new_offset; + Ok(true) + } + + // Rescale shrinks a state array. Mirrors Ppmd7_Rescale's branch at + // Ppmd7.c:901-919: if the target bucket has a free block, swap to it + // (pop i1, push old to i0); otherwise SplitBlock the existing block in + // place — the first i1 units stay at the current address as the new + // array, the (i0 - i1)-unit residue is bucketed onto smaller free lists. + // No bump is consumed on the in-place path, which matters because over + // many rescales the reference never grows lo_bump from shrinks. + // + // Collapse-to-unary (new_n == 1, new_units == 0) is handled by Rescale's + // earlier branch (Ppmd7.c:881-898), which frees `stats` at bucket + // U2I(n0) and copies the surviving state into the inline OneState slot. + fn shrink_state_array(&mut self, ctx_idx: usize, old_n: usize, new_n: usize) -> Result<()> { + let old_units = Self::state_array_units(old_n); + let new_units = Self::state_array_units(new_n); + // Rescale starts with a multi-state context, so old_units is positive. + if new_units >= old_units { + return Ok(()); + } + if new_units == 0 { + // Collapse to unary: free the whole array, clear the pointer. + let old_offset = self.contexts[ctx_idx].array_offset; + self.suballoc.try_free(old_offset, old_units)?; + self.contexts[ctx_idx].array_offset = NULL_OFFSET; + return Ok(()); + } + // Contexts contain at most 256 states, so both nonzero array sizes + // are in the allocator's 1..=128-unit range. + let i0 = Suballocator::::bucket_for(old_units).expect("old array fits a bucket"); + let i1 = Suballocator::::bucket_for(new_units).expect("new array fits a bucket"); + if i0 == i1 { + return Ok(()); + } + let old_offset = self.contexts[ctx_idx].array_offset; + if let Some(swap_offset) = self.suballoc.free_lists[i1].pop() { + // Swap path: take a same-sized block from the target bucket, + // return the oversized block to its bucket. Data lives in + // self.contexts[ctx_idx].states (Vec), so no MEM_12_CPY needed. + self.suballoc.try_free(old_offset, old_units)?; + self.contexts[ctx_idx].array_offset = swap_offset; + } else { + // SplitBlock in place: keep the first I2U(i1) units at the same + // address, bucket the residue. Matches Ppmd7_SplitBlock. + let i0_units = Suballocator::::bucket_units(i0) as u32; + let i1_units = Suballocator::::bucket_units(i1) as u32; + self.suballoc + .try_split_in_place(old_offset, i0_units, i1_units)?; + // array_offset is unchanged. + } + Ok(()) + } + + fn rescale(&mut self) -> Result<()> { + let ctx = self.min_context; + let original_state_count = self.contexts[ctx].states.len(); + let mut states = Buffer::copied(&self.contexts[ctx].states, &self.contexts.allowance())?; + let found = self.found_state.index; + if found != 0 { + let state = states.remove(found); + states.insert(0, state)?; + self.found_state.index = 0; + } + let mut sum_freq = states[0].freq as u32; + let mut esc_freq = self.contexts[ctx].summ_freq as u32 - sum_freq; + let adder = u32::from(self.order_fall != 0); + sum_freq = (sum_freq + 4 + adder) >> 1; + states[0].freq = sum_freq as u8; + for index in 1..states.len() { + let freq = states[index].freq as u32; + esc_freq -= freq; + let freq = (freq + adder) >> 1; + sum_freq += freq; + states[index].freq = freq as u8; + let mut j = index; + while j > 0 && states[j].freq > states[j - 1].freq { + states.swap(j, j - 1); + j -= 1; + } + } + while states.last().is_some_and(|state| state.freq == 0) { + states.pop(); + esc_freq += 1; + } + if states.len() == 1 { + let mut freq = states[0].freq as u32; + while esc_freq > 1 { + esc_freq >>= 1; + freq = (freq + 1) >> 1; + } + states[0].freq = freq as u8; + self.shrink_state_array(ctx, original_state_count, 1)?; + self.contexts[ctx].states = states; + self.found_state.index = 0; + return Ok(()); + } + self.contexts[ctx].summ_freq = (sum_freq + esc_freq - (esc_freq >> 1)) as u16; + self.shrink_state_array(ctx, original_state_count, states.len())?; + self.contexts[ctx].states = states; + self.found_state.index = 0; + Ok(()) + } + + fn state(&self, state: StateRef) -> Result { + self.contexts + .get(state.context) + .and_then(|context| context.states.get(state.index)) + .copied() + .ok_or(Error::InvalidData("RAR PPMd state reference is invalid")) + } + + fn state_mut(&mut self, state: StateRef) -> Result<&mut State> { + self.contexts + .get_mut(state.context) + .and_then(|context| context.states.get_mut(state.index)) + .ok_or(Error::InvalidData("RAR PPMd state reference is invalid")) + } +} + +#[cfg(any(test, feature = "write"))] +impl PpmdEncoder { + pub fn new(max_order: usize, esc_char: u8, dictionary_mb: usize) -> Result { + if !(2..=64).contains(&max_order) { + return Err(Error::InvalidData("RAR PPMd order is invalid")); + } + if dictionary_mb == 0 { + return Err(Error::InvalidData("RAR PPMd dictionary size is invalid")); + } + let mut model = PpmdDecoder::new(); + model.state.max_contexts = model_context_limit(dictionary_mb); + model + .state + .suballoc + .reset(dictionary_mb.saturating_mul(1024 * 1024)); + model.state.init_model(max_order)?; + model.state.allocated = true; + Ok(Self { + model, + range: RangeEncoder::new(), + esc_char, + }) + } + + /// Carries a model from one block into the next. + /// + /// A block that clears the reset bit in its header leaves the reader's + /// model alone and only re-reads the range coder, so a solid chain can keep + /// one model across every member in it. Each block still gets a fresh range + /// coder, which is what lets a member's packed bytes start on a byte + /// boundary of their own. + #[cfg(feature = "write")] + pub fn continuing(model: PpmdDecoder, esc_char: u8) -> Self { + Self { + model, + range: RangeEncoder::new(), + esc_char, + } + } + + /// Ends the block and hands the model back for the next one to continue. + pub fn finish_keeping_model(mut self) -> Result<(Vec, PpmdDecoder)> { + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(2, &mut self.range)?; + Ok((self.range.finish(), self.model)) + } + + /// Ends this PPMd block while keeping the member open for another block. + #[cfg(all(test, feature = "write"))] + pub(crate) fn finish_block_keeping_model(mut self) -> Result<(Vec, PpmdDecoder)> { + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(0, &mut self.range)?; + Ok((self.range.finish(), self.model)) + } + + #[cfg(all(test, feature = "write"))] + pub(crate) fn finish_with_command(self, command: u8) -> Result> { + self.finish_with_command_prefix(command, &[]) + } + + #[cfg(all(test, feature = "write"))] + pub(crate) fn finish_with_command_prefix( + mut self, + command: u8, + parameters: &[u8], + ) -> Result> { + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(command, &mut self.range)?; + for ¶meter in parameters { + self.model.state.encode_symbol(parameter, &mut self.range)?; + } + Ok(self.range.finish()) + } + + pub fn encode_literal(&mut self, symbol: u8) -> Result<()> { + self.model.state.encode_symbol(symbol, &mut self.range)?; + if symbol == self.esc_char { + self.model.state.encode_symbol(1, &mut self.range)?; + } + Ok(()) + } + + pub fn encode_repeat_offset_one(&mut self, length: usize) -> Result<()> { + if !(4..=259).contains(&length) { + return Err(Error::InvalidData( + "RAR PPMd offset-one repeat length is invalid", + )); + } + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(5, &mut self.range)?; + self.model + .state + .encode_symbol((length - 4) as u8, &mut self.range)?; + Ok(()) + } + + pub fn encode_match(&mut self, offset: usize, length: usize) -> Result<()> { + if !(2..=0x1000001).contains(&offset) || !(32..=287).contains(&length) { + return Err(Error::InvalidData("RAR PPMd match is invalid")); + } + let encoded_offset = offset - 2; + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(4, &mut self.range)?; + self.model + .state + .encode_symbol(((encoded_offset >> 16) & 0xff) as u8, &mut self.range)?; + self.model + .state + .encode_symbol(((encoded_offset >> 8) & 0xff) as u8, &mut self.range)?; + self.model + .state + .encode_symbol((encoded_offset & 0xff) as u8, &mut self.range)?; + self.model + .state + .encode_symbol((length - 32) as u8, &mut self.range)?; + Ok(()) + } + + #[cfg(feature = "write")] + pub fn encode_vm_filter_record(&mut self, record: &[u8]) -> Result<()> { + self.model + .state + .encode_symbol(self.esc_char, &mut self.range)?; + self.model.state.encode_symbol(3, &mut self.range)?; + for &byte in record { + self.model.state.encode_symbol(byte, &mut self.range)?; + } + Ok(()) + } + + /// Bits spent so far, to fractional precision. log2 of the range register + /// falls as symbols narrow the interval and rises by eight for every byte + /// normalisation flushes, so the difference between two readings is the + /// cost of whatever was coded between them. The RAR 2.9 tokeniser reads + /// this to price escape tokens against the literals they would replace. + #[cfg(feature = "write")] + pub(crate) fn spent_bits(&self) -> f64 { + 8.0 * self.range.out.len() as f64 - f64::from(self.range.range.max(1)).log2() + } +} + +#[derive(Debug, Clone, Copy)] +enum SeeRef { + Dummy, + Table(usize, usize), +} + +impl RangeDecoder { + fn new() -> Self { + Self { + range: 0xffff_ffff, + code: 0, + low: 0, + } + } + + fn init(&mut self, input: &mut impl PpmdByteReader) -> Result<()> { + self.code = 0; + self.range = 0xffff_ffff; + self.low = 0; + for _ in 0..4 { + self.code = (self.code << 8) | input.read_ppmd_byte()? as u32; + } + if self.code == 0xffff_ffff { + return Err(Error::InvalidData("RAR PPMd range code is invalid")); + } + Ok(()) + } + + fn get_threshold(&mut self, total: u32) -> Result { + if total == 0 { + return Err(Error::InvalidData("RAR PPMd frequency sum is zero")); + } + self.range /= total; + Ok(self.code.wrapping_sub(self.low) / self.range) + } + + fn decode(&mut self, start: u32, size: u32) { + let start = start.wrapping_mul(self.range); + self.low = self.low.wrapping_add(start); + self.range = self.range.wrapping_mul(size); + } + + fn decode_bit0(&mut self, size0: u32) { + self.range = size0; + } + + fn decode_bit1(&mut self, size0: u32) { + self.low = self.low.wrapping_add(size0); + self.range = (self.range & !(BIN_SCALE - 1)).wrapping_sub(size0); + } + + fn normalize(&mut self, input: &mut impl PpmdByteReader) -> Result<()> { + while normalize_range(self.low, &mut self.range) { + self.code = (self.code << 8) | input.read_ppmd_byte()? as u32; + self.range <<= 8; + self.low <<= 8; + } + Ok(()) + } +} + +#[derive(Debug, Clone)] +#[cfg(any(test, feature = "write"))] +struct RangeEncoder { + low: u32, + range: u32, + out: Vec, +} + +#[cfg(any(test, feature = "write"))] +impl RangeEncoder { + fn new() -> Self { + Self { + low: 0, + range: 0xffff_ffff, + out: Vec::new(), + } + } + + fn encode(&mut self, start: u32, size: u32, total: u32) { + self.range /= total; + self.low = self.low.wrapping_add(start.wrapping_mul(self.range)); + self.range = self.range.wrapping_mul(size); + } + + fn encode_bit0(&mut self, size0: u32) { + self.range = size0; + } + + fn encode_bit1(&mut self, size0: u32) { + self.low = self.low.wrapping_add(size0); + self.range = (self.range & !(BIN_SCALE - 1)).wrapping_sub(size0); + } + + fn normalize(&mut self) { + while normalize_range(self.low, &mut self.range) { + self.out.push((self.low >> 24) as u8); + self.range <<= 8; + self.low <<= 8; + } + } + + fn finish(mut self) -> Vec { + for _ in 0..4 { + self.out.push((self.low >> 24) as u8); + self.low <<= 8; + } + self.out + } +} + +fn normalize_range(low: u32, range: &mut u32) -> bool { + if (low ^ low.wrapping_add(*range)) < TOP { + return true; + } + if *range >= BOT { + return false; + } + *range = low.wrapping_neg() & (BOT - 1); + true +} + +fn update_prob_1(prob: u32) -> u32 { + prob - ((prob + (1 << 5)) >> INT_BITS) +} + +fn hi_bits_flag(symbol: u8, bits: u32) -> u32 { + ((symbol as u32 + 0xc0) >> (8 - bits)) & (1 << bits) +} + +#[cfg(test)] +impl Default for Suballocator { + fn default() -> Self { + Self::with_allowance(&Allowance::default()) + } +} +#[cfg(test)] +impl Suballocator { + fn alloc(&mut self, units: usize, side: AllocSide, text_len_bytes: usize) -> Option { + self.try_alloc(units, side, text_len_bytes) + .expect("unlimited arena allocation") + } + fn free(&mut self, offset: u32, units: usize) { + self.try_free(offset, units).unwrap(); + } + fn split_in_place(&mut self, base: u32, old: u32, new: u32) { + self.try_split_in_place(base, old, new).unwrap(); + } + fn glue(&mut self) { + self.glue_inner().expect("unlimited glue maintenance"); + } +} +/// Keep the glue walk's original order while admitting an exact allocation +/// for its offset lookup. The last original entry wins for duplicate offsets, +/// matching the previous map's insert semantics without opaque hash-table RAM. +struct GlueIndex { + entries: Buffer, B>, +} +impl GlueIndex { + fn new( + list: &[(u32, u32)], + allowance: &B, + control: &crate::read_control::ReadControl, + ) -> Result { + control.check_codec()?; + if list.is_empty() { + return Ok(Self { + entries: Buffer::new(allowance), + }); + } + let count = list + .len() + .checked_mul(2) + .and_then(usize::checked_next_power_of_two) + .ok_or(Error::InvalidData("PPMd glue lookup size overflows"))?; + let mut out = Self { + entries: Buffer::filled(count, None, allowance)?, + }; + let mut poller = control.poller(); + for &(offset, units) in list { + poller.check_codec(0)?; + out.insert(offset, units); + } + Ok(out) + } + fn hash(mut value: u32) -> usize { + value ^= value >> 16; + value = value.wrapping_mul(0x85eb_ca6b); + value ^= value >> 13; + value = value.wrapping_mul(0xc2b2_ae35); + (value ^ (value >> 16)) as usize + } + fn slot(&self, offset: u32) -> Option { + if self.entries.is_empty() { + return None; + } + let mask = self.entries.len() - 1; + let mut index = Self::hash(offset) & mask; + loop { + match self.entries[index] { + Some((key, _)) if key != offset => index = (index + 1) & mask, + _ => return Some(index), + } + } + } + fn get(&self, offset: &u32) -> Option<&u32> { + self.entries[self.slot(*offset)?] + .as_ref() + .map(|(_, units)| units) + } + fn insert(&mut self, offset: u32, units: u32) { + let index = self + .slot(offset) + .expect("glue inserts into a nonempty lookup"); + self.entries[index] = Some((offset, units)); + } +} + +// Upper bound on the number of live context records. The C reference +// (Ppmd7.c) has NO independent context cap — model restart is driven solely +// by suballocator exhaustion (`Ppmd7_AllocUnits`/`AllocUnitsRare` returning +// NULL). A context header is one 12-byte unit, and headers + state arrays +// share the pool, so the live context count can never exceed `pool_units` +// (= Size / UNIT_SIZE). Sizing the cap to that makes the suballocator the +// binding constraint, exactly as in the reference, while still bounding Vec +// growth defensively. A smaller cap (the old Size/16) forced a premature +// RestartModel that desynchronised the decoder from the reference. +fn model_context_limit(dictionary_mb: usize) -> usize { + dictionary_mb + .saturating_mul(1024 * 1024) + .checked_div(ALLOC_UNIT_BYTES) + .unwrap_or(usize::MAX) + .max(MIN_MODEL_CONTEXTS) +} + +#[cfg(test)] +mod tests; diff --git a/arca-rar/vendor/rars/src/codec/ppmd/tests.rs b/arca-rar/vendor/rars/src/codec/ppmd/tests.rs new file mode 100644 index 00000000..e527cea2 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/ppmd/tests.rs @@ -0,0 +1,1545 @@ +fn refuse_each_ppmd_allocation( + mut run: impl FnMut(&crate::codec::workspace::RefusingBudget) -> Result<()>, +) { + use crate::codec::workspace::RefusingBudget; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts > 0); + assert_eq!(baseline.used(), 0); + for index in 0..attempts { + let budget = RefusingBudget::new(index); + assert!( + matches!(run(&budget), Err(Error::Cancelled)), + "allocation {index}" + ); + assert_eq!(budget.used(), 0); + } +} + +#[test] +fn reader_ppmd_workspace_refusals_release_contexts_states_text_and_checkpoints() { + let data = b"abracadabra and evolving contexts abracadabra"; + let mut encoder = PpmdEncoder::new(4, 2, 1).unwrap(); + for &byte in data { + encoder.encode_literal(byte).unwrap(); + } + let (packed, _) = encoder.finish_keeping_model().unwrap(); + refuse_each_ppmd_allocation(|budget| { + let mut model = PpmdState::with_allowance(budget); + model.max_contexts = model_context_limit(1); + model.suballoc.reset(1024 * 1024); + model.init_model(4)?; + let mut input = Bytes { input: &packed }; + model.range.init(&mut input)?; + for &byte in data { + assert_eq!(model.decode_symbol(&mut input)?, Some(byte)); + } + let checkpoint = model.try_clone()?; + assert_eq!(checkpoint.contexts.len(), model.contexts.len()); + assert_eq!(checkpoint.text, model.text); + assert_eq!( + checkpoint.contexts[0].states[0].freq, + model.contexts[0].states[0].freq + ); + Ok(()) + }); +} + +#[test] +fn reader_ppmd_workspace_refusals_release_free_lists_and_glue_lookup() { + refuse_each_ppmd_allocation(|budget| { + let mut allocator = super::Suballocator::with_allowance(budget); + allocator.reset(32 * ALLOC_UNIT_BYTES); + for offset in [10, 11, 20, 21] { + allocator.try_free(offset, 1)?; + } + allocator.glue_inner()?; + assert_eq!(&*allocator.free_lists[1], &[10, 20]); + let checkpoint = allocator.try_clone()?; + assert_eq!(checkpoint.free_lists[1], allocator.free_lists[1]); + Ok(()) + }); +} + +#[test] +fn reader_ppmd_workspace_refusal_is_not_an_arena_restart() { + let ledger = Allowance::limited(1); + let mut model = PpmdState::with_allowance(&ledger); + let mut input = Bytes { input: &[0; 5] }; + let mut escape = 2; + assert!(matches!( + model.decode_init(0x20 | 3, &mut input, &mut escape), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert!(!model.allocated); + assert!(model.contexts.is_empty()); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn reader_ppmd_glue_index_probes_collisions_wraps_and_accepts_zero_offsets() { + let keys: Vec<_> = (0..1000u32) + .filter(|&key| GlueIndex::::hash(key) & 7 == 7) + .take(3) + .collect(); + let list: Vec<_> = keys + .iter() + .enumerate() + .map(|(index, &key)| (key, index as u32 + 1)) + .collect(); + let ledger = Allowance::limited(1024); + let control = crate::read_control::ReadControl::default(); + let mut index = GlueIndex::new(&list, &ledger, &control).unwrap(); + assert_eq!(index.entries.len(), 8); + assert!(index.entries[7].is_some() && index.entries[0].is_some() && index.entries[1].is_some()); + for &(key, units) in &list { + assert_eq!(index.get(&key), Some(&units)); + } + index.insert(keys[1], 0); + assert_eq!(index.get(&keys[1]), Some(&0)); + assert_eq!(index.get(&u32::MAX), None); + drop(index); + let zero = GlueIndex::new(&[(0, 1), (u32::MAX, 2)], &ledger, &control).unwrap(); + assert_eq!(zero.get(&0), Some(&1)); + assert_eq!(zero.get(&u32::MAX), Some(&2)); + drop(zero); + let empty = GlueIndex::new(&[], &ledger, &control).unwrap(); + assert_eq!(empty.get(&0), None); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn reader_ppmd_glue_index_matches_map_lookup_and_duplicate_overwrites() { + let list = [(10, 1), (4, 3), (10, 8), (20, 2), (4, 5)]; + let ledger = Allowance::limited(1024); + let mut index = + GlueIndex::new(&list, &ledger, &crate::read_control::ReadControl::default()).unwrap(); + let mut reference: std::collections::HashMap<_, _> = list.into_iter().collect(); + for key in [0, 4, 10, 20, 21, u32::MAX] { + assert_eq!(index.get(&key), reference.get(&key)); + } + for (key, value) in [(10, 0), (4, 7), (20, 0)] { + index.insert(key, value); + reference.insert(key, value); + assert_eq!(index.get(&key), reference.get(&key)); + } + assert_eq!( + ledger.used(), + index.entries.capacity() as u64 * std::mem::size_of::>() as u64 + ); + drop(index); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn cancellation_interrupts_suballocator_maintenance() { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(1); + let mut allocator = Suballocator { + read_control: control, + ..Suballocator::default() + }; + allocator.free_lists[0] = (0..5000).collect::>().into(); + assert_eq!(allocator.glue_inner(), Err(Error::Cancelled)); + assert!(token.is_cancelled()); +} +use super::*; +type PpmdDecoder = PpmdState; +type Suballocator = super::Suballocator; + +#[test] +fn alloc_tables_match_spec_pattern() { + let t = alloc_tables(); + // Spec §4.2: bucket sizes are 1,2,3,4 then groups of 4 at strides 1,2,3,4. + // First 12 buckets cover 1..4, then 6,8,10,12, then 15,18,21,24. + assert_eq!(t.index_to_units[0], 1); + assert_eq!(t.index_to_units[1], 2); + assert_eq!(t.index_to_units[2], 3); + assert_eq!(t.index_to_units[3], 4); + assert_eq!(t.index_to_units[4], 6); + assert_eq!(t.index_to_units[5], 8); + assert_eq!(t.index_to_units[6], 10); + assert_eq!(t.index_to_units[7], 12); + assert_eq!(t.index_to_units[8], 15); + assert_eq!(t.index_to_units[9], 18); + assert_eq!(t.index_to_units[10], 21); + assert_eq!(t.index_to_units[11], 24); + // From bucket 12 onward, stride is 4: 28, 32, 36, 40 ... up to 128. + assert_eq!(t.index_to_units[12], 28); + assert_eq!(t.index_to_units[N_BUCKETS - 1], 128); + + // 1-unit requests resolve to bucket 0; 2 → 1; 5,6 → 4 (the 6-unit bucket). + assert_eq!(t.units_to_index[0], 0); + assert_eq!(t.units_to_index[1], 1); + assert_eq!(t.units_to_index[4], 4); // 5 units + assert_eq!(t.units_to_index[5], 4); // 6 units (same bucket as 5) +} + +#[test] +fn suballoc_alloc_until_exhaustion() { + // Pool needs the text reservation (1/8) plus units area. 16 units + // total gives 2-unit text region + 14 units of headroom for bumping. + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + // 14 units between lo_bump and hi_bump → can hand out 7 × 2-unit blocks. + for _ in 0..7 { + assert!(s.alloc(2, AllocSide::Lo, 0).is_some()); + } + assert!(s.alloc(2, AllocSide::Lo, 0).is_none()); // pool full +} + +#[test] +fn suballoc_reuses_freed_bucket() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + let offsets: Vec = (0..7) + .map(|_| s.alloc(2, AllocSide::Lo, 0).expect("alloc")) + .collect(); + assert!(s.alloc(2, AllocSide::Lo, 0).is_none()); // full + s.free(offsets[0], 2); // freed → bucket 1 has 1 slot + assert!(s.alloc(2, AllocSide::Lo, 0).is_some()); // reuses freed slot + assert!(s.alloc(2, AllocSide::Lo, 0).is_none()); // truly full again +} + +#[test] +fn suballoc_uninitialised_pool_acts_unbounded() { + let mut s = Suballocator::default(); + // pool_bytes=0; the suballoc shouldn't reject any allocation since the + // model hasn't been told its budget yet. + for _ in 0..1000 { + assert!(s.alloc(2, AllocSide::Lo, 0).is_some()); + } + assert!(s.text_has_room(usize::MAX / 2)); +} + +#[test] +fn suballoc_rejects_invalid_sizes_and_ignores_null_free() { + let mut s = Suballocator::default(); + assert_eq!(s.alloc(0, AllocSide::Lo, 0), None); + assert_eq!(s.alloc(MAX_BUCKET_UNITS + 1, AllocSide::Lo, 0), None); + s.free(NULL_OFFSET, 1); + s.free(1, 0); + s.free(1, MAX_BUCKET_UNITS + 1); + assert!(s.free_lists.iter().all(|list| list.is_empty())); +} + +#[test] +fn hi_side_reuses_a_header_only_after_bump_space_is_exhausted() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + let old = s.alloc(1, AllocSide::Hi, 0).unwrap(); + s.free(old, 1); + assert_ne!(s.alloc(1, AllocSide::Hi, 0), Some(old)); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Hi, 0).unwrap(); + } + assert_eq!(s.alloc(1, AllocSide::Hi, 0), Some(old)); +} + +#[test] +fn hi_side_exhaustion_without_a_free_header_uses_rare_allocation() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Hi, 0).unwrap(); + } + let before = s.units_start; + assert_eq!(s.alloc(1, AllocSide::Hi, 0), Some(before - 1)); +} + +#[test] +fn rare_allocation_splits_larger_free_block() { + let mut s = Suballocator::default(); + s.reset(32 * ALLOC_UNIT_BYTES); + // Exhaust the ordinary unit interval. Keep one six-unit block free + // and suppress glue so the rare path must split that exact block. + let large = s.alloc(6, AllocSide::Lo, 0).unwrap(); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Lo, 0).unwrap(); + } + s.free(large, 6); + s.glue_count = 1; + assert_eq!(s.alloc(1, AllocSide::Lo, 0), Some(large)); + // A six-unit block minus one leaves five, represented as 4 + 1. + assert!(s.free_lists[3].contains(&(large + 1))); + assert!(s.free_lists[0].contains(&(large + 5))); +} + +#[test] +fn rare_allocation_borrows_text_space() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Lo, 0).unwrap(); + } + // With no free block, the allocator takes one unit from the text + // reservation while leaving room for the text pointer. + let before = s.units_start; + assert_eq!(s.alloc(1, AllocSide::Lo, 0), Some(before - 1)); + assert_eq!( + s.text_capacity_bytes, + (before - 1) as usize * ALLOC_UNIT_BYTES + ); +} + +#[test] +fn rare_allocation_stops_when_text_reservation_is_full() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Lo, 0).unwrap(); + } + let text_end = s.text_capacity_bytes; + assert_eq!(s.alloc(1, AllocSide::Lo, text_end), None); +} + +#[test] +fn cancelled_glue_aborts_rare_allocation() { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(1); + let mut s = Suballocator { + read_control: control, + ..Suballocator::default() + }; + s.reset(16 * ALLOC_UNIT_BYTES); + while s.hi_bump > s.lo_bump { + s.alloc(1, AllocSide::Lo, 0).unwrap(); + } + s.free_lists[0] = (0..5000).collect::>().into(); + assert_eq!(s.try_alloc(2, AllocSide::Lo, 0), Err(Error::Cancelled)); + assert!(token.is_cancelled()); +} + +// Spec §4.3: free blocks that are address-adjacent should merge into a +// larger run during glue, and that merged run should be visible in the +// bucket whose size matches. +#[test] +fn glue_merges_adjacent_free_blocks() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + // Allocate 4 consecutive 1-unit blocks from the Lo side. They will + // be at offsets [units_start, units_start+1, units_start+2, + // units_start+3], i.e. adjacent. + let a = s.alloc(1, AllocSide::Lo, 0).unwrap(); + let b = s.alloc(1, AllocSide::Lo, 0).unwrap(); + let c = s.alloc(1, AllocSide::Lo, 0).unwrap(); + let d = s.alloc(1, AllocSide::Lo, 0).unwrap(); + assert_eq!(b, a + 1); + assert_eq!(c, a + 2); + assert_eq!(d, a + 3); + // Free them — bucket 0 now has 4 entries, bucket 3 (size 4) has none. + s.free(a, 1); + s.free(b, 1); + s.free(c, 1); + s.free(d, 1); + assert_eq!(s.free_lists[0].len(), 4); + assert!(s.free_lists[3].is_empty()); + s.glue(); + // After gluing, the 4-adjacent run becomes one 4-unit block in bucket 3. + assert!(s.free_lists[0].is_empty()); + assert_eq!(s.free_lists[3].len(), 1); + // And we can satisfy a 4-unit request from the merged block. + assert_eq!(s.alloc(4, AllocSide::Lo, 0), Some(a)); +} + +// Non-adjacent free blocks shouldn't merge even though their bucket sizes +// are compatible. +#[test] +fn glue_keeps_non_adjacent_blocks_separate() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + // Two 1-unit blocks separated by a still-live 2-unit allocation. + let a = s.alloc(1, AllocSide::Lo, 0).unwrap(); + let _live = s.alloc(2, AllocSide::Lo, 0).unwrap(); + let b = s.alloc(1, AllocSide::Lo, 0).unwrap(); + s.free(a, 1); + s.free(b, 1); + s.glue(); + // Still two separate 1-unit free entries; no merged 2-unit block. + assert_eq!(s.free_lists[0].len(), 2); +} + +// A merged run larger than the biggest bucket (128 units) should be +// chunked into multiple bucket-sized pieces during redistribution. +#[test] +fn glue_splits_oversized_run_into_buckets() { + // 256-unit pool (text=32, bumpable=224). Adjacent 64-unit + 64-unit + // blocks combine to 128, which is the biggest bucket — exactly one + // entry. Push it to 192 and we get a 128 + a 64 (closest bucket). + let mut s = Suballocator::default(); + s.reset(256 * ALLOC_UNIT_BYTES); + // Three adjacent 64-unit allocs → run of 192 units after freeing. + // 64 is bucket 18 in the spec table. + let bucket_64 = Suballocator::bucket_for(64).unwrap(); + assert_eq!(Suballocator::bucket_units(bucket_64), 64); + let a = s.alloc(64, AllocSide::Lo, 0).unwrap(); + let b = s.alloc(64, AllocSide::Lo, 0).unwrap(); + let c = s.alloc(64, AllocSide::Lo, 0).unwrap(); + assert_eq!(b, a + 64); + assert_eq!(c, a + 128); + s.free(a, 64); + s.free(b, 64); + s.free(c, 64); + s.glue(); + // Should emit one 128-unit block + one 64-unit block. + let bucket_128 = Suballocator::bucket_for(128).unwrap(); + assert_eq!(s.free_lists[bucket_128].len(), 1); + assert_eq!(s.free_lists[bucket_64].len(), 1); + // The 128 block starts at `a`, the 64 follows. + assert_eq!(s.free_lists[bucket_128][0], a); + assert_eq!(s.free_lists[bucket_64][0], a + 128); +} + +#[test] +fn glue_does_not_merge_a_run_to_65536_units() { + let mut s = Suballocator::default(); + // A 16-bit NU cannot hold 65536 units. Populate the same 512 adjacent + // 128-unit free blocks without allocating a huge backing pool. + let bucket = Suballocator::bucket_for(128).unwrap(); + s.free_lists[bucket] = (0..512).map(|i| i * 128).collect::>().into(); + s.glue(); + assert_eq!(s.free_lists[bucket].len(), 512); + assert_eq!(s.free_lists[bucket].iter().copied().min(), Some(0)); + assert_eq!(s.free_lists[bucket].iter().copied().max(), Some(511 * 128)); +} + +#[test] +fn glue_emits_exact_128_unit_chunks_and_inexact_remainder() { + let mut s = Suballocator::default(); + s.emit_run(10, 256).unwrap(); + let full = Suballocator::bucket_for(128).unwrap(); + assert_eq!(s.free_lists[full], vec![10, 138]); + + // Five units have no dedicated bucket: split into four plus one. + s.emit_run(300, 5).unwrap(); + assert_eq!(s.free_lists[3], vec![300]); + assert_eq!(s.free_lists[0], vec![304]); +} + +#[test] +fn in_place_split_buckets_an_inexact_five_unit_residue() { + let mut s = Suballocator::default(); + s.split_in_place(100, 6, 1); + assert_eq!(s.free_lists[3], vec![101]); + assert_eq!(s.free_lists[0], vec![105]); +} + +// glue_count debounce: a single bump failure runs the glue pass exactly +// once, then subsequent failures decrement instead of re-gluing. +#[test] +fn glue_count_debounces_subsequent_failures() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + // Fill the pool to capacity (14 bumpable units in a 16-unit pool; + // text region is 2 units). All 14 calls succeed — glue_count stays 0. + // Pass a text_len that occupies the entire 2-unit text region so + // the fallback_bump path can't grab any more. + let text_len_full = 2 * ALLOC_UNIT_BYTES; + for _ in 0..14 { + assert!(s.alloc(1, AllocSide::Lo, text_len_full).is_some()); + } + assert_eq!(s.glue_count, 0); + // 15th call fails: triggers glue (no-op, no free blocks) then + // walks up larger buckets (none), then fallback_bump fails (text + // already fills text region), and on the fallback path we + // decrement glue_count once. Mirrors C's `p->GlueCount--` inside + // the bump-fallback branch of AllocUnitsRare. + assert!(s.alloc(1, AllocSide::Lo, text_len_full).is_none()); + assert_eq!(s.glue_count, GLUE_RESET - 1); + // Subsequent failure decrements again (no re-glue because count > 0). + assert!(s.alloc(1, AllocSide::Lo, text_len_full).is_none()); + assert_eq!(s.glue_count, GLUE_RESET - 2); +} + +// After exhaustion, freeing two adjacent blocks lets a larger request +// succeed via glue. +#[test] +fn glue_recovers_capacity_for_larger_request() { + let mut s = Suballocator::default(); + s.reset(16 * ALLOC_UNIT_BYTES); + // Fill the pool to capacity (14 × 1-unit) without triggering a + // failure, so glue_count remains 0. + let mut held = Vec::new(); + for _ in 0..14 { + held.push(s.alloc(1, AllocSide::Lo, 0).unwrap()); + } + // Free two adjacent 1-unit blocks at the bottom of the units region. + s.free(held[0], 1); + s.free(held[1], 1); + // alloc(2) needs bucket 1 (size 2). Empty, bump exhausted, but + // glue_count == 0 so glue fires, merging into one 2-unit block at + // held[0]. Retry pop succeeds. + assert_eq!(s.alloc(2, AllocSide::Lo, 0), Some(held[0])); +} + +#[test] +fn state_array_units_handles_boundaries() { + assert_eq!(PpmdDecoder::state_array_units(0), 0); + assert_eq!(PpmdDecoder::state_array_units(1), 0); // binary: inline + assert_eq!(PpmdDecoder::state_array_units(2), 1); + assert_eq!(PpmdDecoder::state_array_units(3), 2); + assert_eq!(PpmdDecoder::state_array_units(4), 2); + assert_eq!(PpmdDecoder::state_array_units(255), 128); + assert_eq!(PpmdDecoder::state_array_units(256), 128); +} + +struct Bytes<'a> { + input: &'a [u8], +} + +impl PpmdByteReader for Bytes<'_> { + fn read_ppmd_byte(&mut self) -> Result { + let Some((&byte, rest)) = self.input.split_first() else { + return Err(Error::NeedMoreInput); + }; + self.input = rest; + Ok(byte) + } +} + +#[test] +fn decode_init_rejects_truncated_range_header_without_panic() { + let mut decoder = PpmdDecoder::new(); + let mut input = Bytes { input: &[0, 0] }; + let mut esc = 0; + + assert_eq!( + decoder.decode_init(0x20 | 1, &mut input, &mut esc), + Err(Error::NeedMoreInput) + ); +} + +#[test] +fn decode_init_rejects_reuse_before_model_allocation() { + let mut decoder = PpmdDecoder::new(); + let mut input = Bytes { + input: &[0, 0, 0, 0], + }; + let mut esc = 0; + + assert_eq!( + decoder.decode_init(0, &mut input, &mut esc), + Err(Error::InvalidData("RAR PPMd block reuses missing model")) + ); +} + +#[test] +fn decode_init_accepts_max_wire_order_without_growing_unbounded_model() { + let mut decoder = PpmdDecoder::new(); + let mut input = Bytes { + input: &[0, 0, 0, 0, 0], + }; + let mut esc = 0; + + decoder + .decode_init(0x20 | 0x1f, &mut input, &mut esc) + .unwrap(); + + assert_eq!(decoder.max_order, 64); + assert_eq!(decoder.contexts.len(), 1); + assert_eq!(decoder.contexts[0].states.len(), 256); + assert_eq!(decoder.max_contexts, model_context_limit(1)); +} + +#[test] +fn decode_init_rejects_wire_order_one() { + let mut decoder = PpmdDecoder::new(); + let mut input = Bytes { + input: &[0, 0, 0, 0, 0], + }; + let mut esc = 0; + assert_eq!( + decoder.decode_init(0x20, &mut input, &mut esc), + Err(Error::InvalidData("RAR PPMd order is invalid")) + ); +} + +#[test] +fn decode_init_reads_explicit_escape_character() { + let mut decoder = PpmdDecoder::new(); + let mut input = Bytes { + input: &[0, b'!', 0, 0, 0, 0], + }; + let mut esc = 2; + decoder + .decode_init(0x20 | 0x40 | 3, &mut input, &mut esc) + .unwrap(); + assert_eq!(esc, b'!'); +} + +#[test] +fn decoder_reports_invalid_range_and_frequency_sum() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + let mut input = Bytes { input: &[] }; + decoder.range.range = 1; + assert_eq!( + decoder.decode_symbol(&mut input), + Err(Error::InvalidData("RAR PPMd range is invalid")) + ); + + decoder.range.range = 257; + decoder.contexts[0].summ_freq = 1; + decoder.range.code = 256 * 257; + assert_eq!( + decoder.decode_symbol(&mut input), + Err(Error::InvalidData("RAR PPMd frequency sum is invalid")) + ); +} + +#[test] +fn decoder_rejects_invalid_escape_range_and_symbol() { + fn escaping_model(code_delta: u32) -> PpmdDecoder { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + let state = |symbol| State { + symbol, + freq: 1, + successor: Successor::None, + }; + decoder + .contexts + .push(Context { + states: vec![state(b'a'), state(b'b'), state(b'c')].into(), + summ_freq: 4, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap(); + decoder + .contexts + .push(Context { + states: vec![state(b'a'), state(b'b')].into(), + summ_freq: 3, + suffix: Some(1), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap(); + decoder.min_context = 2; + decoder.range.range = 100_000; + // The first escape leaves a 33_333-unit range straddling TOP. + // That is above BOT, so normalization consumes no input. + decoder.range.low = TOP - 20_000 - 2 * (100_000 / 3); + decoder.range.code = decoder.range.low + code_delta; + decoder + } + + let mut decoder = escaping_model(2 * (100_000 / 3)); + decoder.see[0][7] = See { + summ: u16::MAX, + shift: 0, + count: 1, + }; + assert_eq!( + decoder.decode_symbol(&mut Bytes { input: &[] }), + Err(Error::InvalidData("RAR PPMd escape range is invalid")) + ); + + let mut decoder = escaping_model(110_000); + assert_eq!( + decoder.decode_symbol(&mut Bytes { input: &[] }), + Err(Error::InvalidData("RAR PPMd escape symbol is invalid")) + ); +} + +#[test] +fn root_escape_ends_ppmd_stream() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + let total = decoder.contexts[0].summ_freq as u32; + decoder.range.code = 256 * (decoder.range.range / total); + let mut input = Bytes { input: &[0; 16] }; + assert_eq!(decoder.decode_symbol(&mut input), Ok(None)); +} + +#[test] +fn range_decoder_rejects_reserved_initial_code() { + let mut range = RangeDecoder::new(); + let mut input = Bytes { input: &[0xff; 4] }; + assert_eq!( + range.init(&mut input), + Err(Error::InvalidData("RAR PPMd range code is invalid")) + ); +} + +#[test] +fn range_coders_normalize_across_the_bottom_boundary() { + let mut decoder = RangeDecoder::new(); + decoder.low = TOP - 50; + decoder.range = 100; + decoder.normalize(&mut Bytes { input: &[0; 8] }).unwrap(); + assert_ne!(decoder.range, 100); + + let mut encoder = RangeEncoder::new(); + encoder.low = TOP - 50; + encoder.range = 100; + encoder.normalize(); + assert!(!encoder.out.is_empty()); + + // Straddling TOP alone does not normalize while enough range remains. + let mut decoder = RangeDecoder::new(); + decoder.low = TOP - 20_000; + decoder.range = 40_000; + decoder.normalize(&mut Bytes { input: &[] }).unwrap(); + assert_eq!(decoder.range, 40_000); + + let mut encoder = RangeEncoder::new(); + encoder.low = TOP - 20_000; + encoder.range = 40_000; + encoder.normalize(); + assert!(encoder.out.is_empty()); +} + +#[test] +fn see_counter_ages_and_dummy_accumulates_without_aging() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder.see[0][0] = See { + summ: 7, + shift: PERIOD_BITS - 1, + count: 1, + }; + decoder.update_see(SeeRef::Table(0, 0)); + assert_eq!(decoder.see[0][0].summ, 14); + assert_eq!(decoder.see[0][0].shift, PERIOD_BITS); + assert_eq!(decoder.see[0][0].count, 3 << (PERIOD_BITS - 1)); + decoder.update_see(SeeRef::Table(0, 0)); + assert_eq!(decoder.see[0][0].summ, 14); + + let before = decoder.dummy_see; + decoder.update_see(SeeRef::Dummy); + assert_eq!(decoder.dummy_see.summ, before.summ); + assert_eq!(decoder.dummy_see.count, before.count); + decoder.add_see_summ(SeeRef::Dummy, 9); + assert_eq!(decoder.dummy_see.summ, before.summ + 9); +} + +#[test] +fn encoder_rejects_invalid_match_and_repeat_bounds() { + let mut encoder = PpmdEncoder::new(4, 2, 1).unwrap(); + for length in [3, 260] { + assert_eq!( + encoder.encode_repeat_offset_one(length), + Err(Error::InvalidData( + "RAR PPMd offset-one repeat length is invalid" + )) + ); + } + for (offset, length) in [(1, 32), (0x1000002, 32), (2, 31), (2, 288)] { + assert_eq!( + encoder.encode_match(offset, length), + Err(Error::InvalidData("RAR PPMd match is invalid")) + ); + } +} + +#[test] +fn encoder_rejects_corrupt_frequency_sum_and_missing_root_symbol() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder.contexts[0].states.truncate(2); + decoder.contexts[0].summ_freq = 2; + assert_eq!( + decoder.encode_symbol(2, &mut RangeEncoder::new()), + Err(Error::InvalidData("RAR PPMd frequency sum is invalid")) + ); + + decoder.init_model(4).unwrap(); + decoder.contexts[0].states.truncate(2); + decoder.contexts[0].summ_freq = 3; + assert_eq!( + decoder.encode_symbol(2, &mut RangeEncoder::new()), + Err(Error::InvalidData("RAR PPMd symbol is not encodable")) + ); +} + +#[test] +fn encoder_rejects_orders_outside_model_bounds() { + assert!(matches!( + PpmdEncoder::new(1, 2, 1), + Err(Error::InvalidData("RAR PPMd order is invalid")) + )); + assert!(matches!( + PpmdEncoder::new(65, 2, 1), + Err(Error::InvalidData("RAR PPMd order is invalid")) + )); +} + +#[test] +fn encoder_rejects_zero_dictionary_size() { + assert!(matches!( + PpmdEncoder::new(4, 2, 0), + Err(Error::InvalidData("RAR PPMd dictionary size is invalid")) + )); +} + +#[test] +fn range_decoder_rejects_zero_total_without_panic() { + let mut decoder = RangeDecoder::new(); + let mut input = Bytes { + input: &[0, 0, 0, 0], + }; + decoder.init(&mut input).unwrap(); + + assert_eq!( + decoder.get_threshold(0), + Err(Error::InvalidData("RAR PPMd frequency sum is zero")) + ); +} + +#[test] +fn context_allocation_respects_dictionary_limit() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 1; + decoder.init_model(4).unwrap(); + + assert_eq!( + decoder + .push_context(Context { + states: Buffer::new(&Allowance::default()), + summ_freq: 0, + suffix: None, + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap(), + None + ); +} + +#[test] +fn context_header_pressure_is_distinct_from_the_context_count_limit() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = model_context_limit(1); + decoder.suballoc.reset(1024 * 1024); + decoder.init_model(4).unwrap(); + + // Occupy the pool through the allocator's normal state-array and + // header operations, including its rare text-reservation fallback. + // The root's 128-unit array alone makes memory bind before the + // defensive one-header-per-unit context-count cap. + while decoder.suballoc.alloc(128, AllocSide::Lo, 0).is_some() {} + while decoder.suballoc.alloc(1, AllocSide::Hi, 0).is_some() {} + assert!(decoder.contexts.len() < decoder.max_contexts); + let root_header = decoder.contexts[0].header_offset; + let root_array = decoder.contexts[0].array_offset; + let new_context = || Context { + states: vec![State { + symbol: b'a', + freq: 1, + successor: Successor::None, + }] + .into(), + summ_freq: 0, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }; + assert_eq!(decoder.push_context(new_context()).unwrap(), None); + assert_eq!(decoder.contexts.len(), 1); + assert_eq!(decoder.contexts[0].header_offset, root_header); + assert_eq!(decoder.contexts[0].array_offset, root_array); + assert_eq!(decoder.contexts[0].states.len(), 256); + + decoder.init_model(4).unwrap(); + assert_eq!(decoder.push_context(new_context()).unwrap(), Some(1)); +} + +#[test] +fn context_allocation_releases_header_when_state_array_does_not_fit() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.suballoc.reset(16 * ALLOC_UNIT_BYTES); + let state = State { + symbol: 0, + freq: 1, + successor: Successor::None, + }; + let context = Context { + states: vec![state; 256].into(), + summ_freq: 257, + suffix: None, + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }; + assert_eq!(decoder.push_context(context).unwrap(), None); + assert_eq!(decoder.suballoc.free_lists[0].len(), 1); + assert!(decoder.contexts.is_empty()); +} + +#[test] +fn model_restarts_at_text_boundary_and_failed_successor_creation() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder.suballoc.reset(16 * ALLOC_UNIT_BYTES); + decoder + .text + .resize(decoder.suballoc.text_capacity_bytes - 1, 0) + .unwrap(); + decoder.update_model().unwrap(); + assert!(decoder.text.is_empty()); + assert_eq!(decoder.contexts.len(), 1); + + decoder.order_fall = 0; + decoder.update_model().unwrap(); + assert_eq!(decoder.order_fall, 4); + + decoder.contexts[0].states[0].successor = Successor::Raw(usize::MAX); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[0].states[0].successor, Successor::None); +} + +#[test] +fn model_restarts_when_an_ancestor_state_array_cannot_grow() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.init_model(4).unwrap(); + let state = |symbol| State { + symbol, + freq: 1, + successor: Successor::None, + }; + let ancestor = decoder + .push_context(Context { + states: vec![state(b'a'), state(b'b')].into(), + summ_freq: 3, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let selected = decoder + .push_context(Context { + states: vec![state(b'c'), state(b'd')].into(), + summ_freq: 3, + suffix: Some(ancestor), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let expanded = decoder + .push_context(Context { + states: vec![state(b'a'), state(b'b')].into(), + summ_freq: 3, + suffix: Some(selected), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = selected; + decoder.max_context = expanded; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 1; + + decoder.suballoc.reset(16 * ALLOC_UNIT_BYTES); + decoder + .text + .resize(decoder.suballoc.text_capacity_bytes - 2, 0) + .unwrap(); + while decoder.suballoc.hi_bump > decoder.suballoc.lo_bump { + decoder.suballoc.alloc(1, AllocSide::Lo, 0).unwrap(); + } + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts.len(), 1); + assert_eq!(decoder.order_fall, 4); + assert!(decoder.text.is_empty()); +} + +#[test] +fn model_adds_ancestor_state_with_raw_or_context_successor() { + fn chain(existing_successor: Successor) -> (PpmdDecoder, usize) { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.init_model(4).unwrap(); + let state = |symbol, successor| State { + symbol, + freq: 1, + successor, + }; + let ancestor = decoder + .push_context(Context { + states: vec![state(b'a', Successor::None), state(b'b', Successor::None)].into(), + summ_freq: 3, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let selected = decoder + .push_context(Context { + states: vec![ + state(b'c', existing_successor), + state(b'd', Successor::None), + ] + .into(), + summ_freq: 3, + suffix: Some(ancestor), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let expanded = decoder + .push_context(Context { + states: vec![state(b'a', Successor::None), state(b'b', Successor::None)].into(), + summ_freq: 3, + suffix: Some(selected), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = selected; + decoder.max_context = expanded; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 1; + (decoder, expanded) + } + + let (mut decoder, expanded) = chain(Successor::None); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[expanded].states.len(), 3); + assert_eq!( + decoder.contexts[expanded].states[2].successor, + Successor::Raw(1) + ); + assert_eq!(&*decoder.text, b"c"); + + let (mut decoder, expanded) = chain(Successor::Context(2)); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[expanded].states.len(), 3); + assert_eq!( + decoder.contexts[expanded].states[2].successor, + Successor::Context(2) + ); + assert!(decoder.text.is_empty()); +} + +#[test] +fn model_updates_suffix_frequencies_at_the_binary_and_multi_state_caps() { + fn chain(suffix: Vec, symbol: u8) -> (PpmdDecoder, usize) { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.init_model(4).unwrap(); + let ancestor = decoder + .push_context(Context { + summ_freq: suffix.iter().map(|s| s.freq as u16).sum::() + 1, + states: suffix.into(), + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let selected = decoder + .push_context(Context { + states: vec![State { + symbol, + freq: 2, + successor: Successor::None, + }] + .into(), + summ_freq: 0, + suffix: Some(ancestor), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = selected; + decoder.max_context = selected; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 1; + (decoder, ancestor) + } + let state = |symbol, freq| State { + symbol, + freq, + successor: Successor::None, + }; + + for (initial, expected) in [(31, 32), (32, 32)] { + let (mut decoder, ancestor) = chain(vec![state(b'a', initial)], b'a'); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[ancestor].states[0].freq, expected); + } + + let (mut decoder, ancestor) = chain(vec![state(b'a', 2), state(b'b', 2)], b'b'); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[ancestor].states[0].symbol, b'b'); + assert_eq!(decoder.contexts[ancestor].states[0].freq, 4); + + let (mut decoder, ancestor) = chain(vec![state(b'a', 1), state(b'b', 115)], b'b'); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[ancestor].states[0].freq, 115); + + let (mut decoder, ancestor) = chain(vec![state(b'a', 2), state(b'b', 2)], b'c'); + decoder.update_model().unwrap(); + assert_eq!(decoder.contexts[ancestor].states[0].freq, 2); + assert_eq!(decoder.contexts[ancestor].states[1].freq, 2); +} + +#[test] +fn successor_creation_materializes_raw_chain_and_handles_limits() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.init_model(4).unwrap(); + let selected = decoder + .push_context(Context { + states: vec![State { + symbol: b'a', + freq: 2, + successor: Successor::Raw(0), + }] + .into(), + summ_freq: 0, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.contexts[0].states[b'a' as usize].successor = Successor::Raw(0); + decoder.min_context = selected; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 1; + decoder.text.push(b'b').unwrap(); + + let mut limited = decoder.clone(); + limited.max_contexts = 2; + assert_eq!(limited.create_successors().unwrap(), None); + let mut conflicting = decoder.clone(); + conflicting.contexts[0].states[b'a' as usize].successor = Successor::None; + assert_eq!(conflicting.create_successors().unwrap(), None); + + let leaf = decoder.create_successors().unwrap().unwrap(); + assert_eq!(decoder.contexts.len(), 4); + assert_eq!(decoder.contexts[leaf].states[0].symbol, b'b'); + assert_eq!(decoder.contexts[leaf].suffix, Some(2)); + assert_eq!( + decoder.contexts[0].states[b'a' as usize].successor, + Successor::Context(2) + ); + assert_eq!( + decoder.contexts[selected].states[0].successor, + Successor::Context(leaf) + ); +} + +#[test] +fn successor_creation_reuses_existing_context_without_materialization() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 4; + decoder.init_model(4).unwrap(); + let selected = decoder + .push_context(Context { + states: vec![State { + symbol: b'a', + freq: 2, + successor: Successor::Raw(0), + }] + .into(), + summ_freq: 0, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = selected; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 0; + decoder.contexts[0].states[b'a' as usize].successor = Successor::Context(0); + assert_eq!(decoder.create_successors().unwrap(), Some(0)); + assert_eq!(decoder.contexts.len(), 2); + + decoder.contexts[selected].states[0].successor = Successor::Context(0); + assert_eq!(decoder.create_successors().unwrap(), Some(0)); + decoder.order_fall = 1; + assert_eq!(decoder.create_successors().unwrap(), None); + decoder.order_fall = 0; + decoder.contexts[selected].states[0].successor = Successor::None; + assert_eq!(decoder.create_successors().unwrap(), None); + + decoder.min_context = 0; + decoder.found_state = StateRef { + context: 0, + index: 0, + }; + decoder.contexts[0].states[0].successor = Successor::Raw(0); + assert_eq!(decoder.create_successors().unwrap(), Some(0)); +} + +#[test] +fn cancelled_model_init_does_not_erase_contexts() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + let token = crate::ReadCancellation::new(); + decoder.set_read_control(crate::read_control::ReadControl::new(Some(&token))); + token.cancel(); + assert_eq!(decoder.init_model(8), Err(Error::Cancelled)); + assert_eq!(decoder.max_order, 4); + assert_eq!(decoder.contexts.len(), 1); +} + +#[test] +fn shrink_array_reuses_a_free_bucket_or_splits_in_place() { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 4; + let state = State { + symbol: 0, + freq: 1, + successor: Successor::None, + }; + let context = Context { + states: vec![state; 12].into(), + summ_freq: 13, + suffix: None, + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }; + let ctx = decoder.push_context(context).unwrap().unwrap(); + let original = decoder.contexts[ctx].array_offset; + decoder.shrink_state_array(ctx, 12, 12).unwrap(); + assert_eq!(decoder.contexts[ctx].array_offset, original); + // Six and five units share a bucket, so this shrink keeps its slot. + decoder.shrink_state_array(ctx, 12, 10).unwrap(); + assert_eq!(decoder.contexts[ctx].array_offset, original); + + // Six to two units has no spare block: keep the prefix and free the + // four-unit residue. A spare two-unit block later selects the swap. + decoder.shrink_state_array(ctx, 12, 4).unwrap(); + assert_eq!(decoder.contexts[ctx].array_offset, original); + assert!(decoder.suballoc.free_lists[3].contains(&(original + 2))); + let spare = decoder.suballoc.alloc(2, AllocSide::Lo, 0).unwrap(); + decoder.suballoc.free(spare, 2); + decoder.shrink_state_array(ctx, 12, 4).unwrap(); + assert_eq!(decoder.contexts[ctx].array_offset, spare); + assert!(decoder.suballoc.free_lists[4].contains(&original)); + + decoder.shrink_state_array(ctx, 4, 1).unwrap(); + assert_eq!(decoder.contexts[ctx].array_offset, NULL_OFFSET); +} + +#[test] +fn rescale_sorts_survivors_and_collapses_or_shrinks_arrays() { + fn model( + freqs: &[(u8, u8)], + sum: u16, + order_fall: usize, + found: usize, + ) -> (PpmdDecoder, usize) { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 4; + decoder.init_model(4).unwrap(); + let ctx = decoder + .push_context(Context { + states: freqs + .iter() + .map(|&(symbol, freq)| State { + symbol, + freq, + successor: Successor::None, + }) + .collect::>() + .into(), + summ_freq: sum, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = ctx; + decoder.found_state = StateRef { + context: ctx, + index: found, + }; + decoder.order_fall = order_fall; + (decoder, ctx) + } + + let (mut decoder, ctx) = model(&[(b'a', 10), (b'b', 1), (b'c', 80)], 92, 1, 0); + decoder.rescale().unwrap(); + assert_eq!( + decoder.contexts[ctx] + .states + .iter() + .map(|s| (s.symbol, s.freq)) + .collect::>(), + vec![(b'c', 40), (b'a', 7), (b'b', 1)] + ); + assert_eq!(decoder.contexts[ctx].summ_freq, 49); + + let (mut decoder, ctx) = model(&[(b'a', 10), (b'b', 125), (b'c', 2)], 138, 1, 1); + decoder.rescale().unwrap(); + assert_eq!(decoder.found_state.index, 0); + assert_eq!(decoder.contexts[ctx].states[0].symbol, b'b'); + assert_eq!(decoder.contexts[ctx].states[0].freq, 65); + + let (mut decoder, ctx) = model(&[(b'a', 125), (b'b', 1), (b'c', 1)], 130, 0, 0); + decoder.rescale().unwrap(); + assert_eq!(decoder.contexts[ctx].states.len(), 1); + assert_eq!(decoder.contexts[ctx].states[0].freq, 16); + assert_eq!(decoder.contexts[ctx].array_offset, NULL_OFFSET); + + let (mut decoder, ctx) = model(&[(b'a', 125), (b'b', 2), (b'c', 1)], 130, 0, 0); + let old_array = decoder.contexts[ctx].array_offset; + decoder.rescale().unwrap(); + assert_eq!( + decoder.contexts[ctx] + .states + .iter() + .map(|s| (s.symbol, s.freq)) + .collect::>(), + vec![(b'a', 64), (b'b', 1)] + ); + assert_eq!(decoder.contexts[ctx].summ_freq, 67); + assert_eq!(decoder.contexts[ctx].array_offset, old_array); + assert!(decoder.suballoc.free_lists[0].contains(&(old_array + 1))); +} + +#[test] +fn frequency_updates_rescale_at_the_reference_call_sites() { + fn model(freqs: &[(u8, u8)], selected: usize) -> (PpmdDecoder, usize) { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 4; + decoder.init_model(4).unwrap(); + let ctx = decoder + .push_context(Context { + states: freqs + .iter() + .map(|&(symbol, freq)| State { + symbol, + freq, + successor: Successor::None, + }) + .collect::>() + .into(), + summ_freq: freqs.iter().map(|&(_, freq)| freq as u16).sum::() + 1, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + for state in &mut decoder.contexts[ctx].states { + state.successor = Successor::Context(ctx); + } + decoder.min_context = ctx; + decoder.max_context = ctx; + decoder.found_state = StateRef { + context: ctx, + index: selected, + }; + decoder.order_fall = 0; + (decoder, ctx) + } + + let (mut decoder, ctx) = model(&[(b'a', 121), (b'b', 1)], 0); + decoder.update1_0().unwrap(); + assert_eq!(decoder.contexts[ctx].states.len(), 1); + + let (mut decoder, ctx) = model(&[(b'a', 1), (b'b', 121)], 1); + decoder.update1().unwrap(); + assert_eq!(decoder.contexts[ctx].states.len(), 1); + + // Variant H rescales update1 only when the selected state moves + // ahead of its predecessor, even if its frequency now exceeds 124. + let (mut decoder, ctx) = model(&[(b'a', 125), (b'b', 121)], 1); + decoder.update1().unwrap(); + assert_eq!(decoder.contexts[ctx].states[1].freq, 125); + assert_eq!(decoder.contexts[ctx].states.len(), 2); + + let (mut decoder, ctx) = model(&[(b'a', 121), (b'b', 1)], 0); + decoder.update2().unwrap(); + assert_eq!(decoder.contexts[ctx].states.len(), 1); + + let (mut decoder, ctx) = model(&[(b'a', 127)], 0); + decoder.update_bin().unwrap(); + assert_eq!(decoder.contexts[ctx].states[0].freq, 128); + decoder.update_bin().unwrap(); + assert_eq!(decoder.contexts[ctx].states[0].freq, 128); +} + +#[test] +fn make_esc_freq_rejects_invalid_masked_state_count() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder + .contexts + .push(Context { + states: vec![ + State { + symbol: b'a', + freq: 1, + successor: Successor::None, + }, + State { + symbol: b'b', + freq: 1, + successor: Successor::None, + }, + ] + .into(), + summ_freq: 2, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap(); + decoder.min_context = 1; + + assert!(matches!( + decoder.make_esc_freq(2), + Err(Error::InvalidData("RAR PPMd masked-state count is invalid")) + )); +} + +#[test] +fn update_model_rejects_invalid_frequency_arithmetic() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder + .contexts + .push(Context { + states: vec![State { + symbol: b'a', + freq: 10, + successor: Successor::None, + }] + .into(), + summ_freq: 1, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap(); + decoder.min_context = 1; + decoder.max_context = 0; + decoder.found_state = StateRef { + context: 1, + index: 0, + }; + decoder.order_fall = 1; + + assert!(matches!( + decoder.update_model(), + Err(Error::InvalidData("RAR PPMd model frequency is invalid")) + )); +} + +#[test] +fn update_model_rejects_zero_frequency_sum_and_unrepresentable_sum() { + fn chain( + ancestor: Vec, + ancestor_sum: u16, + selected: Vec, + selected_sum: u16, + ) -> PpmdDecoder { + let mut decoder = PpmdDecoder::new(); + decoder.max_contexts = 10; + decoder.init_model(4).unwrap(); + let ancestor = decoder + .push_context(Context { + states: ancestor.into(), + summ_freq: ancestor_sum, + suffix: Some(0), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + let selected = decoder + .push_context(Context { + states: selected.into(), + summ_freq: selected_sum, + suffix: Some(ancestor), + header_offset: NULL_OFFSET, + array_offset: NULL_OFFSET, + }) + .unwrap() + .unwrap(); + decoder.min_context = selected; + decoder.max_context = ancestor; + decoder.found_state = StateRef { + context: selected, + index: 0, + }; + decoder.order_fall = 1; + decoder + } + let state = |symbol, freq| State { + symbol, + freq, + successor: Successor::None, + }; + + let mut decoder = chain( + vec![state(b'a', 0)], + 0, + vec![state(b'c', 31), state(b'd', 1)], + 32, + ); + assert_eq!( + decoder.update_model(), + Err(Error::InvalidData("RAR PPMd model frequency is invalid")) + ); + + let selected = (0..10) + .map(|i| state(b'c' + i, if i == 0 { 31 } else { 1 })) + .collect(); + let mut decoder = chain(vec![state(b'a', 1), state(b'b', 1)], u16::MAX, selected, 40); + assert_eq!( + decoder.update_model(), + Err(Error::InvalidData("RAR PPMd model frequency overflows")) + ); +} + +#[test] +fn update_paths_reject_invalid_state_reference_without_panic() { + let mut decoder = PpmdDecoder::new(); + decoder.init_model(4).unwrap(); + decoder.found_state = StateRef { + context: 99, + index: 0, + }; + + assert_eq!( + decoder.update1_0(), + Err(Error::InvalidData("RAR PPMd state reference is invalid")) + ); + + decoder.found_state = StateRef { + context: 0, + index: 999, + }; + assert_eq!( + decoder.update_bin(), + Err(Error::InvalidData("RAR PPMd state reference is invalid")) + ); +} diff --git a/arca-rar/vendor/rars/src/codec/rar13.rs b/arca-rar/vendor/rars/src/codec/rar13.rs new file mode 100644 index 00000000..14611498 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar13.rs @@ -0,0 +1,923 @@ +#[cfg(feature = "write")] +mod encoder; +#[cfg(feature = "write")] +pub(crate) use encoder::unpack15_encode_with_options_and_progress; +#[cfg(feature = "write")] +pub use encoder::{ + find_long_lz, unpack15_encode, unpack15_encode_with_options, EncodeOptions, LongLz, + Unpack15Encoder, +}; + +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; +use std::io::{Read, Write}; + +const DEC_L1: &[u16] = &[ + 0x8000, 0xa000, 0xc000, 0xd000, 0xe000, 0xea00, 0xee00, 0xf000, 0xf200, 0xf200, 0xffff, +]; +const POS_L1: &[u16] = &[0, 0, 0, 2, 3, 5, 7, 11, 16, 20, 24, 32, 32]; +const DEC_L2: &[u16] = &[ + 0xa000, 0xc000, 0xd000, 0xe000, 0xea00, 0xee00, 0xf000, 0xf200, 0xf240, 0xffff, +]; +const POS_L2: &[u16] = &[0, 0, 0, 0, 5, 7, 9, 13, 18, 22, 26, 34, 36]; +const DEC_HF0: &[u16] = &[ + 0x8000, 0xc000, 0xe000, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xffff, +]; +const POS_HF0: &[u16] = &[0, 0, 0, 0, 0, 8, 16, 24, 33, 33, 33, 33, 33]; +const DEC_HF1: &[u16] = &[ + 0x2000, 0xc000, 0xe000, 0xf000, 0xf200, 0xf200, 0xf7e0, 0xffff, +]; +const POS_HF1: &[u16] = &[0, 0, 0, 0, 0, 0, 4, 44, 60, 76, 80, 80, 127]; +const DEC_HF2: &[u16] = &[ + 0x1000, 0x2400, 0x8000, 0xc000, 0xfa00, 0xffff, 0xffff, 0xffff, +]; +const POS_HF2: &[u16] = &[0, 0, 0, 0, 0, 0, 2, 7, 53, 117, 233, 0, 0]; +const DEC_HF3: &[u16] = &[0x0800, 0x2400, 0xee00, 0xfe80, 0xffff, 0xffff, 0xffff]; +const POS_HF3: &[u16] = &[0, 0, 0, 0, 0, 0, 0, 2, 16, 218, 251, 0, 0]; +const DEC_HF4: &[u16] = &[0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]; +const POS_HF4: &[u16] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0]; + +const SHORT_LEN1: [u8; 16] = [1, 3, 4, 4, 5, 6, 7, 8, 8, 4, 4, 5, 6, 6, 4, 0]; +const SHORT_XOR1: [u8; 15] = [ + 0x00, 0xa0, 0xd0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xc0, 0x80, 0x90, 0x98, 0x9c, 0xb0, +]; +const SHORT_LEN2: [u8; 16] = [2, 3, 3, 3, 4, 4, 5, 6, 6, 4, 4, 5, 6, 6, 4, 0]; +const SHORT_XOR2: [u8; 15] = [ + 0x00, 0x40, 0x60, 0xa0, 0xd0, 0xe0, 0xf0, 0xf8, 0xfc, 0xc0, 0x80, 0x90, 0x98, 0x9c, 0xb0, +]; + +pub fn unpack15_decode(input: &[u8], output_size: usize) -> Result> { + let mut decoder = Unpack15::new(); + decoder.decode_member(input, output_size, false) +} + +#[derive(Clone)] +pub struct Unpack15 { + pub(crate) read_control: crate::read_control::ReadControl, + state: Reader15State, +} +impl Clone for Reader15State { + fn clone(&self) -> Self { + self.try_clone().expect("unlimited legacy decoder copy") + } +} +impl Unpack15 { + pub fn new() -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + state: Reader15State::with_allowance(&Allowance::default()) + .expect("unlimited legacy decoder"), + } + } + pub fn decode_member(&mut self, input: &[u8], target: usize, solid: bool) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member(input, target, solid) + .map(Buffer::into_vec) + } + pub fn decode_member_to( + &mut self, + input: &[u8], + target: usize, + solid: bool, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state.decode_member_to(input, target, solid, out) + } + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + target: usize, + solid: bool, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader(input, target, solid, out) + } +} +#[cfg(all(test, feature = "write"))] +impl Reader15State { + fn new() -> Self { + Self::with_allowance(&Allowance::default()).unwrap() + } +} +pub(crate) struct Reader15State { + pub(crate) read_control: crate::read_control::ReadControl, + bits: ReaderBits, + target: usize, + output_written: usize, + window: Buffer, + unp_ptr: usize, + prev_ptr: usize, + first_win_done: bool, + // State names follow RAR13_FORMAT_SPECIFICATION.md §6 so the codec state + // lines up directly with the documented Unpack15 tables and traces. + ch_set: [u16; 256], + ch_set_a: [u16; 256], + ch_set_b: [u16; 256], + ch_set_c: [u16; 256], + n_to_pl: [u8; 256], + n_to_pl_b: [u8; 256], + n_to_pl_c: [u8; 256], + avr_plc: u32, + avr_plc_b: u32, + avr_ln1: u32, + avr_ln2: u32, + avr_ln3: u32, + max_dist3: u32, + nhfb: u32, + nlzb: u32, + num_huf: u32, + buf60: u32, + st_mode: bool, + l_count: u32, + flag_buf: u32, + flags_cnt: i32, + old_dist: [u32; 4], + old_dist_ptr: usize, + last_dist: u32, + last_length: u32, + #[cfg(all(test, feature = "write"))] + token_stats: DecodeTokenStats, + #[cfg(all(test, feature = "write"))] + old_distance_events: Vec, +} + +#[cfg(all(test, feature = "write"))] +#[derive(Clone, Copy, Debug, Default)] +struct DecodeTokenStats { + literals: u64, + st_literals: u64, + st_matches: u64, + st_match_bytes: u64, + short_matches: u64, + short_match_bytes: u64, + repeat_matches: u64, + repeat_match_bytes: u64, + old_distance_matches: u64, + old_distance_match_bytes: u64, + old_distance_codes: [u64; 4], + old_distance_near: u64, + old_distance_far: u64, + long_near_matches: u64, + long_near_match_bytes: u64, + long_far_matches: u64, + long_far_match_bytes: u64, +} + +#[cfg(all(test, feature = "write"))] +#[derive(Clone, Copy, Debug)] +struct OldDistanceEvent { + output_position: usize, + short_code: u32, + distance: u32, + length: u32, + max_dist3: u32, +} + +impl Reader15State { + /// A decoder ready to read either a fresh member or a solid continuation. + /// + /// The starting state comes from `reset_non_solid` rather than being + /// hand-copied, because the two drifted: the tables `init_huff` fills were + /// left zeroed here. Nothing noticed while every archive opened with a + /// non-solid member, since that member resets them before the first symbol + /// is read. A first member carrying the solid flag skips the reset and + /// decoded against zeroes. + pub(crate) fn with_allowance(allowance: &B) -> Result { + let mut decoder = Self { + read_control: crate::read_control::ReadControl::default(), + bits: ReaderBits::with_allowance(&[], allowance)?, + target: 0, + output_written: 0, + window: Buffer::filled(0x10000, 0, allowance)?, + unp_ptr: 0, + prev_ptr: 0, + first_win_done: false, + ch_set: [0; 256], + ch_set_a: [0; 256], + ch_set_b: [0; 256], + ch_set_c: [0; 256], + n_to_pl: [0; 256], + n_to_pl_b: [0; 256], + n_to_pl_c: [0; 256], + avr_plc: 0, + avr_plc_b: 0, + avr_ln1: 0, + avr_ln2: 0, + avr_ln3: 0, + max_dist3: 0, + nhfb: 0, + nlzb: 0, + num_huf: 0, + buf60: 0, + st_mode: false, + l_count: 0, + flag_buf: 0, + flags_cnt: 0, + old_dist: [0; 4], + old_dist_ptr: 0, + last_dist: 0, + last_length: 0, + #[cfg(all(test, feature = "write"))] + token_stats: DecodeTokenStats::default(), + #[cfg(all(test, feature = "write"))] + old_distance_events: Vec::new(), + }; + decoder.reset_non_solid(); + Ok(decoder) + } + + pub(crate) fn try_clone(&self) -> Result { + Ok(Self { + read_control: self.read_control.clone(), + bits: self.bits.try_clone()?, + target: self.target, + output_written: self.output_written, + window: Buffer::copied(&self.window, &self.window.allowance())?, + unp_ptr: self.unp_ptr, + prev_ptr: self.prev_ptr, + first_win_done: self.first_win_done, + ch_set: self.ch_set, + ch_set_a: self.ch_set_a, + ch_set_b: self.ch_set_b, + ch_set_c: self.ch_set_c, + n_to_pl: self.n_to_pl, + n_to_pl_b: self.n_to_pl_b, + n_to_pl_c: self.n_to_pl_c, + avr_plc: self.avr_plc, + avr_plc_b: self.avr_plc_b, + avr_ln1: self.avr_ln1, + avr_ln2: self.avr_ln2, + avr_ln3: self.avr_ln3, + max_dist3: self.max_dist3, + nhfb: self.nhfb, + nlzb: self.nlzb, + num_huf: self.num_huf, + buf60: self.buf60, + st_mode: self.st_mode, + l_count: self.l_count, + flag_buf: self.flag_buf, + flags_cnt: self.flags_cnt, + old_dist: self.old_dist, + old_dist_ptr: self.old_dist_ptr, + last_dist: self.last_dist, + last_length: self.last_length, + #[cfg(all(test, feature = "write"))] + token_stats: self.token_stats, + #[cfg(all(test, feature = "write"))] + old_distance_events: self.old_distance_events.clone(), + }) + } + pub fn decode_member( + &mut self, + input: &[u8], + target: usize, + solid: bool, + ) -> Result> { + self.read_control.check_codec()?; + let mut output = Buffer::with_capacity(target, &self.window.allowance())?; + self.decode_member_to(input, target, solid, &mut output)?; + Ok(output) + } + + pub fn decode_member_to( + &mut self, + input: &[u8], + target: usize, + solid: bool, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + self.init_member(target, solid); + self.bits = ReaderBits::with_allowance(input, &self.window.allowance())?; + self.decode_loop(out) + } + + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + target: usize, + solid: bool, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + const OUTPUT_CHUNK: usize = 64 * 1024; + + self.init_member(target, solid); + self.bits = ReaderBits::with_allowance(&[], &self.window.allowance())?; + self.bits.input.read_to_end(input)?; + + while self.output_written < self.target { + let chunk_target = self + .output_written + .saturating_add(OUTPUT_CHUNK) + .min(self.target); + let mut chunk = Buffer::with_capacity( + chunk_target - self.output_written, + &self.window.allowance(), + )?; + self.decode_loop_until(chunk_target, &mut chunk)?; + out.write_all(&chunk).map_err(Error::from)?; + } + Ok(()) + } + + fn init_member(&mut self, target: usize, solid: bool) { + self.target = target; + self.output_written = 0; + self.flags_cnt = -2; + self.flag_buf = 0; + self.st_mode = false; + self.l_count = 0; + + if !solid { + self.reset_non_solid(); + } + } + + fn decode_loop(&mut self, out: &mut impl Write) -> Result<()> { + if self.target == 0 { + return Ok(()); + } + + self.decode_loop_until(self.target, out) + } + + fn decode_loop_until(&mut self, target: usize, out: &mut impl Write) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.output_written < target { + poller.check_codec(self.output_written)?; + self.decode_step(out)?; + } + + Ok(()) + } + + fn decode_step(&mut self, out: &mut impl Write) -> Result<()> { + if self.flags_cnt == -2 { + self.get_flags_buf()?; + self.flags_cnt = 8; + } + + self.unp_ptr &= 0xffff; + self.first_win_done |= self.prev_ptr > self.unp_ptr; + self.prev_ptr = self.unp_ptr; + + if self.st_mode { + return self.huff_decode(out); + } + + self.flags_cnt -= 1; + if self.flags_cnt < 0 { + self.get_flags_buf()?; + self.flags_cnt = 7; + } + + if self.flag_buf & 0x80 != 0 { + self.flag_buf = (self.flag_buf << 1) & 0xff; + if self.nlzb > self.nhfb { + self.long_lz(out) + } else { + self.huff_decode(out) + } + } else { + self.flag_buf = (self.flag_buf << 1) & 0xff; + self.flags_cnt -= 1; + if self.flags_cnt < 0 { + self.get_flags_buf()?; + self.flags_cnt = 7; + } + if self.flag_buf & 0x80 != 0 { + self.flag_buf = (self.flag_buf << 1) & 0xff; + if self.nlzb > self.nhfb { + self.huff_decode(out) + } else { + self.long_lz(out) + } + } else { + self.flag_buf = (self.flag_buf << 1) & 0xff; + self.short_lz(out) + } + } + } + + fn reset_non_solid(&mut self) { + self.window.fill(0); + self.unp_ptr = 0; + self.prev_ptr = 0; + self.first_win_done = false; + self.avr_plc_b = 0; + self.avr_ln1 = 0; + self.avr_ln2 = 0; + self.avr_ln3 = 0; + self.num_huf = 0; + self.buf60 = 0; + self.avr_plc = 0x3500; + self.max_dist3 = 0x2001; + self.nhfb = 0x80; + self.nlzb = 0x80; + self.old_dist = [u32::MAX; 4]; + self.old_dist_ptr = 0; + self.last_dist = u32::MAX; + self.last_length = 0; + self.init_huff(); + } + + fn short_lz(&mut self, out: &mut impl Write) -> Result<()> { + self.num_huf = 0; + let mut bit_field = self.bits.get_bits(); + if self.l_count == 2 { + self.bits.add_bits(1); + if bit_field >= 0x8000 { + #[cfg(all(test, feature = "write"))] + { + self.token_stats.repeat_matches += 1; + self.token_stats.repeat_match_bytes += u64::from(self.last_length); + } + self.copy_string(self.last_dist, self.last_length, out)?; + return Ok(()); + } + bit_field = (bit_field << 1) & 0xffff; + self.l_count = 0; + } + + let bit_byte = (bit_field >> 8) as u8; + let mut length = 0usize; + // Both prefix tables cover every byte in either Buf60 state. + // The exhaustive table test verifies that a matching entry always exists. + if self.avr_ln1 < 37 { + loop { + let short_len = self.short_len1(length); + let mask = (!(0xffu16 >> short_len)) as u8; + if ((bit_byte ^ SHORT_XOR1[length]) & mask) == 0 { + break; + } + length += 1; + } + self.bits.add_bits(self.short_len1(length) as usize); + } else { + loop { + let short_len = self.short_len2(length); + let mask = (!(0xffu16 >> short_len)) as u8; + if ((bit_byte ^ SHORT_XOR2[length]) & mask) == 0 { + break; + } + length += 1; + } + self.bits.add_bits(self.short_len2(length) as usize); + } + + let mut length = length as u32; + if length >= 9 { + if length == 9 { + self.l_count += 1; + #[cfg(all(test, feature = "write"))] + { + self.token_stats.repeat_matches += 1; + self.token_stats.repeat_match_bytes += u64::from(self.last_length); + } + self.copy_string(self.last_dist, self.last_length, out)?; + return Ok(()); + } + if length == 14 { + self.l_count = 0; + length = self.decode_num(self.bits.get_bits(), 3, DEC_L2, POS_L2) + 5; + let distance = (self.bits.get_bits() >> 1) | 0x8000; + self.bits.add_bits(15); + self.last_length = length; + self.last_dist = distance; + #[cfg(all(test, feature = "write"))] + { + self.token_stats.short_matches += 1; + self.token_stats.short_match_bytes += u64::from(length); + } + self.copy_string(distance, length, out)?; + return Ok(()); + } + + self.l_count = 0; + let save_length = length; + let distance = + self.old_dist[(self.old_dist_ptr.wrapping_sub((length - 9) as usize)) & 3]; + length = self.decode_num(self.bits.get_bits(), 2, DEC_L1, POS_L1) + 2; + if length == 0x101 && save_length == 10 { + self.buf60 ^= 1; + return Ok(()); + } + if distance > 256 { + length += 1; + } + if distance >= self.max_dist3 { + length += 1; + } + + self.remember_match(distance, length); + #[cfg(all(test, feature = "write"))] + { + self.old_distance_events.push(OldDistanceEvent { + output_position: self.output_written, + short_code: save_length, + distance, + length, + max_dist3: self.max_dist3, + }); + self.token_stats.old_distance_matches += 1; + self.token_stats.old_distance_match_bytes += u64::from(length); + self.token_stats.old_distance_codes[(save_length - 10) as usize] += 1; + if distance <= 256 { + self.token_stats.old_distance_near += 1; + } else { + self.token_stats.old_distance_far += 1; + } + } + self.copy_string(distance, length, out)?; + return Ok(()); + } + + self.l_count = 0; + self.avr_ln1 += length; + self.avr_ln1 -= self.avr_ln1 >> 4; + + let distance_place = + (self.decode_num(self.bits.get_bits(), 5, DEC_HF2, POS_HF2) & 0xff) as usize; + let mut distance = self.ch_set_a[distance_place] as u32; + if distance_place > 0 { + let last_distance = self.ch_set_a[distance_place - 1]; + self.ch_set_a[distance_place] = last_distance; + self.ch_set_a[distance_place - 1] = distance as u16; + } + length += 2; + distance += 1; + self.remember_match(distance, length); + #[cfg(all(test, feature = "write"))] + { + self.token_stats.short_matches += 1; + self.token_stats.short_match_bytes += u64::from(length); + } + self.copy_string(distance, length, out) + } + + fn long_lz(&mut self, out: &mut impl Write) -> Result<()> { + self.num_huf = 0; + self.nlzb += 16; + if self.nlzb > 0xff { + self.nlzb = 0x90; + self.nhfb >>= 1; + } + let old_avr2 = self.avr_ln2; + + let bit_field = self.bits.get_bits(); + let mut length = if self.avr_ln2 >= 122 { + self.decode_num(bit_field, 3, DEC_L2, POS_L2) + } else if self.avr_ln2 >= 64 { + self.decode_num(bit_field, 2, DEC_L1, POS_L1) + } else if bit_field < 0x100 { + self.bits.add_bits(16); + bit_field + } else { + let mut length = 0u32; + while ((bit_field << length) & 0x8000) == 0 { + length += 1; + } + self.bits.add_bits((length + 1) as usize); + length + }; + + self.avr_ln2 += length; + self.avr_ln2 -= self.avr_ln2 >> 5; + + let bit_field = self.bits.get_bits(); + let distance_place = if self.avr_plc_b > 0x28ff { + self.decode_num(bit_field, 5, DEC_HF2, POS_HF2) + } else if self.avr_plc_b > 0x06ff { + self.decode_num(bit_field, 5, DEC_HF1, POS_HF1) + } else { + self.decode_num(bit_field, 4, DEC_HF0, POS_HF0) + }; + + self.avr_plc_b += distance_place; + self.avr_plc_b -= self.avr_plc_b >> 8; + + let idx = (distance_place & 0xff) as usize; + let mut distance; + let mut new_distance_place; + loop { + distance = self.ch_set_b[idx] as u32; + new_distance_place = self.n_to_pl_b[(distance & 0xff) as usize] as usize; + self.n_to_pl_b[(distance & 0xff) as usize] = + self.n_to_pl_b[(distance & 0xff) as usize].wrapping_add(1); + distance += 1; + if distance & 0xff == 0 { + corr_huff(&mut self.ch_set_b, &mut self.n_to_pl_b); + } else { + break; + } + } + + self.ch_set_b[idx] = self.ch_set_b[new_distance_place]; + self.ch_set_b[new_distance_place] = distance as u16; + + distance = ((distance & 0xff00) | (self.bits.get_bits() >> 8)) >> 1; + self.bits.add_bits(7); + + let old_avr3 = self.avr_ln3; + if length != 1 && length != 4 { + if length == 0 && distance <= self.max_dist3 { + self.avr_ln3 += 1; + self.avr_ln3 -= self.avr_ln3 >> 8; + } else if self.avr_ln3 > 0 { + self.avr_ln3 -= 1; + } + } + length += 3; + if distance >= self.max_dist3 { + length += 1; + } + if distance <= 256 { + length += 8; + } + if old_avr3 > 0xb0 || (self.avr_plc >= 0x2a00 && old_avr2 < 0x40) { + self.max_dist3 = 0x7f00; + } else { + self.max_dist3 = 0x2001; + } + + self.remember_match(distance, length); + #[cfg(all(test, feature = "write"))] + if distance <= 256 { + self.token_stats.long_near_matches += 1; + self.token_stats.long_near_match_bytes += u64::from(length); + } else { + self.token_stats.long_far_matches += 1; + self.token_stats.long_far_match_bytes += u64::from(length); + } + self.copy_string(distance, length, out) + } + + fn huff_decode(&mut self, out: &mut impl Write) -> Result<()> { + let bit_field = self.bits.get_bits(); + + let mut byte_place = if self.avr_plc > 0x75ff { + self.decode_num(bit_field, 8, DEC_HF4, POS_HF4) + } else if self.avr_plc > 0x5dff { + self.decode_num(bit_field, 6, DEC_HF3, POS_HF3) + } else if self.avr_plc > 0x35ff { + self.decode_num(bit_field, 5, DEC_HF2, POS_HF2) + } else if self.avr_plc > 0x0dff { + self.decode_num(bit_field, 5, DEC_HF1, POS_HF1) + } else { + self.decode_num(bit_field, 4, DEC_HF0, POS_HF0) + } & 0xff; + + if self.st_mode { + if byte_place == 0 && bit_field > 0x0fff { + byte_place = 0x100; + } + if byte_place == 0 { + let bit_field = self.bits.get_bits(); + self.bits.add_bits(1); + if bit_field & 0x8000 != 0 { + self.num_huf = 0; + self.st_mode = false; + return Ok(()); + } + + let length = if bit_field & 0x4000 != 0 { 4 } else { 3 }; + self.bits.add_bits(1); + let mut distance = self.decode_num(self.bits.get_bits(), 5, DEC_HF2, POS_HF2); + distance = (distance << 5) | (self.bits.get_bits() >> 11); + self.bits.add_bits(5); + #[cfg(all(test, feature = "write"))] + { + self.token_stats.st_matches += 1; + self.token_stats.st_match_bytes += u64::from(length); + } + self.copy_string(distance, length, out)?; + return Ok(()); + } + byte_place -= 1; + } else { + if self.num_huf >= 16 && self.flags_cnt == 0 { + self.st_mode = true; + } + self.num_huf += 1; + } + + self.avr_plc += byte_place; + self.avr_plc -= self.avr_plc >> 8; + self.nhfb += 16; + if self.nhfb > 0xff { + self.nhfb = 0x90; + self.nlzb >>= 1; + } + + let byte = (self.ch_set[byte_place as usize] >> 8) as u8; + #[cfg(all(test, feature = "write"))] + if self.st_mode { + self.token_stats.st_literals += 1; + } else { + self.token_stats.literals += 1; + } + self.put_byte(byte, out)?; + + let idx = byte_place as usize; + let mut cur_byte; + let mut new_byte_place; + loop { + cur_byte = self.ch_set[idx] as u32; + new_byte_place = self.n_to_pl[(cur_byte & 0xff) as usize] as usize; + self.n_to_pl[(cur_byte & 0xff) as usize] = + self.n_to_pl[(cur_byte & 0xff) as usize].wrapping_add(1); + cur_byte += 1; + if cur_byte & 0xff > 0xa1 { + corr_huff(&mut self.ch_set, &mut self.n_to_pl); + } else { + break; + } + } + + self.ch_set[idx] = self.ch_set[new_byte_place]; + self.ch_set[new_byte_place] = cur_byte as u16; + Ok(()) + } + + fn get_flags_buf(&mut self) -> Result<()> { + let flags_place = self.decode_num(self.bits.get_bits(), 5, DEC_HF2, POS_HF2) as usize; + if flags_place >= self.ch_set_c.len() { + return Ok(()); + } + + let mut flags; + let mut new_flags_place; + loop { + flags = self.ch_set_c[flags_place] as u32; + new_flags_place = self.n_to_pl_c[(flags & 0xff) as usize] as usize; + self.n_to_pl_c[(flags & 0xff) as usize] = + self.n_to_pl_c[(flags & 0xff) as usize].wrapping_add(1); + self.flag_buf = flags >> 8; + flags += 1; + if flags & 0xff == 0 { + corr_huff(&mut self.ch_set_c, &mut self.n_to_pl_c); + } else { + break; + } + } + + self.ch_set_c[flags_place] = self.ch_set_c[new_flags_place]; + self.ch_set_c[new_flags_place] = flags as u16; + Ok(()) + } + + fn decode_num( + &mut self, + num: u32, + mut start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], + ) -> u32 { + let num = num & 0xfff0; + let mut i = 0usize; + while dec_tab[i] as u32 <= num { + start_pos += 1; + i += 1; + } + self.bits.add_bits(start_pos as usize); + ((num - if i > 0 { dec_tab[i - 1] as u32 } else { 0 }) >> (16 - start_pos)) + + pos_tab[start_pos as usize] as u32 + } + + fn copy_string(&mut self, distance: u32, length: u32, out: &mut impl Write) -> Result<()> { + if self.output_written + length as usize > self.target { + return Err(Error::InvalidData("RAR 1.3 match exceeds output size")); + } + + if (!self.first_win_done && distance as usize > self.unp_ptr) + || distance as usize > 0x10000 + || distance == 0 + { + for _ in 0..length { + self.put_byte(0, out)?; + } + } else { + for _ in 0..length { + let byte = self.window[(self.unp_ptr.wrapping_sub(distance as usize)) & 0xffff]; + self.put_byte(byte, out)?; + } + } + Ok(()) + } + + fn put_byte(&mut self, byte: u8, out: &mut impl Write) -> Result<()> { + if self.output_written >= self.target { + return Err(Error::InvalidData("RAR 1.3 literal exceeds output size")); + } + self.window[self.unp_ptr] = byte; + self.unp_ptr = (self.unp_ptr + 1) & 0xffff; + out.write_all(&[byte]).map_err(Error::from)?; + self.output_written += 1; + Ok(()) + } + + fn remember_match(&mut self, distance: u32, length: u32) { + self.old_dist[self.old_dist_ptr] = distance; + self.old_dist_ptr = (self.old_dist_ptr + 1) & 3; + self.last_length = length; + self.last_dist = distance; + } + + fn short_len1(&self, pos: usize) -> u32 { + if pos == 1 { + self.buf60 + 3 + } else { + SHORT_LEN1[pos] as u32 + } + } + + fn short_len2(&self, pos: usize) -> u32 { + if pos == 3 { + self.buf60 + 3 + } else { + SHORT_LEN2[pos] as u32 + } + } + + fn init_huff(&mut self) { + for i in 0..256 { + self.ch_set[i] = (i as u16) << 8; + self.ch_set_b[i] = (i as u16) << 8; + self.ch_set_a[i] = i as u16; + self.ch_set_c[i] = (0u8.wrapping_sub(i as u8) as u16) << 8; + } + self.n_to_pl = [0; 256]; + self.n_to_pl_b = [0; 256]; + self.n_to_pl_c = [0; 256]; + corr_huff(&mut self.ch_set_b, &mut self.n_to_pl_b); + } +} + +impl Default for Unpack15 { + fn default() -> Self { + Self::new() + } +} + +fn corr_huff(char_set: &mut [u16; 256], num_to_place: &mut [u8; 256]) { + let mut pos = 0usize; + for rank in (0..=7).rev() { + for _ in 0..32 { + char_set[pos] = (char_set[pos] & !0xff) | rank; + pos += 1; + } + } + *num_to_place = [0; 256]; + for rank in (0..=6).rev() { + num_to_place[rank] = ((7 - rank) * 32) as u8; + } +} + +struct ReaderBits { + input: Buffer, + bit_pos: usize, +} + +impl ReaderBits { + fn with_allowance(input: &[u8], allowance: &B) -> Result { + Ok(Self { + input: Buffer::copied(input, allowance)?, + bit_pos: 0, + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + input: Buffer::copied(&self.input, &self.input.allowance())?, + bit_pos: self.bit_pos, + }) + } + + fn get_bits(&self) -> u32 { + let mut value = 0u32; + for i in 0..16 { + value <<= 1; + let bit_index = self.bit_pos + i; + let byte = self.input.get(bit_index / 8).copied().unwrap_or(0); + value |= ((byte >> (7 - (bit_index % 8))) & 1) as u32; + } + value + } + + fn add_bits(&mut self, count: usize) { + self.bit_pos += count; + } +} + +#[cfg(all(test, feature = "write"))] +impl ReaderBits { + fn new(input: &[u8]) -> Self { + Self::with_allowance(input, &Allowance::default()).unwrap() + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar13/encoder.rs b/arca-rar/vendor/rars/src/codec/rar13/encoder.rs new file mode 100644 index 00000000..fb900a6e --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar13/encoder.rs @@ -0,0 +1,1470 @@ +//! RAR13 member encoding and bit emission. +use super::*; + +/// Prebuilt long-LZ candidate index. Unlike the other encoders, rar13 builds +/// the index for the whole member up front and then queries it at arbitrary +/// positions, so candidates are stored per hash as position-sorted arrays: a +/// binary search finds the newest candidate before the query position and +/// iteration proceeds toward older ones with array locality. A linked-chain +/// finder is a poor fit here because its head always points at the newest +/// position in the member, forcing every query to pointer-chase past all +/// not-yet-reached positions. +#[derive(Debug, Clone)] +struct Rar13MatchFinder { + buckets: Vec>, +} + +const LONG_LZ_HASH_BITS: u32 = 16; + +impl Rar13MatchFinder { + fn build(input: &[u8]) -> Self { + let mut buckets = vec![Vec::new(); 1 << LONG_LZ_HASH_BITS]; + for pos in 0..input.len().saturating_sub(2) { + buckets[Self::hash(input, pos)].push(pos); + } + Self { buckets } + } + + fn hash(input: &[u8], pos: usize) -> usize { + let value = u32::from(input[pos]) + | (u32::from(input[pos + 1]) << 8) + | (u32::from(input[pos + 2]) << 16); + (value.wrapping_mul(0x9E37_79B1) >> (32 - LONG_LZ_HASH_BITS)) as usize + } + + /// Candidate positions strictly before `pos` sharing its 3-byte hash, + /// newest first. The caller must ensure 3 bytes are readable at `pos`. + fn candidates_before(&self, input: &[u8], pos: usize) -> impl Iterator + '_ { + let bucket = &self.buckets[Self::hash(input, pos)]; + let end = bucket.partition_point(|&candidate| candidate < pos); + bucket[..end].iter().rev().copied() + } +} + +const MAX_LONG_MATCH_CANDIDATES: usize = 64; + +const MAX_LONG_LZ_DISTANCE: usize = 0x7fff; + +pub fn unpack15_encode(input: &[u8]) -> Result> { + unpack15_encode_with_options(input, EncodeOptions::default()) +} + +pub fn unpack15_encode_with_options(input: &[u8], options: EncodeOptions) -> Result> { + if input.is_empty() { + return Ok(Vec::new()); + } + + let mut encoder = Unpack15Encoder::with_options(options); + encoder.encode_member(input) +} + +pub(crate) fn unpack15_encode_with_options_and_progress( + input: &[u8], + options: EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + if input.is_empty() { + return Ok(Vec::new()); + } + Unpack15Encoder::with_options(options).encode_member_with_progress(input, progress) +} + +pub struct Unpack15Encoder { + bits: BitWriter, + options: EncodeOptions, + // State names follow RAR13_FORMAT_SPECIFICATION.md §6 so the codec state + // lines up directly with the documented Unpack15 tables and traces. + ch_set: [u16; 256], + ch_set_c: [u16; 256], + ch_set_b: [u16; 256], + n_to_pl: [u8; 256], + n_to_pl_b: [u8; 256], + n_to_pl_c: [u8; 256], + ch_set_a: [u16; 256], + avr_plc: u32, + avr_plc_b: u32, + avr_ln1: u32, + avr_ln2: u32, + avr_ln3: u32, + max_dist3: u32, + nhfb: u32, + nlzb: u32, + num_huf: u32, + old_dist: [u32; 4], + old_dist_ptr: usize, + last_dist: u32, + last_length: u32, + l_count: u32, + #[cfg(test)] + stmode_literal_count: usize, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EncodeOptions { + old_distance_tokens: bool, + lazy_matching: bool, + stmode_literal_runs: bool, + max_long_match_distance: usize, +} + +impl EncodeOptions { + pub const fn new() -> Self { + Self { + old_distance_tokens: true, + lazy_matching: true, + stmode_literal_runs: true, + max_long_match_distance: MAX_LONG_LZ_DISTANCE, + } + } + + pub const fn with_old_distance_tokens(mut self, enabled: bool) -> Self { + self.old_distance_tokens = enabled; + self + } + + pub const fn with_lazy_matching(mut self, enabled: bool) -> Self { + self.lazy_matching = enabled; + self + } + + pub const fn with_stmode_literal_runs(mut self, enabled: bool) -> Self { + self.stmode_literal_runs = enabled; + self + } + + pub const fn with_max_long_match_distance(mut self, distance: usize) -> Self { + self.max_long_match_distance = distance; + self + } + + pub const fn old_distance_tokens_enabled(self) -> bool { + self.old_distance_tokens + } + + #[cfg(test)] + pub(crate) const fn lazy_matching_enabled(self) -> bool { + self.lazy_matching + } +} + +impl Default for EncodeOptions { + fn default() -> Self { + Self::new() + } +} + +impl Unpack15Encoder { + pub fn new() -> Self { + Self::with_options(EncodeOptions::default()) + } + + pub fn with_options(options: EncodeOptions) -> Self { + let mut encoder = Self { + bits: BitWriter::new(), + options, + ch_set: [0; 256], + ch_set_c: [0; 256], + ch_set_b: [0; 256], + n_to_pl: [0; 256], + n_to_pl_b: [0; 256], + n_to_pl_c: [0; 256], + ch_set_a: [0; 256], + avr_plc: 0x3500, + avr_plc_b: 0, + avr_ln1: 0, + avr_ln2: 0, + avr_ln3: 0, + max_dist3: 0x2001, + nhfb: 0x80, + nlzb: 0x80, + num_huf: 0, + old_dist: [u32::MAX; 4], + old_dist_ptr: 0, + last_dist: u32::MAX, + last_length: 0, + l_count: 0, + #[cfg(test)] + stmode_literal_count: 0, + }; + encoder.init_huff(); + encoder + } + + pub fn encode_literals_only(mut self, input: &[u8]) -> Result> { + Ok(self.encode_literals_only_member(input)) + } + + fn encode_literals_only_member(&mut self, input: &[u8]) -> Vec { + if input.is_empty() { + return Vec::new(); + } + self.bits = BitWriter::new(); + let mut pos = 0usize; + while pos < input.len() { + let mut flags = 0u8; + let mut flag_bits = 0usize; + let mut payloads = Vec::new(); + let mut plan_nhfb = self.nhfb; + let mut plan_nlzb = self.nlzb; + let mut plan_num_huf = self.num_huf; + let mut group_enters_stmode = false; + + while flag_bits < 8 && pos < input.len() { + // Literal-only planning can start with two-bit flags after a + // match-heavy solid member. Huffman updates only move that + // choice toward one-bit flags; the switch occurs after an + // even number of bits, so a flag cannot straddle the byte. + let flag = huff_flag_bits(plan_nlzb <= plan_nhfb); + write_planned_flag_bits(&mut flags, flag_bits, flag); + payloads.push(EncodedToken::Literal(input[pos])); + flag_bits += flag.len(); + if flag_bits == 8 && plan_num_huf >= 16 && pos + 1 < input.len() { + group_enters_stmode = true; + } + plan_num_huf += 1; + pos += 1; + plan_huff_effect(&mut plan_nhfb, &mut plan_nlzb); + } + + self.emit_flags_byte(flags); + self.emit_payloads(payloads); + if group_enters_stmode { + if self.options.stmode_literal_runs { + self.emit_stmode_literal_run(input, None, &mut pos); + } + self.emit_stmode_exit(); + } + } + std::mem::take(&mut self.bits).finish() + } + + pub fn encode_member(&mut self, input: &[u8]) -> Result> { + self.encode_member_inner(input, None) + } + + #[cfg(any(test, feature = "write"))] + pub(crate) fn encode_member_with_progress( + &mut self, + input: &[u8], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result> { + self.encode_member_inner(input, Some(progress)) + } + + fn encode_member_inner( + &mut self, + input: &[u8], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + if input.is_empty() { + return Ok(Vec::new()); + } + self.bits = BitWriter::new(); + // Everything the decoder drops at a member boundary has to be dropped + // here too. The adaptive tables carry across a solid run, but the + // short-LZ literal run does not: `Unpack15::init_member` clears it for + // every member, solid or not. Leaving it set here made the encoder + // write a break bit at the start of the next member that no decoder + // was going to read, and one stray bit desynchronises the rest of the + // archive. + self.l_count = 0; + let buckets = long_lz_buckets(input); + let mut pos = 0usize; + let mut next_report = 0usize; + let mut straddle: Option = None; + while pos < input.len() || straddle.is_some() { + let mut flags = 0u8; + let mut flag_bits = 0usize; + let mut payloads = Vec::new(); + let mut plan_encoder = self.clone_for_planning(); + let mut group_enters_stmode = false; + + if let Some(carried) = straddle.take() { + write_planned_flag_bits(&mut flags, 0, carried.rest); + flag_bits = carried.rest.len(); + payloads.push(carried.token); + plan_encoder.emit_payloads(vec![carried.token]); + } + + while flag_bits < 8 && pos < input.len() { + let state = plan_encoder.lz_plan_state(); + if let Some(token) = plan_encoder + .choose_lz_token(input, pos, &buckets, state) + .filter(|token| { + !self.options.lazy_matching + || !should_lazy_emit_literal( + input, + pos, + &buckets, + *token, + state.max_dist3, + self.options, + ) + }) + { + let flag = token.flag_bits(state.nlzb, state.nhfb); + let next_pos = pos + token.length() as usize; + if flag_fits(flag_bits, flag) { + write_planned_flag_bits(&mut flags, flag_bits, flag); + flag_bits += flag.len(); + pos = next_pos; + plan_encoder.emit_payloads(vec![token.into()]); + payloads.push(token.into()); + continue; + } + } + + let flag = huff_flag_bits(plan_encoder.nlzb <= plan_encoder.nhfb); + if flag_bits + flag.len() > 8 { + straddle = Some(split_flag( + &mut flags, + flag_bits, + flag, + EncodedToken::Literal(input[pos]), + )); + pos += 1; + break; + } + write_planned_flag_bits(&mut flags, flag_bits, flag); + let literal = input[pos]; + payloads.push(EncodedToken::Literal(input[pos])); + flag_bits += flag.len(); + if flag_bits == 8 && plan_encoder.num_huf >= 16 && pos + 1 < input.len() { + group_enters_stmode = true; + } + pos += 1; + plan_encoder.emit_literal(literal); + } + + self.emit_flags_byte(flags); + self.emit_payloads(payloads); + if group_enters_stmode { + if self.options.stmode_literal_runs { + self.emit_stmode_literal_run(input, Some(&buckets), &mut pos); + } + self.emit_stmode_exit(); + } + if pos >= next_report { + if progress.as_deref_mut().is_some_and(|report| !report(pos)) { + return Err(Error::Cancelled); + } + next_report = pos.saturating_add(1024 * 1024); + } + } + if progress.is_some_and(|report| !report(input.len())) { + return Err(Error::Cancelled); + } + Ok(std::mem::take(&mut self.bits).finish()) + } + + fn clone_for_planning(&self) -> Self { + Self { + bits: BitWriter::new(), + options: self.options, + ch_set: self.ch_set, + ch_set_c: self.ch_set_c, + ch_set_b: self.ch_set_b, + n_to_pl: self.n_to_pl, + n_to_pl_b: self.n_to_pl_b, + n_to_pl_c: self.n_to_pl_c, + ch_set_a: self.ch_set_a, + avr_plc: self.avr_plc, + avr_plc_b: self.avr_plc_b, + avr_ln1: self.avr_ln1, + avr_ln2: self.avr_ln2, + avr_ln3: self.avr_ln3, + max_dist3: self.max_dist3, + nhfb: self.nhfb, + nlzb: self.nlzb, + num_huf: self.num_huf, + old_dist: self.old_dist, + old_dist_ptr: self.old_dist_ptr, + last_dist: self.last_dist, + last_length: self.last_length, + l_count: self.l_count, + #[cfg(test)] + stmode_literal_count: self.stmode_literal_count, + } + } + + fn lz_plan_state(&self) -> LzPlanState { + LzPlanState { + last_dist: self.last_dist, + last_length: self.last_length, + old_dist: self.old_dist, + old_dist_ptr: self.old_dist_ptr, + max_dist3: self.max_dist3, + nlzb: self.nlzb, + nhfb: self.nhfb, + l_count: self.l_count, + } + } + + fn choose_lz_token( + &self, + input: &[u8], + pos: usize, + buckets: &Rar13MatchFinder, + state: LzPlanState, + ) -> Option { + let candidates = find_lz_tokens(input, pos, buckets, state, self.options); + candidates + .into_iter() + .filter_map(|token| self.token_bit_cost(token, state).map(|cost| (token, cost))) + .min_by(|(left, left_cost), (right, right_cost)| { + let left_score = left_cost * 256 / left.length() as usize; + let right_score = right_cost * 256 / right.length() as usize; + left_score + .cmp(&right_score) + .then_with(|| right.length().cmp(&left.length())) + }) + .map(|(token, _)| token) + } + + fn token_bit_cost(&self, token: MatchToken, state: LzPlanState) -> Option { + let flag_cost = token.flag_bits(state.nlzb, state.nhfb).len(); + match token { + MatchToken::RepeatLast(_) => Some(flag_cost + self.repeat_last_bit_cost(state.l_count)), + MatchToken::ShortLz(token) => { + let distance_value = token.distance - 1; + let distance_place = self + .ch_set_a + .iter() + .position(|&value| value as u32 == distance_value) + .expect("short-distance alphabet contains every distance"); + Some( + flag_cost + + l_count_break_bit_cost(state.l_count) + + self.short_lz_prefix_bit_cost(token.length - 2) + + decode_num_bit_cost(distance_place as u32, 5, DEC_HF2, POS_HF2)?, + ) + } + MatchToken::OldDist(token) => { + let length_code = old_dist_lz_length_code( + token.length, + token.distance, + state.max_dist3, + token.short_code, + ) + .expect("old-distance candidate passed both distance thresholds"); + Some( + flag_cost + + l_count_break_bit_cost(state.l_count) + + self.short_lz_prefix_bit_cost(token.short_code) + + decode_num_bit_cost(length_code, 2, DEC_L1, POS_L1)?, + ) + } + MatchToken::LongLz(token) => { + let length_code = long_lz_length_code_for_distance(token, state.max_dist3) + .expect("long-match candidate passed distance threshold validation"); + let distance_place = self.long_lz_distance_place(token.distance); + Some( + flag_cost + + self.long_lz_length_bit_cost(length_code) + + self.long_lz_distance_bit_cost(distance_place) + + 7, + ) + } + } + } + + fn emit_payloads(&mut self, payloads: Vec) { + for payload in payloads { + match payload { + EncodedToken::Literal(byte) => self.emit_literal(byte), + EncodedToken::ShortLz(short_lz) => { + self.emit_short_lz(short_lz); + } + EncodedToken::RepeatLast(repeat) => { + self.emit_repeat_last(repeat); + } + EncodedToken::OldDist(old_lz) => { + self.emit_old_dist_lz(old_lz); + } + EncodedToken::LongLz(long_lz) => { + self.emit_long_lz(long_lz); + } + } + } + } + + fn emit_flags_byte(&mut self, flags: u8) { + let flags_place = self + .ch_set_c + .iter() + .position(|&value| (value >> 8) as u8 == flags) + .expect("flag alphabet contains every byte"); + emit_decode_num(&mut self.bits, flags_place as u32, 5, DEC_HF2, POS_HF2); + + let mut cur_flags; + let mut new_flags_place; + loop { + cur_flags = self.ch_set_c[flags_place] as u32; + new_flags_place = self.n_to_pl_c[(cur_flags & 0xff) as usize] as usize; + self.n_to_pl_c[(cur_flags & 0xff) as usize] = + self.n_to_pl_c[(cur_flags & 0xff) as usize].wrapping_add(1); + cur_flags += 1; + if cur_flags & 0xff == 0 { + corr_huff(&mut self.ch_set_c, &mut self.n_to_pl_c); + } else { + break; + } + } + + self.ch_set_c[flags_place] = self.ch_set_c[new_flags_place]; + self.ch_set_c[new_flags_place] = cur_flags as u16; + } + + fn emit_literal(&mut self, byte: u8) { + let byte_place = self + .ch_set + .iter() + .position(|&value| (value >> 8) as u8 == byte) + .expect("literal alphabet contains every byte"); + self.emit_literal_place(byte_place, byte_place, true) + } + + fn emit_stmode_literal(&mut self, byte: u8) { + let byte_place = self + .ch_set + .iter() + .position(|&value| (value >> 8) as u8 == byte) + .expect("literal alphabet contains every byte"); + #[cfg(test)] + { + self.stmode_literal_count += 1; + } + self.emit_literal_place(byte_place + 1, byte_place, false) + } + + fn emit_stmode_literal_run( + &mut self, + input: &[u8], + buckets: Option<&Rar13MatchFinder>, + pos: &mut usize, + ) { + while *pos + 1 < input.len() { + if buckets + .and_then(|buckets| { + find_lz_token( + input, + *pos, + buckets, + LzPlanState { + last_dist: self.last_dist, + last_length: self.last_length, + old_dist: self.old_dist, + old_dist_ptr: self.old_dist_ptr, + max_dist3: self.max_dist3, + nlzb: self.nlzb, + nhfb: self.nhfb, + l_count: self.l_count, + }, + self.options, + ) + }) + .is_some() + { + break; + } + self.emit_stmode_literal(input[*pos]); + *pos += 1; + } + } + + fn emit_literal_place( + &mut self, + encoded_place: usize, + decoded_place: usize, + update_num_huf: bool, + ) { + debug_assert!(encoded_place <= self.ch_set.len()); + debug_assert!(decoded_place < self.ch_set.len()); + + let (start_pos, dec_tab, pos_tab) = if self.avr_plc > 0x75ff { + (8, DEC_HF4, POS_HF4) + } else if self.avr_plc > 0x5dff { + (6, DEC_HF3, POS_HF3) + } else if self.avr_plc > 0x35ff { + (5, DEC_HF2, POS_HF2) + } else if self.avr_plc > 0x0dff { + (5, DEC_HF1, POS_HF1) + } else { + (4, DEC_HF0, POS_HF0) + }; + emit_decode_num( + &mut self.bits, + encoded_place as u32, + start_pos, + dec_tab, + pos_tab, + ); + + self.avr_plc += decoded_place as u32; + self.avr_plc -= self.avr_plc >> 8; + self.nhfb += 16; + if self.nhfb > 0xff { + self.nhfb = 0x90; + self.nlzb >>= 1; + } + if update_num_huf { + self.num_huf += 1; + } + + let idx = decoded_place; + let mut cur_byte; + let mut new_byte_place; + loop { + cur_byte = self.ch_set[idx] as u32; + new_byte_place = self.n_to_pl[(cur_byte & 0xff) as usize] as usize; + self.n_to_pl[(cur_byte & 0xff) as usize] = + self.n_to_pl[(cur_byte & 0xff) as usize].wrapping_add(1); + cur_byte += 1; + if cur_byte & 0xff > 0xa1 { + corr_huff(&mut self.ch_set, &mut self.n_to_pl); + } else { + break; + } + } + + self.ch_set[idx] = self.ch_set[new_byte_place]; + self.ch_set[new_byte_place] = cur_byte as u16; + } + + fn emit_short_lz(&mut self, short_lz: ShortLz) { + debug_assert!((1..=256).contains(&short_lz.distance)); + debug_assert!((2..=10).contains(&short_lz.length)); + self.num_huf = 0; + if self.l_count == 2 { + self.bits.write_bits(0, 1); + self.l_count = 0; + } + let length_place = short_lz.length - 2; + self.emit_short_lz_code(length_place as usize); + self.l_count = 0; + + self.avr_ln1 += length_place; + self.avr_ln1 -= self.avr_ln1 >> 4; + + let distance_value = short_lz.distance - 1; + let distance_place = self + .ch_set_a + .iter() + .position(|&value| value as u32 == distance_value) + .expect("short-distance alphabet contains every distance"); + emit_decode_num(&mut self.bits, distance_place as u32, 5, DEC_HF2, POS_HF2); + if distance_place > 0 { + let last_distance = self.ch_set_a[distance_place - 1]; + self.ch_set_a[distance_place] = last_distance; + self.ch_set_a[distance_place - 1] = distance_value as u16; + } + self.remember_match(short_lz.distance, short_lz.length); + } + + fn emit_repeat_last(&mut self, repeat: RepeatLastLz) { + debug_assert_eq!(self.last_dist, repeat.distance); + debug_assert_eq!(self.last_length, repeat.length); + self.num_huf = 0; + if self.l_count == 2 { + self.bits.write_bits(1, 1); + } else { + self.emit_short_lz_code(9); + self.l_count += 1; + } + } + + fn emit_old_dist_lz(&mut self, old_lz: OldDistLz) { + self.num_huf = 0; + if self.l_count == 2 { + self.bits.write_bits(0, 1); + self.l_count = 0; + } + self.emit_short_lz_code(old_lz.short_code as usize); + self.l_count = 0; + + let expected_distance = self.old_dist[(self + .old_dist_ptr + .wrapping_sub((old_lz.short_code - 9) as usize)) + & 3]; + debug_assert_eq!(expected_distance, old_lz.distance); + let length_code = old_dist_lz_length_code( + old_lz.length, + old_lz.distance, + self.max_dist3, + old_lz.short_code, + ) + .expect("selected old-distance length passed planner validation"); + emit_decode_num(&mut self.bits, length_code, 2, DEC_L1, POS_L1); + self.remember_match(old_lz.distance, old_lz.length); + } + + fn emit_short_lz_code(&mut self, code: usize) { + let (code_len, code_byte) = if self.avr_ln1 < 37 { + (self.short_len1(code), SHORT_XOR1[code]) + } else { + (self.short_len2(code), SHORT_XOR2[code]) + }; + self.bits + .write_bits((code_byte >> (8 - code_len)) as u32, code_len as usize); + } + + fn short_lz_prefix_bit_cost(&self, code: u32) -> usize { + debug_assert!(code < SHORT_XOR1.len() as u32); + let code = code as usize; + (if self.avr_ln1 < 37 { + self.short_len1(code) + } else { + self.short_len2(code) + }) as usize + } + + fn repeat_last_bit_cost(&self, l_count: u32) -> usize { + if l_count == 2 { + 1 + } else { + self.short_lz_prefix_bit_cost(9) + } + } + + fn emit_long_lz(&mut self, long_lz: LongLz) { + self.num_huf = 0; + self.nlzb += 16; + if self.nlzb > 0xff { + self.nlzb = 0x90; + self.nhfb >>= 1; + } + let old_avr2 = self.avr_ln2; + + let length_code = self + .long_lz_length_code(long_lz) + .expect("selected long-match length passed planner validation"); + emit_long_lz_length(&mut self.bits, self.avr_ln2, length_code); + self.avr_ln2 += length_code; + self.avr_ln2 -= self.avr_ln2 >> 5; + + let distance_place = self.long_lz_distance_place(long_lz.distance); + let (start_pos, dec_tab, pos_tab) = if self.avr_plc_b > 0x28ff { + (5, DEC_HF2, POS_HF2) + } else if self.avr_plc_b > 0x06ff { + (5, DEC_HF1, POS_HF1) + } else { + (4, DEC_HF0, POS_HF0) + }; + emit_decode_num( + &mut self.bits, + distance_place as u32, + start_pos, + dec_tab, + pos_tab, + ); + self.avr_plc_b += distance_place as u32; + self.avr_plc_b -= self.avr_plc_b >> 8; + + let idx = distance_place; + let mut distance; + let mut new_distance_place; + loop { + distance = self.ch_set_b[idx] as u32; + new_distance_place = self.n_to_pl_b[(distance & 0xff) as usize] as usize; + self.n_to_pl_b[(distance & 0xff) as usize] = + self.n_to_pl_b[(distance & 0xff) as usize].wrapping_add(1); + distance += 1; + if distance & 0xff == 0 { + corr_huff(&mut self.ch_set_b, &mut self.n_to_pl_b); + } else { + break; + } + } + + self.ch_set_b[idx] = self.ch_set_b[new_distance_place]; + self.ch_set_b[new_distance_place] = distance as u16; + + let low_byte = ((long_lz.distance << 1) & 0xff) as u8; + self.bits.write_bits((low_byte >> 1) as u32, 7); + + let old_avr3 = self.avr_ln3; + if length_code != 1 && length_code != 4 { + if length_code == 0 && long_lz.distance <= self.max_dist3 { + self.avr_ln3 += 1; + self.avr_ln3 -= self.avr_ln3 >> 8; + } else if self.avr_ln3 > 0 { + self.avr_ln3 -= 1; + } + } + if old_avr3 > 0xb0 || (self.avr_plc >= 0x2a00 && old_avr2 < 0x40) { + self.max_dist3 = 0x7f00; + } else { + self.max_dist3 = 0x2001; + } + + self.remember_match(long_lz.distance, long_lz.length); + } + + fn long_lz_length_code(&self, long_lz: LongLz) -> Option { + long_lz_length_code_for_distance(long_lz, self.max_dist3) + } + + fn long_lz_distance_place(&self, target_distance: u32) -> usize { + let wanted_high = ((target_distance << 1) & 0xff00) as u16; + self.ch_set_b + .iter() + .position(|&value| value & 0xff00 == wanted_high) + .expect("long-distance alphabet contains every high byte") + } + + fn long_lz_length_bit_cost(&self, length_code: u32) -> usize { + debug_assert!(length_code < 0x100); + if self.avr_ln2 >= 122 { + decode_num_bit_cost(length_code, 3, DEC_L2, POS_L2) + .expect("L2 represents every length symbol") + } else if self.avr_ln2 >= 64 { + decode_num_bit_cost(length_code, 2, DEC_L1, POS_L1) + .expect("L1 represents every length symbol") + } else if length_code <= 7 { + length_code as usize + 1 + } else { + 16 + } + } + + fn long_lz_distance_bit_cost(&self, distance_place: usize) -> usize { + debug_assert!(distance_place < 256); + let cost = if self.avr_plc_b > 0x28ff { + decode_num_bit_cost(distance_place as u32, 5, DEC_HF2, POS_HF2) + } else if self.avr_plc_b > 0x06ff { + decode_num_bit_cost(distance_place as u32, 5, DEC_HF1, POS_HF1) + } else { + decode_num_bit_cost(distance_place as u32, 4, DEC_HF0, POS_HF0) + }; + cost.expect("distance codebooks represent every adaptive rank") + } + + fn emit_stmode_exit(&mut self) { + let (start_pos, dec_tab, pos_tab) = if self.avr_plc > 0x75ff { + (8, DEC_HF4, POS_HF4) + } else if self.avr_plc > 0x5dff { + (6, DEC_HF3, POS_HF3) + } else if self.avr_plc > 0x35ff { + (5, DEC_HF2, POS_HF2) + } else if self.avr_plc > 0x0dff { + (5, DEC_HF1, POS_HF1) + } else { + (4, DEC_HF0, POS_HF0) + }; + emit_decode_num(&mut self.bits, 0, start_pos, dec_tab, pos_tab); + self.bits.write_bits(1, 1); + self.num_huf = 0; + } + + fn init_huff(&mut self) { + for i in 0..256 { + self.ch_set[i] = (i as u16) << 8; + self.ch_set_c[i] = (0u8.wrapping_sub(i as u8) as u16) << 8; + self.ch_set_b[i] = (i as u16) << 8; + } + self.n_to_pl = [0; 256]; + self.n_to_pl_b = [0; 256]; + self.n_to_pl_c = [0; 256]; + for i in 0..256 { + self.ch_set_a[i] = i as u16; + } + corr_huff(&mut self.ch_set_b, &mut self.n_to_pl_b); + } + + fn remember_match(&mut self, distance: u32, length: u32) { + self.old_dist[self.old_dist_ptr] = distance; + self.old_dist_ptr = (self.old_dist_ptr + 1) & 3; + self.last_length = length; + self.last_dist = distance; + } + + fn short_len1(&self, pos: usize) -> u8 { + if pos == 1 { + 3 + } else { + SHORT_LEN1[pos] + } + } + + fn short_len2(&self, pos: usize) -> u8 { + if pos == 3 { + 3 + } else { + SHORT_LEN2[pos] + } + } +} + +impl Default for Unpack15Encoder { + fn default() -> Self { + Self::new() + } +} + +#[derive(Debug, Clone, Copy)] +struct LzPlanState { + last_dist: u32, + last_length: u32, + old_dist: [u32; 4], + old_dist_ptr: usize, + max_dist3: u32, + nlzb: u32, + nhfb: u32, + l_count: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum EncodedToken { + Literal(u8), + ShortLz(ShortLz), + RepeatLast(RepeatLastLz), + OldDist(OldDistLz), + LongLz(LongLz), +} + +/// Candidates from the match finder; literals take a separate planning path. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum MatchToken { + ShortLz(ShortLz), + RepeatLast(RepeatLastLz), + OldDist(OldDistLz), + LongLz(LongLz), +} + +impl MatchToken { + fn length(self) -> u32 { + match self { + Self::ShortLz(token) => token.length, + Self::RepeatLast(token) => token.length, + Self::OldDist(token) => token.length, + Self::LongLz(token) => token.length, + } + } + + fn flag_bits(self, nlzb: u32, nhfb: u32) -> &'static [bool] { + match self { + Self::LongLz(_) => long_lz_flag_bits(nlzb > nhfb), + Self::ShortLz(_) | Self::RepeatLast(_) | Self::OldDist(_) => &[false, false], + } + } +} + +impl From for EncodedToken { + fn from(token: MatchToken) -> Self { + match token { + MatchToken::ShortLz(value) => Self::ShortLz(value), + MatchToken::RepeatLast(value) => Self::RepeatLast(value), + MatchToken::OldDist(value) => Self::OldDist(value), + MatchToken::LongLz(value) => Self::LongLz(value), + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct ShortLz { + pub distance: u32, + pub length: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct RepeatLastLz { + pub distance: u32, + pub length: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct OldDistLz { + pub distance: u32, + pub length: u32, + pub short_code: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct LongLz { + pub distance: u32, + pub length: u32, +} + +fn huff_flag_bits(prefer_huff_on_one: bool) -> &'static [bool] { + if prefer_huff_on_one { + &[true] + } else { + &[false, true] + } +} + +fn long_lz_flag_bits(prefer_long_lz_on_one: bool) -> &'static [bool] { + if prefer_long_lz_on_one { + &[true] + } else { + &[false, true] + } +} + +/// A token whose flag did not fit in what was left of a flags byte. +/// +/// `Unpack15` fetches the next flags byte the moment it runs out of bits, and +/// it does that in the middle of reading a flag, not between tokens. So a +/// two-bit flag at the last bit of a byte is legal: its first bit closes that +/// byte and its second opens the next one, and only then does the decoder read +/// the token's payload. Padding the byte out instead leaves a bit the decoder +/// still reads as a flag, which desynchronises everything after it. +#[derive(Clone, Copy)] +struct Straddle { + token: EncodedToken, + /// The flag bits that belong at the front of the next flags byte. + rest: &'static [bool], +} + +fn split_flag( + flags: &mut u8, + flag_bits: usize, + flag: &'static [bool], + token: EncodedToken, +) -> Straddle { + let fits = 8 - flag_bits; + write_planned_flag_bits(flags, flag_bits, &flag[..fits]); + Straddle { + token, + rest: &flag[fits..], + } +} + +fn write_planned_flag_bits(flags: &mut u8, start: usize, bits: &[bool]) { + for (offset, &bit) in bits.iter().enumerate() { + if bit { + *flags |= 1 << (7 - start - offset); + } + } +} + +fn flag_fits(used: usize, flag: &[bool]) -> bool { + used + flag.len() <= 8 +} + +fn plan_huff_effect(nhfb: &mut u32, nlzb: &mut u32) { + *nhfb += 16; + if *nhfb > 0xff { + *nhfb = 0x90; + *nlzb >>= 1; + } +} + +fn l_count_break_bit_cost(l_count: u32) -> usize { + usize::from(l_count == 2) +} + +fn find_lz_token( + input: &[u8], + pos: usize, + buckets: &Rar13MatchFinder, + state: LzPlanState, + options: EncodeOptions, +) -> Option { + find_lz_tokens(input, pos, buckets, state, options) + .into_iter() + .next() +} + +fn find_lz_tokens( + input: &[u8], + pos: usize, + buckets: &Rar13MatchFinder, + state: LzPlanState, + options: EncodeOptions, +) -> Vec { + let mut tokens = Vec::with_capacity(4); + if let Some(repeat) = find_repeat_last_lz(input, pos, state.last_dist, state.last_length) { + tokens.push(MatchToken::RepeatLast(repeat)); + } + if options.old_distance_tokens { + if let Some(old_lz) = find_old_dist_lz( + input, + pos, + state.old_dist, + state.old_dist_ptr, + state.max_dist3, + ) { + tokens.push(MatchToken::OldDist(old_lz)); + } + } + if let Some(short_lz) = find_short_lz(input, pos) { + tokens.push(MatchToken::ShortLz(short_lz)); + } + if let Some(long_lz) = find_long_lz_with_buckets( + input, + pos, + options.max_long_match_distance, + buckets, + MAX_LONG_MATCH_CANDIDATES, + ) + .filter(|long_lz| long_lz_length_code_for_distance(*long_lz, state.max_dist3).is_some()) + { + tokens.push(MatchToken::LongLz(long_lz)); + } + tokens +} + +fn should_lazy_emit_literal( + input: &[u8], + pos: usize, + buckets: &Rar13MatchFinder, + current: MatchToken, + max_dist3: u32, + options: EncodeOptions, +) -> bool { + if !matches!(current, MatchToken::ShortLz(_) | MatchToken::LongLz(_)) { + return false; + } + + // Selected matches fit at least two bytes of the remaining input. + debug_assert!(pos + 1 < input.len()); + + let next = find_lz_token( + input, + pos + 1, + buckets, + LzPlanState { + last_dist: u32::MAX, + last_length: 0, + old_dist: [u32::MAX; 4], + old_dist_ptr: 0, + max_dist3, + nlzb: 0, + nhfb: 0, + l_count: 0, + }, + options, + ); + next.is_some_and(|next| { + matches!(next, MatchToken::ShortLz(_) | MatchToken::LongLz(_)) + && next.length() >= current.length() + 2 + }) +} + +fn find_short_lz(input: &[u8], pos: usize) -> Option { + if pos == 0 { + return None; + } + + let max_distance = pos.min(256); + let mut best = ShortLz { + distance: 0, + length: 0, + }; + for distance in 1..=max_distance { + let mut length = 0usize; + while length < 10 + && pos + length < input.len() + && input[pos + length] == input[pos + length - distance] + { + length += 1; + } + // Distances increase, so the first match of a given length is nearest. + if length >= 2 && length > best.length as usize { + best = ShortLz { + distance: distance as u32, + length: length as u32, + }; + } + } + + (best.length >= 2).then_some(best) +} + +fn find_repeat_last_lz( + input: &[u8], + pos: usize, + last_dist: u32, + last_length: u32, +) -> Option { + if last_dist == u32::MAX { + return None; + } + debug_assert!((1..=MAX_LONG_LZ_DISTANCE as u32).contains(&last_dist)); + debug_assert!((2..=258).contains(&last_length)); + debug_assert!(pos <= input.len()); + let distance = last_dist as usize; + let length = last_length as usize; + if distance > pos || pos + length > input.len() { + return None; + } + let matches = (0..length).all(|offset| input[pos + offset] == input[pos + offset - distance]); + matches.then_some(RepeatLastLz { + distance: last_dist, + length: last_length, + }) +} + +fn find_old_dist_lz( + input: &[u8], + pos: usize, + old_dist: [u32; 4], + old_dist_ptr: usize, + _max_dist3: u32, +) -> Option { + let mut best = OldDistLz { + distance: 0, + length: 0, + short_code: 0, + }; + for short_code in 10..=13 { + let distance = old_dist[(old_dist_ptr.wrapping_sub((short_code - 9) as usize)) & 3]; + if distance == u32::MAX { + continue; + } + debug_assert!((1..=MAX_LONG_LZ_DISTANCE as u32).contains(&distance)); + let distance_usize = distance as usize; + if distance_usize > pos { + continue; + } + let mut length = 0usize; + while length < 258 + && pos + length < input.len() + && input[pos + length] == input[pos + length - distance_usize] + { + length += 1; + } + if length >= 3 + && old_dist_lz_is_encodable(length as u32, distance, short_code) + && length > best.length as usize + { + best = OldDistLz { + distance, + length: length as u32, + short_code, + }; + } + } + + (best.length >= 3).then_some(best) +} + +fn old_dist_lz_is_encodable(length: u32, distance: u32, short_code: u32) -> bool { + old_dist_lz_length_code(length, distance, 0x2001, short_code).is_some() + && old_dist_lz_length_code(length, distance, 0x7f00, short_code).is_some() +} + +fn old_dist_lz_length_code( + length: u32, + distance: u32, + max_dist3: u32, + _short_code: u32, +) -> Option { + let decoded_bonus = u32::from(distance > 256) + u32::from(distance >= max_dist3); + let length_code = length.checked_sub(2 + decoded_bonus)?; + // DOS RAR 1.402 does not reliably decode an old-distance match whose + // length symbol reaches the all-ones value. Code 10 also reserves that + // value for the Buf60 toggle, but the compatibility limit applies to all + // four old-distance codes. + if length_code == 0xff { + return None; + } + Some(length_code) +} + +fn long_lz_length_code_for_distance(long_lz: LongLz, max_dist3: u32) -> Option { + let decoded_bonus = + u32::from(long_lz.distance >= max_dist3) + if long_lz.distance <= 256 { 8 } else { 0 }; + long_lz.length.checked_sub(3 + decoded_bonus) +} + +pub fn find_long_lz(input: &[u8], pos: usize, max_match_distance: usize) -> Option { + if pos == 0 { + return None; + } + + let max_distance = pos.min(MAX_LONG_LZ_DISTANCE).min(max_match_distance); + if max_distance == 0 { + return None; + } + let mut best = LongLz { + distance: 0, + length: 0, + }; + for distance in 1..=max_distance { + let length = super::super::fast::match_length(input, pos, distance, 258); + // LongLZ adds eight to the decoded length for distances up to 256, + // so its shortest encodable near-distance match is eleven bytes. + let min_length = if distance <= 256 { 11 } else { 3 }; + if length >= min_length && length > best.length as usize { + best = LongLz { + distance: distance as u32, + length: length as u32, + }; + } + } + + (best.length >= 3).then_some(best) +} + +fn find_long_lz_with_buckets( + input: &[u8], + pos: usize, + max_match_distance: usize, + buckets: &Rar13MatchFinder, + max_candidates: usize, +) -> Option { + if pos == 0 || pos + 2 >= input.len() { + return None; + } + + let max_distance = pos.min(MAX_LONG_LZ_DISTANCE).min(max_match_distance); + if max_distance == 0 { + return None; + } + let max_length = (input.len() - pos).min(258); + let mut best = LongLz { + distance: 0, + length: 0, + }; + let mut checked = 0usize; + for candidate in buckets.candidates_before(input, pos) { + let distance = pos - candidate; + if distance > max_distance { + break; + } + // Near-distance candidates are a separate, bounded set and must not + // consume the established search budget for older matches. + if distance > 256 { + if checked >= max_candidates { + break; + } + checked += 1; + } + // A candidate can only improve on the current best when it matches at + // least one byte past the best length, so probe that byte first. The + // loop breaks once best reaches `max_length`, so the probe index stays + // in bounds. + if best.length == 0 + || input[candidate + best.length as usize] == input[pos + best.length as usize] + { + let length = super::super::fast::match_length(input, pos, distance, max_length); + let min_length = if distance <= 256 { 11 } else { 3 }; + // Candidates arrive nearest first, so equal lengths cannot win. + if length >= min_length && length > best.length as usize { + best = LongLz { + distance: distance as u32, + length: length as u32, + }; + if length == max_length { + break; + } + } + } + } + + (best.length >= 3).then_some(best) +} + +fn long_lz_buckets(input: &[u8]) -> Rar13MatchFinder { + Rar13MatchFinder::build(input) +} + +fn emit_long_lz_length(bits: &mut BitWriter, avr_ln2: u32, length_code: u32) { + debug_assert!(length_code < 0x100); + if avr_ln2 >= 122 { + emit_decode_num(bits, length_code, 3, DEC_L2, POS_L2); + } else if avr_ln2 >= 64 { + emit_decode_num(bits, length_code, 2, DEC_L1, POS_L1); + } else if length_code <= 7 { + bits.write_bits(1, length_code as usize + 1); + } else { + bits.write_bits(length_code, 16); + } +} + +fn emit_decode_num( + bits: &mut BitWriter, + target: u32, + start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) { + let (code, len) = encode_decode_num_prefix(target, start_pos, dec_tab, pos_tab) + .expect("emitted symbol passed fixed codebook validation"); + bits.write_bits(code, len); +} + +fn decode_num_bit_cost( + target: u32, + start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) -> Option { + encode_decode_num_prefix(target, start_pos, dec_tab, pos_tab).map(|(_, len)| len) +} + +fn encode_decode_num_prefix( + target: u32, + start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) -> Option<(u32, usize)> { + // Fixed table/start pairs cover every visited index and have positive thresholds. + let end = 16.min(pos_tab.len().saturating_sub(1)); + for (len, &base) in pos_tab + .iter() + .enumerate() + .take(end + 1) + .skip(start_pos as usize) + { + let dec_index = len - start_pos as usize; + let upper = u32::from(dec_tab[dec_index]); + let previous = if dec_index == 0 { + 0 + } else { + u32::from(dec_tab[dec_index - 1]) + }; + let max_num = (upper - 1) & !0xf; + if max_num < previous { + continue; + } + let base = u32::from(base); + let max_target = ((max_num - previous) >> (16 - len)) + base; + if target <= max_target { + // Nonempty fixed-table intervals are contiguous, so earlier ones + // already handle every target below this base. + debug_assert!(target >= base); + let num = previous + ((target - base) << (16 - len)); + return Some((num >> (16 - len), len)); + } + } + None +} + +#[cfg(test)] +#[path = "tests.rs"] +mod tests; + +#[derive(Default)] +struct BitWriter { + output: Vec, + bit_pos: usize, +} + +impl BitWriter { + fn new() -> Self { + Self { + output: Vec::new(), + bit_pos: 0, + } + } + + fn write_bits(&mut self, value: u32, count: usize) { + super::super::fast::write_msb_bits( + &mut self.output, + &mut self.bit_pos, + u64::from(value), + count, + ); + } + + fn finish(self) -> Vec { + self.output + } +} + +#[cfg(test)] +#[path = "solid_regressions.rs"] +mod solid_regressions; diff --git a/arca-rar/vendor/rars/src/codec/rar13/solid_regressions.rs b/arca-rar/vendor/rars/src/codec/rar13/solid_regressions.rs new file mode 100644 index 00000000..2eabdad0 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar13/solid_regressions.rs @@ -0,0 +1,307 @@ +use super::*; +type Unpack15 = Reader15State; +type BitReader = ReaderBits; + +/// The options the RAR 1.3 writer uses at its default level. +fn rar13_options() -> EncodeOptions { + EncodeOptions::new() + .with_old_distance_tokens(false) + .with_lazy_matching(false) +} + +fn encode_solid_run(members: &[&[u8]], options: EncodeOptions) -> Vec> { + let mut encoder = Unpack15Encoder::with_options(options); + members + .iter() + .map(|member| encoder.encode_member(member).unwrap()) + .collect() +} + +fn decode_solid_run(packed: &[Vec], members: &[&[u8]]) -> Vec> { + let mut decoder = Unpack15::new(); + packed + .iter() + .zip(members) + .map(|(packed, member)| { + decoder + .decode_member(packed, member.len(), true) + .unwrap() + .into_vec() + }) + .collect() +} + +/// The short-LZ literal run does not survive a member boundary: the decoder +/// clears it for every member, solid or not. The encoder kept it, so where +/// a member happened to end mid-run the next one opened with a break bit +/// nothing would read, and every symbol after it was a bit out of step. +/// +/// This pair is the smallest one that ends a member with the run at two. +#[test] +fn a_member_boundary_clears_the_short_lz_literal_run() { + let first: Vec = b"abcdefgh".iter().cycle().take(128).copied().collect(); + let second = vec![0u8; 16]; + let members: Vec<&[u8]> = vec![&first, &second]; + + let packed = encode_solid_run(&members, rar13_options()); + let decoded = decode_solid_run(&packed, &members); + + assert_eq!(decoded[0], first); + assert_eq!( + decoded[1], second, + "the second member decoded a bit out of step" + ); +} + +/// A decoder handed a solid member first skips the non-solid reset, so +/// whatever it was constructed with is what decodes the member. It used to +/// be constructed with the Huffman tables left at zero. +#[test] +fn a_first_member_marked_solid_decodes_against_real_tables() { + let member = b"the quick brown fox jumps over the lazy dog\n".repeat(40); + let members: Vec<&[u8]> = vec![&member]; + let packed = encode_solid_run(&members, rar13_options()); + + let mut fresh = Unpack15::new(); + let solid = fresh.decode_member(&packed[0], member.len(), true).unwrap(); + assert_eq!(solid, member); + + // And it agrees with the same member read as a fresh one. + let mut other = Unpack15::new(); + let plain = other + .decode_member(&packed[0], member.len(), false) + .unwrap(); + assert_eq!(plain, member); +} + +/// Several members in a row, with the shapes that move the adaptive state +/// around: a long run, incompressible bytes, a short member and an empty +/// one. +#[test] +fn a_long_solid_run_round_trips() { + let repetitive = b"solid chain payload ".repeat(500); + let counted: Vec = (0..30_000u32) + .map(|index| (index * 7 % 251) as u8) + .collect(); + let short = b"tail".to_vec(); + let empty = Vec::new(); + let members: Vec<&[u8]> = vec![&repetitive, &counted, &short, &empty, &repetitive]; + + for options in [ + rar13_options(), + EncodeOptions::new().with_lazy_matching(false), + ] { + let packed = encode_solid_run(&members, options); + let decoded = decode_solid_run(&packed, &members); + for (index, (got, want)) in decoded.iter().zip(&members).enumerate() { + assert_eq!(got, want, "member {index} did not survive the solid run"); + } + } +} + +#[test] +fn final_encoder_progress_report_can_cancel() { + let mut encoder = Unpack15Encoder::new(); + let mut reports = Vec::new(); + let error = encoder + .encode_member_with_progress(b"nonempty", &mut |position| { + reports.push(position); + reports.len() == 1 + }) + .unwrap_err(); + assert_eq!(error, Error::Cancelled); + assert_eq!(reports, [8, 8]); +} + +#[test] +fn literal_only_encoder_exits_stmode_without_literal_runs() { + let input: Vec<_> = (0..128).map(|index| (index * 73 + 19) as u8).collect(); + let mut encoder = + Unpack15Encoder::with_options(EncodeOptions::new().with_stmode_literal_runs(false)); + let packed = encoder.encode_literals_only_member(&input); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn default_encoder_round_trips_low_rank_literal_history() { + let input = vec![b'x'; 4096]; + let mut encoder = Unpack15Encoder::default(); + let packed = encoder.encode_literals_only_member(&input); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); + assert!(encoder.avr_plc <= 0x0dff); +} + +#[test] +fn long_match_search_rejects_zero_history_or_distance_budget() { + let input = b"repeated repeated"; + assert_eq!(find_long_lz(input, 0, 16), None); + assert_eq!(find_long_lz(input, 9, 0), None); + let buckets = long_lz_buckets(input); + assert_eq!(find_long_lz_with_buckets(input, 9, 0, &buckets, 8), None); +} + +#[test] +fn equal_length_match_candidates_keep_nearest_distance() { + assert_eq!( + super::find_long_lz(&[0; 24], 11, 11), + Some(super::LongLz { + distance: 1, + length: 13 + }) + ); + let short = b"abcXabcYabcZ"; + assert_eq!( + find_short_lz(short, 8), + Some(ShortLz { + distance: 4, + length: 3, + }) + ); + + let prefix = b"abcdefghijkl"; + let mut long = Vec::new(); + for suffix in *b"XYZ" { + long.extend_from_slice(prefix); + long.push(suffix); + } + let buckets = long_lz_buckets(&long); + assert_eq!( + find_long_lz_with_buckets(&long, 26, 0x7fff, &buckets, 64), + Some(LongLz { + distance: 13, + length: 12, + }) + ); +} + +#[test] +fn decoder_refuses_literal_past_declared_output_size() { + let mut decoder = Unpack15::new(); + decoder.target = 0; + assert_eq!( + decoder.put_byte(b'x', &mut Vec::new()), + Err(Error::InvalidData("RAR 1.3 literal exceeds output size")) + ); +} + +#[test] +fn number_prefix_search_rejects_unrepresentable_candidates() { + assert_eq!( + super::encode_decode_num_prefix(u32::MAX, 4, super::DEC_HF0, super::POS_HF0), + None + ); + assert_eq!( + super::decode_num_bit_cost(256, 2, super::DEC_L1, super::POS_L1), + None + ); + assert_eq!( + super::decode_num_bit_cost(256, 3, super::DEC_L2, super::POS_L2), + None + ); +} + +#[test] +fn decoder_reads_far_short_match_token() { + let mut encoder = Unpack15Encoder::new(); + encoder.emit_short_lz_code(10); + emit_decode_num(&mut encoder.bits, 0xff, 2, DEC_L1, POS_L1); + encoder.emit_short_lz_code(14); + emit_decode_num(&mut encoder.bits, 0, 3, DEC_L2, POS_L2); + encoder.bits.write_bits(0, 15); + + let mut decoder = Unpack15::new(); + decoder.bits = BitReader::new(&encoder.bits.finish()); + decoder.target = 0x8000 + 5; + decoder.output_written = 0x8000; + decoder.unp_ptr = 0x8000; + decoder.window[..5].copy_from_slice(b"abcde"); + let mut output = Vec::new(); + decoder.short_lz(&mut output).unwrap(); + assert_eq!(decoder.buf60, 1); + assert!(output.is_empty(), "Buf60 toggle emits no match"); + decoder.short_lz(&mut output).unwrap(); + assert_eq!(output, b"abcde"); + assert_eq!(decoder.token_stats.short_matches, 1); +} + +#[test] +fn short_lz_prefix_tables_cover_every_byte_with_each_buf60_state() { + // RAR13_FORMAT_SPECIFICATION.md §6.13: Buf60 changes one prefix in + // each table. Completeness must hold for both wire states. + for (lengths, prefixes, adjusted) in [ + (&super::SHORT_LEN1, &super::SHORT_XOR1, 1), + (&super::SHORT_LEN2, &super::SHORT_XOR2, 3), + ] { + for buf60 in 0..=1 { + for byte in 0..=u8::MAX { + assert!( + prefixes.iter().enumerate().any(|(index, &prefix)| { + let len = if index == adjusted { + buf60 + 3 + } else { + lengths[index] + }; + (byte ^ prefix) & (!(0xffu16 >> len) as u8) == 0 + }), + "byte {byte:#04x}, Buf60={buf60}, adjusted prefix={adjusted}" + ); + } + } + } +} + +#[test] +fn old_distance_all_ones_length_does_not_toggle_buf60_for_other_codes() { + // The historical decoder reserves length 257 only for code 10. + // Current encoders avoid this symbol, but old/crafted streams can + // carry it with the other old-distance codes (§6.13). + for code in 11..=13 { + let mut encoder = Unpack15Encoder::new(); + encoder.emit_short_lz_code(code); + emit_decode_num(&mut encoder.bits, 0xff, 2, DEC_L1, POS_L1); + let mut decoder = Unpack15::new(); + decoder.bits = BitReader::new(&encoder.bits.finish()); + decoder.target = 257; + decoder.unp_ptr = 1; + decoder.window[0] = b'a'; + decoder.old_dist[(0usize.wrapping_sub(code - 9)) & 3] = 1; + let mut output = Vec::new(); + decoder.short_lz(&mut output).unwrap(); + assert_eq!(output, vec![b'a'; 257]); + assert_eq!(decoder.buf60, 0); + } +} + +#[test] +fn zero_distance_after_window_wrap_retains_historical_zero_fill() { + let mut decoder = Unpack15::new(); + decoder.first_win_done = true; + decoder.target = 3; + let mut output = Vec::new(); + decoder.copy_string(0, 3, &mut output).unwrap(); + assert_eq!(output, [0; 3]); +} + +#[test] +fn decoder_reads_stmode_short_match_token() { + for length in [3, 4] { + let mut bits = BitWriter::new(); + emit_decode_num(&mut bits, 0, 5, DEC_HF1, POS_HF1); + bits.write_bits(0, 1); // ST-mode match rather than exit. + bits.write_bits(u32::from(length == 4), 1); // Three- or four-byte match. + emit_decode_num(&mut bits, 0, 5, DEC_HF2, POS_HF2); + bits.write_bits(1, 5); // Distance one. + + let mut decoder = Unpack15::new(); + decoder.bits = BitReader::new(&bits.finish()); + decoder.st_mode = true; + decoder.target = 1 + length; + decoder.output_written = 1; + decoder.unp_ptr = 1; + decoder.window[0] = b'A'; + let mut output = Vec::new(); + decoder.huff_decode(&mut output).unwrap(); + assert_eq!(output, vec![b'A'; length]); + assert_eq!(decoder.token_stats.st_matches, 1); + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar13/tests.rs b/arca-rar/vendor/rars/src/codec/rar13/tests.rs new file mode 100644 index 00000000..41f57364 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar13/tests.rs @@ -0,0 +1,1482 @@ +use crate::codec::Error; + +#[test] +fn normal_encoder_round_trips_terminal_literal_flag_groups() { + for length in [23, 24, 25] { + let input: Vec = (0..length).collect(); + let packed = super::unpack15_encode(&input).unwrap(); + assert_eq!(super::unpack15_decode(&packed, input.len()).unwrap(), input); + } +} + +#[test] +fn final_literal_flag_crosses_into_a_terminal_flags_group() { + let first = match_heavy_payload(176, 8000); + let mut encoder = + super::Unpack15Encoder::with_options(super::EncodeOptions::new().with_lazy_matching(false)); + let first_packed = encoder.encode_member(&first).unwrap(); + let mut decoder = super::Unpack15::new(); + assert_eq!( + decoder + .decode_member(&first_packed, first.len(), false) + .unwrap(), + first + ); + let input: Vec = [b'A'; 24].into_iter().chain(*b"XYZ").collect(); + let mut planned = encoder.clone_for_planning(); + planned.emit_literal(b'A'); + let buckets = long_lz_buckets(&input); + assert_eq!( + planned.choose_lz_token(&input, 1, &buckets, planned.lz_plan_state()), + Some(MatchToken::LongLz(LongLz { + distance: 1, + length: 23 + })) + ); + let packed = encoder.encode_member(&input).unwrap(); + let mut partial = decoder.clone(); + assert_eq!( + decoder.decode_member(&packed, input.len(), true).unwrap(), + input + ); + assert_eq!( + partial + .decode_member(&packed, input.len() - 1, true) + .unwrap(), + input[..input.len() - 1] + ); + assert_eq!( + partial.state.flags_cnt, 1, + "one flag bit remains before the terminal literal" + ); + partial.state.target = input.len(); + let mut tail = Vec::new(); + partial.state.decode_step(&mut tail).unwrap(); + assert_eq!(tail, b"Z"); + assert_eq!( + partial.state.flags_cnt, 7, + "the second flag bit comes from the terminal flags group" + ); +} + +#[test] +fn empty_encoder_fast_paths_skip_progress_and_nonempty_work_can_cancel() { + assert!( + super::unpack15_encode_with_options(&[], super::EncodeOptions::default()) + .unwrap() + .is_empty() + ); + assert!(super::unpack15_encode_with_options_and_progress( + &[], + super::EncodeOptions::default(), + &mut |_| panic!("empty input has no codec work") + ) + .unwrap() + .is_empty()); + let mut checkpoints = Vec::new(); + assert_eq!( + super::unpack15_encode_with_options_and_progress( + b"abc", + super::EncodeOptions::default(), + &mut |position| { + checkpoints.push(position); + false + } + ), + Err(Error::Cancelled) + ); + assert_eq!(checkpoints, [3]); +} + +#[test] +fn public_decoder_renormalizes_repeated_flags_without_losing_the_alphabet() { + let mut encoder = super::Unpack15Encoder::new(); + let first = encoder.encode_member(&[0]).unwrap(); + let mut decoder = super::Unpack15::new(); + assert_eq!(decoder.decode_member(&first, 1, false).unwrap(), [0]); + for _ in 0..300 { + encoder.emit_flags_byte(0); + for _ in 0..4 { + encoder.emit_short_lz(super::ShortLz { + distance: 1, + length: 2, + }); + } + } + let packed = std::mem::take(&mut encoder.bits).finish(); + assert_eq!( + decoder.decode_member(&packed, 2400, true).unwrap(), + vec![0; 2400] + ); + assert_eq!(decoder.state.ch_set_c, encoder.ch_set_c); + let frequency = decoder + .state + .ch_set_c + .iter() + .find(|&&entry| entry >> 8 == 0) + .unwrap() + & 0xff; + assert_eq!( + frequency, 52, + "256th update renormalizes the hot entry to 7, then increments it" + ); +} + +#[test] +fn invalid_flag_rank_preserves_the_table_and_match_overrun_writes_nothing() { + let mut bits = super::BitWriter::new(); + super::emit_decode_num(&mut bits, 256, 5, super::DEC_HF2, super::POS_HF2); + let packed = bits.finish(); + let mut decoder = super::Unpack15::new(); + let alphabet = decoder.state.ch_set_c; + assert_eq!(decoder.decode_member(&packed, 2, false).unwrap(), [0; 2]); + assert_eq!(decoder.state.ch_set_c, alphabet); + let mut streaming = super::Unpack15::new(); + let mut output = Vec::new(); + streaming + .decode_member_from_reader(&mut packed.as_slice(), 2, false, &mut output) + .unwrap(); + assert_eq!(output, [0; 2]); + assert_eq!(streaming.state.ch_set_c, alphabet); + assert_eq!( + super::Unpack15::new().decode_member(&[], 1, false), + Err(Error::InvalidData("RAR 1.3 match exceeds output size")) + ); + output.clear(); + assert_eq!( + super::Unpack15::new().decode_member_from_reader(&mut &[][..], 1, false, &mut output), + Err(Error::InvalidData("RAR 1.3 match exceeds output size")) + ); + assert!(output.is_empty()); +} + +#[test] +fn consecutive_minimum_long_matches_cross_the_distance_threshold() { + let mut encoder = super::Unpack15Encoder::new(); + let first = encoder.encode_literals_only_member(&[0; 256]); + let mut decoder = super::Unpack15::new(); + assert_eq!(decoder.decode_member(&first, 256, false).unwrap(), [0; 256]); + assert!(decoder.state.avr_plc < 0x2a00); + for _ in 0..178 { + encoder.emit_long_lz(super::LongLz { + distance: 1, + length: 11, + }); + } + let payload = std::mem::take(&mut encoder.bits).finish(); + decoder.state.init_member(178 * 11, true); + decoder.state.bits = + super::ReaderBits::with_allowance(&payload, &decoder.state.window.allowance()).unwrap(); + let mut output = Vec::new(); + for index in 0..178 { + decoder.state.long_lz(&mut output).unwrap(); + if index < 177 { + assert_eq!(decoder.state.max_dist3, 0x2001); + } + } + assert_eq!(output, vec![0; 178 * 11]); + assert_eq!(decoder.state.avr_ln3, 178); + assert_eq!(decoder.state.max_dist3, 0x7f00); + assert_eq!(decoder.state.ch_set_b, encoder.ch_set_b); +} + +#[test] +fn maximum_far_distance_zero_fills_then_reads_wrapped_solid_history() { + fn far_member(encoder: &mut super::Unpack15Encoder) -> Vec { + encoder.emit_flags_byte(0); + // Code 14 is distinct from code 1 only after the Buf60 toggle. + encoder.emit_short_lz_code(10); + super::emit_decode_num(&mut encoder.bits, 255, 2, super::DEC_L1, super::POS_L1); + encoder.emit_short_lz_code(14); + super::emit_decode_num(&mut encoder.bits, 0, 3, super::DEC_L2, super::POS_L2); + encoder.bits.write_bits(0x7fff, 15); + std::mem::take(&mut encoder.bits).finish() + } + let mut encoder = super::Unpack15Encoder::new(); + let packed = far_member(&mut encoder); + let mut decoder = super::Unpack15::new(); + assert_eq!(decoder.decode_member(&packed, 5, false).unwrap(), [0; 5]); + assert_eq!(decoder.state.last_dist, 0xffff); + + let mut first = vec![0; 0x10000]; + first[1..6].copy_from_slice(b"abcde"); + let mut encoder = super::Unpack15Encoder::new(); + let packed_first = encoder.encode_literals_only_member(&first); + let mut decoder = super::Unpack15::new(); + assert_eq!( + decoder + .decode_member(&packed_first, first.len(), false) + .unwrap(), + first + ); + assert_eq!(decoder.state.unp_ptr, 0); + assert_eq!(decoder.state.old_dist, [u32::MAX; 4]); + // The next decoding step observes the wrap before reading a match. + let mut unused_history = decoder.clone(); + let mut unused_streaming = decoder.clone(); + let mut old_encoder = encoder.clone_for_planning(); + old_encoder.emit_flags_byte(0); + old_encoder.emit_short_lz_code(10); + super::emit_decode_num(&mut old_encoder.bits, 0, 2, super::DEC_L1, super::POS_L1); + let old_packed = std::mem::take(&mut old_encoder.bits).finish(); + assert_eq!( + unused_history.decode_member(&old_packed, 4, true).unwrap(), + [0; 4] + ); + assert!(unused_history.state.first_win_done); + assert_eq!(unused_history.state.last_dist, u32::MAX); + let mut zeros = Vec::new(); + unused_streaming + .decode_member_from_reader(&mut old_packed.as_slice(), 4, true, &mut zeros) + .unwrap(); + assert_eq!(zeros, [0; 4]); + let packed = far_member(&mut encoder); + let mut streaming = decoder.clone(); + assert_eq!(decoder.decode_member(&packed, 5, true).unwrap(), b"abcde"); + assert_eq!(decoder.state.last_dist, 0xffff); + assert!(decoder.state.first_win_done); + let mut output = Vec::new(); + streaming + .decode_member_from_reader(&mut packed.as_slice(), 5, true, &mut output) + .unwrap(); + assert_eq!(output, b"abcde"); +} + +#[test] +fn old_distance_finder_keeps_recent_entry_when_match_lengths_tie() { + let mut encoder = super::Unpack15Encoder::new(); + for distance in 1..=4 { + encoder.remember_match(distance, 3); + } + let token = super::find_old_dist_lz( + &[0; 16], + 8, + encoder.old_dist, + encoder.old_dist_ptr, + encoder.max_dist3, + ) + .unwrap(); + assert_eq!( + token, + super::OldDistLz { + distance: 4, + length: 8, + short_code: 10 + } + ); + for _ in 0..4 { + encoder.remember_match(4, 3); + } + assert_eq!( + super::find_old_dist_lz( + &[0; 16], + 8, + encoder.old_dist, + encoder.old_dist_ptr, + encoder.max_dist3 + ), + Some(token) + ); +} + +#[test] +fn repeat_and_old_finders_refuse_history_before_the_member_prefix() { + assert_eq!(super::find_repeat_last_lz(&[0; 8], 4, u32::MAX, 0), None); + assert_eq!(super::find_repeat_last_lz(&[0; 8], 4, 5, 3), None); + assert_eq!(super::find_repeat_last_lz(&[0; 8], 4, 4, 5), None); + assert_eq!(super::find_repeat_last_lz(b"abcdabce", 4, 4, 4), None); + assert_eq!( + super::find_repeat_last_lz(b"abcdabcd", 4, 4, 4), + Some(super::RepeatLastLz { + distance: 4, + length: 4 + }) + ); + assert_eq!( + super::find_old_dist_lz(&[0; 8], 4, [u32::MAX; 4], 0, 0x2001), + None + ); + assert_eq!(super::find_old_dist_lz(&[0; 8], 4, [5; 4], 0, 0x2001), None); +} + +#[test] +fn long_distance_updates_preserve_every_high_byte_through_counter_wraps() { + let mut encoder = super::Unpack15Encoder::new(); + let mut wraps = 0; + for distance in std::iter::repeat_n(128, 768).chain((0..256).map(|high| (high * 128).max(1))) { + let before = encoder.ch_set_b.iter().find(|&&v| v >> 8 == 1).unwrap() & 0xff; + let token = super::LongLz { + distance, + length: 11, + }; + assert!(encoder + .token_bit_cost(super::MatchToken::LongLz(token), encoder.lz_plan_state()) + .is_some()); + encoder.emit_long_lz(token); + let after = encoder.ch_set_b.iter().find(|&&v| v >> 8 == 1).unwrap() & 0xff; + wraps += usize::from(distance == 128 && after < before); + let mut counts = [0u16; 256]; + for &entry in &encoder.ch_set_b { + counts[(entry >> 8) as usize] += 1; + } + assert_eq!(counts, [1; 256]); + } + assert!(wraps >= 2); +} + +#[test] +fn long_length_cost_matches_emitted_bits_and_decoder_at_every_mode_boundary() { + for average in [0, 63, 64, 121, 122, 1000] { + let mut encoder = super::Unpack15Encoder::new(); + encoder.avr_ln2 = average; + for code in 0..=255 { + let length = encoder.long_lz_length_bit_cost(code); + let mut bits = super::BitWriter::new(); + super::emit_long_lz_length(&mut bits, average, code); + assert_eq!(bits.bit_pos, length); + let field = (u32::from(bits.output[0]) << 8) + | u32::from(bits.output.get(1).copied().unwrap_or(0)); + if average >= 64 { + let (start, thresholds, ranks) = if average >= 122 { + (3, DEC_L2, POS_L2) + } else { + (2, DEC_L1, POS_L1) + }; + for suffix in 0..(1u32 << (16 - length)) { + assert_eq!( + simulate_decode_num(field | suffix, start, thresholds, ranks), + (code, length) + ); + } + } else if code <= 7 { + assert_eq!(field, 1 << (15 - code)); + } else { + assert_eq!(field, code); + } + } + } +} + +#[test] +fn planned_old_distance_and_repeat_tokens_replay_after_flag_updates() { + fn state(encoder: &super::Unpack15Encoder) -> (u32, u32, [u32; 4], usize, u32, u32, u32, u32) { + let s = encoder.lz_plan_state(); + ( + s.last_dist, + s.last_length, + s.old_dist, + s.old_dist_ptr, + s.max_dist3, + s.nlzb, + s.nhfb, + s.l_count, + ) + } + for maximum in [0x2001, 0x7f00] { + let mut encoder = super::Unpack15Encoder::new(); + encoder.max_dist3 = maximum; + for distance in 1..=4 { + encoder.emit_short_lz(super::ShortLz { + distance, + length: 3, + }); + } + for code in 10..=13 { + for length in [3, 4, 256] { + let distance = + encoder.old_dist[(encoder.old_dist_ptr.wrapping_sub((code - 9) as usize)) & 3]; + let token = super::OldDistLz { + distance, + length, + short_code: code, + }; + assert!(encoder + .token_bit_cost( + super::MatchToken::OldDist(super::OldDistLz { + length: 258, + ..token + }), + encoder.lz_plan_state(), + ) + .is_none()); + assert!(encoder + .token_bit_cost(super::MatchToken::OldDist(token), encoder.lz_plan_state()) + .is_some()); + let mut planned = encoder.clone_for_planning(); + planned.emit_old_dist_lz(token); + // Real emission writes the flags table before replaying payloads. + // Wrap its adaptive counter to check that this remains independent. + for _ in 0..512 { + encoder.emit_flags_byte(255); + } + encoder.emit_old_dist_lz(token); + assert_eq!(state(&encoder), state(&planned)); + for _ in 0..3 { + let repeat = super::find_repeat_last_lz( + &[0; 1024], + 512, + encoder.last_dist, + encoder.last_length, + ) + .unwrap(); + planned.emit_repeat_last(repeat); + encoder.emit_flags_byte(0); + encoder.emit_repeat_last(repeat); + assert_eq!(state(&encoder), state(&planned)); + } + } + } + } +} + +#[test] +fn flags_and_short_distance_updates_preserve_complete_alphabets() { + let mut encoder = super::Unpack15Encoder::new(); + let mut renormalizations = 0; + for flags in std::iter::repeat_n(255, 768).chain(0..=255) { + let before = encoder.ch_set_c.iter().find(|&&v| v >> 8 == 255).unwrap() & 0xff; + encoder.emit_flags_byte(flags); + let after = encoder.ch_set_c.iter().find(|&&v| v >> 8 == 255).unwrap() & 0xff; + renormalizations += usize::from(flags == 255 && after < before); + let mut counts = [0u16; 256]; + for &entry in &encoder.ch_set_c { + counts[(entry >> 8) as usize] += 1; + } + assert_eq!(counts, [1; 256]); + } + assert!(renormalizations >= 2); + for length in 2..=10 { + for distance in (1..=256).rev() { + encoder.emit_short_lz(super::ShortLz { distance, length }); + let mut counts = [0u16; 256]; + for &entry in &encoder.ch_set_a { + counts[entry as usize] += 1; + } + assert_eq!(counts, [1; 256]); + } + } + let mut input: Vec = (0..=255).collect(); + input.extend_from_slice(&[0, 1]); + assert_eq!( + super::find_short_lz(&input, 256), + Some(super::ShortLz { + distance: 256, + length: 2 + }) + ); +} + +#[test] +fn adaptive_literal_updates_preserve_every_byte_through_renormalization() { + fn assert_alphabet(encoder: &super::Unpack15Encoder) { + let mut counts = [0u16; 256]; + for &entry in &encoder.ch_set { + counts[(entry >> 8) as usize] += 1; + assert!(entry & 0xff <= 0xa1); + } + assert_eq!(counts, [1; 256]); + } + for stmode in [false, true] { + for average in [0, 0x0e00, 0x3600, 0x5e00, 0x7600] { + let mut encoder = super::Unpack15Encoder::new(); + encoder.avr_plc = average; + let mut renormalizations = 0; + for byte in std::iter::repeat_n(0, 512).chain(0..=255) { + let before = encoder + .ch_set + .iter() + .find(|&&entry| entry >> 8 == 0) + .unwrap() + & 0xff; + if stmode { + encoder.emit_stmode_literal(byte); + } else { + encoder.emit_literal(byte); + } + let after = encoder + .ch_set + .iter() + .find(|&&entry| entry >> 8 == 0) + .unwrap() + & 0xff; + renormalizations += usize::from(byte == 0 && after < before); + assert_alphabet(&encoder); + } + assert!(renormalizations >= 2); + } + } +} + +#[test] +fn public_decoder_clone_keeps_independent_solid_history_and_tables() { + let first = b"legacy adaptive solid history ".repeat(32); + let second = b"legacy adaptive solid history ".repeat(8); + let mut encoder = super::Unpack15Encoder::new(); + let packed_first = encoder.encode_member(&first).unwrap(); + let packed_second = encoder.encode_member(&second).unwrap(); + let mut original = super::Unpack15::new(); + assert_eq!( + original + .decode_member(&packed_first, first.len(), false) + .unwrap(), + first + ); + let mut copied = original.clone(); + let other = b"a different non-solid member"; + assert_eq!( + original + .decode_member(&super::unpack15_encode(other).unwrap(), other.len(), false) + .unwrap(), + other + ); + drop(original); + assert_eq!( + copied + .decode_member(&packed_second, second.len(), true) + .unwrap(), + second + ); +} + +#[test] +fn reader15_workspace_refusals_release_window_input_output_and_checkpoint() { + use crate::codec::workspace::{Allowance, RefusingBudget}; + let data = b"legacy reader owned capacity\n".repeat(32); + let packed = unpack15_encode(&data).unwrap(); + for streaming in [false, true] { + let run = |budget: &RefusingBudget| -> super::Result<()> { + let mut decoder = super::Reader15State::with_allowance(budget)?; + if streaming { + let mut output = super::Buffer::new(budget); + decoder.decode_member_from_reader( + &mut packed.as_slice(), + data.len(), + false, + &mut output, + )?; + assert_eq!(&*output, &data); + } else { + let output = decoder.decode_member(&packed, data.len(), false)?; + assert_eq!(&*output, &data); + } + let checkpoint = decoder.try_clone()?; + assert_eq!(checkpoint.window, decoder.window); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts >= 5); + assert_eq!(baseline.used(), 0); + for index in 0..attempts { + let budget = RefusingBudget::new(index); + assert!( + matches!(run(&budget), Err(Error::Cancelled)), + "allocation {index}, streaming={streaming}" + ); + assert_eq!(budget.used(), 0); + } + } + let limit = Allowance::limited(0xffff); + assert!(matches!( + super::Reader15State::with_allowance(&limit), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(limit.used(), 0); +} + +#[test] +fn reader15_workspace_releases_input_and_chunk_on_sink_failure() { + use crate::codec::workspace::Allowance; + struct FailingSink; + impl std::io::Write for FailingSink { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "sink denied", + )) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let data = b"legacy output failure".repeat(10); + let packed = unpack15_encode(&data).unwrap(); + let ledger = Allowance::limited(128 * 1024); + let mut decoder = super::Reader15State::with_allowance(&ledger).unwrap(); + assert!(matches!( + decoder.decode_member_from_reader( + &mut packed.as_slice(), + data.len(), + false, + &mut FailingSink + ), + Err(Error::Io(_)) + )); + assert_eq!( + ledger.used(), + 0x10000 + decoder.bits.input.capacity() as u64 + ); + drop(decoder); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn cancellation_interrupts_buffered_symbol_work() { + let data = b"cancellable legacy symbols ".repeat(16384); + let packed = unpack15_encode(&data).unwrap(); + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack15::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + decoder.read_control.cancel_after_checks(3); + assert_eq!( + decoder + .decode_member(&packed, data.len(), false) + .unwrap_err(), + Error::Cancelled + ); + assert!(decoder.state.output_written > 0 && decoder.state.output_written < data.len()); +} +use super::{ + decode_num_bit_cost, find_long_lz, find_long_lz_with_buckets, find_lz_token, find_old_dist_lz, + find_short_lz, flag_fits, long_lz_buckets, should_lazy_emit_literal, unpack15_decode, + unpack15_encode, unpack15_encode_with_options, EncodeOptions, LongLz, LzPlanState, MatchToken, + OldDistLz, Rar13MatchFinder, ShortLz, Unpack15, Unpack15Encoder, DEC_HF0, DEC_HF1, DEC_HF2, + DEC_HF3, DEC_HF4, DEC_L1, DEC_L2, POS_HF0, POS_HF1, POS_HF2, POS_HF3, POS_HF4, POS_L1, POS_L2, +}; + +fn decode_num_prefix_is_stable( + code: u32, + len: usize, + target: u32, + start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) -> bool { + let relevant_tail_bits = 16usize.saturating_sub(len + 4); + for tail in 0..(1u32 << relevant_tail_bits) { + let bit_field = (code << (16 - len)) | (tail << 4); + let (decoded, consumed) = simulate_decode_num(bit_field, start_pos, dec_tab, pos_tab); + if decoded != target || consumed != len { + return false; + } + } + true +} + +fn simulate_decode_num( + bit_field: u32, + mut start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) -> (u32, usize) { + let num = bit_field & 0xfff0; + let mut i = 0usize; + while dec_tab[i] as u32 <= num { + start_pos += 1; + i += 1; + } + ( + ((num - if i > 0 { dec_tab[i - 1] as u32 } else { 0 }) >> (16 - start_pos)) + + pos_tab[start_pos as usize] as u32, + start_pos as usize, + ) +} + +#[test] +fn probe_rar15_solid() { + let Ok(dir) = std::env::var("RARS_PROBE_DIR") else { + return; + }; + let options = EncodeOptions::new().with_lazy_matching(false); + let mut names: Vec<_> = std::fs::read_dir(&dir) + .unwrap() + .map(|e| e.unwrap().path()) + .collect(); + names.sort(); + let mut enc = Unpack15Encoder::with_options(options); + let mut dec = Unpack15::new(); + for path in &names { + let data = std::fs::read(path).unwrap(); + let packed = enc.encode_member(&data).unwrap(); + match dec.decode_member(&packed, data.len(), true) { + Ok(out) if out == data => println!("{:?} solid OK", path.file_name().unwrap()), + Ok(out) => println!( + "{:?} solid WRONG at {:?}", + path.file_name().unwrap(), + out.iter().zip(data.iter()).position(|(a, b)| a != b) + ), + Err(e) => println!("{:?} solid ERROR {e:?}", path.file_name().unwrap()), + } + } +} + +fn brute_decode_num_bit_cost( + target: u32, + start_pos: u32, + dec_tab: &[u16], + pos_tab: &[u16], +) -> Option { + for len in start_pos as usize..=16 { + for code in 0..(1u32 << len) { + if decode_num_prefix_is_stable(code, len, target, start_pos, dec_tab, pos_tab) { + return Some(len); + } + } + } + None +} + +#[test] +fn decode_member_from_reader_accepts_incremental_input() { + struct TinyReader<'a> { + input: &'a [u8], + } + + impl std::io::Read for TinyReader<'_> { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if self.input.is_empty() { + return Ok(0); + } + let len = self.input.len().min(out.len()).min(2); + out[..len].copy_from_slice(&self.input[..len]); + self.input = &self.input[len..]; + Ok(len) + } + } + + let expected = b"RAR 1.4 incremental input fixture\n".repeat(32); + let packed = unpack15_encode(&expected).unwrap(); + assert_eq!(unpack15_decode(&packed, expected.len()).unwrap(), expected); + + let mut reader = TinyReader { input: &packed }; + let mut decoder = Unpack15::new(); + let mut output = Vec::new(); + decoder + .decode_member_from_reader(&mut reader, expected.len(), false, &mut output) + .unwrap(); + + assert_eq!(output, expected); +} + +#[test] +fn literal_only_encoder_round_trips_flag_and_mode_boundaries() { + for length in 0..=96 { + let input: Vec = (0..length) + .map(|index| (index * 73 + length * 17) as u8) + .collect(); + let packed = Unpack15Encoder::new().encode_literals_only(&input).unwrap(); + let decoded = unpack15_decode(&packed, input.len()).unwrap(); + assert_eq!(decoded, input, "literal-only length {length}"); + } +} + +#[test] +fn literal_only_encoder_follows_match_heavy_solid_history() { + let second: Vec = (0..96).map(|index| (index * 73 + 17) as u8).collect(); + let first = match_heavy_payload(176, 8000); + let mut encoder = Unpack15Encoder::with_options(EncodeOptions::new().with_lazy_matching(false)); + let first_packed = encoder.encode_member(&first).unwrap(); + assert!( + encoder.nlzb > encoder.nhfb, + "nlzb={} nhfb={}", + encoder.nlzb, + encoder.nhfb + ); + let second_packed = encoder.encode_literals_only(&second).unwrap(); + + let mut decoder = Unpack15::new(); + assert_eq!( + decoder + .decode_member(&first_packed, first.len(), false) + .unwrap(), + first + ); + assert_eq!( + decoder + .decode_member(&second_packed, second.len(), true) + .unwrap(), + second + ); +} + +#[test] +fn final_input_zero_pads_missing_bits_in_both_decode_paths() { + let mut decoder = Unpack15::new(); + let direct = decoder.decode_member(&[], 8, false).unwrap(); + assert_eq!(direct.len(), 8); + + let mut decoder = Unpack15::new(); + let mut from_reader = Vec::new(); + decoder + .decode_member_from_reader(&mut &[][..], 8, false, &mut from_reader) + .unwrap(); + assert_eq!(from_reader, direct); +} + +#[test] +fn fixed_number_tables_reencode_every_decoder_prefix() { + for (start, thresholds, ranks, maximum) in [ + (4, DEC_HF0, POS_HF0, 256), + (5, DEC_HF1, POS_HF1, 256), + (5, DEC_HF2, POS_HF2, 256), + (6, DEC_HF3, POS_HF3, 256), + (8, DEC_HF4, POS_HF4, 256), + (2, DEC_L1, POS_L1, 255), + (3, DEC_L2, POS_L2, 255), + ] { + assert!(ranks.len() <= 17); + assert!(ranks.len() > start as usize); + assert!(thresholds.len() >= ranks.len() - start as usize); + assert!(thresholds.iter().all(|&threshold| threshold != 0)); + assert!(thresholds.windows(2).all(|pair| pair[0] <= pair[1])); + assert_eq!(thresholds.last(), Some(&u16::MAX)); + let mut intervals = [None::<(u32, u32)>; 17]; + for field in 0..=u16::MAX { + let (target, consumed) = + simulate_decode_num(u32::from(field), start, thresholds, ranks); + assert!(target <= maximum); + let span = intervals[consumed].get_or_insert((target, target)); + span.0 = span.0.min(target); + span.1 = span.1.max(target); + let (prefix, length) = + super::encode_decode_num_prefix(target, start, thresholds, ranks).unwrap(); + assert_eq!(length, consumed); + assert_eq!(prefix, u32::from(field) >> (16 - length)); + } + let mut next = 0; + for (minimum, maximum) in intervals.into_iter().flatten() { + assert_eq!( + minimum, next, + "nonempty intervals are contiguous in bit-length order" + ); + next = maximum + 1; + } + assert_eq!(next, maximum + 1); + } +} + +#[test] +fn literal_codebooks_decode_every_rank_independently_of_following_bits() { + for (start, thresholds, ranks) in [ + (4, DEC_HF0, POS_HF0), + (5, DEC_HF1, POS_HF1), + (5, DEC_HF2, POS_HF2), + (6, DEC_HF3, POS_HF3), + (8, DEC_HF4, POS_HF4), + ] { + for rank in 0..=256 { + let (prefix, length) = + super::encode_decode_num_prefix(rank, start, thresholds, ranks).unwrap(); + for suffix in 0..(1u32 << (16 - length)) { + let field = (prefix << (16 - length)) | suffix; + assert_eq!( + simulate_decode_num(field, start, thresholds, ranks), + (rank, length), + "start={start}, rank={rank}, suffix={suffix}" + ); + } + } + } +} + +#[test] +fn decode_num_bit_cost_matches_prefix_search_at_table_boundaries() { + let tables = [ + (4, DEC_HF0, POS_HF0), + (5, DEC_HF1, POS_HF1), + (5, DEC_HF2, POS_HF2), + (6, DEC_HF3, POS_HF3), + (8, DEC_HF4, POS_HF4), + (2, DEC_L1, POS_L1), + (3, DEC_L2, POS_L2), + ]; + let targets = [0, 1, 2, 3, 7, 8, 16, 24, 32, 33, 53, 117, 233, 255, 256]; + + for (start_pos, dec_tab, pos_tab) in tables { + for target in targets { + assert_eq!( + decode_num_bit_cost(target, start_pos, dec_tab, pos_tab), + brute_decode_num_bit_cost(target, start_pos, dec_tab, pos_tab), + "target {target}, start_pos {start_pos}" + ); + } + } +} + +#[test] +fn encoder_emits_rar15_very_long_lz_matches() { + let mut input: Vec<_> = (0u8..=255).cycle().take(300).collect(); + input.extend_from_within(..258); + + assert_eq!( + find_long_lz(&input, 300, 0x8000), + Some(LongLz { + distance: 300, + length: 258 + }) + ); + let packed = unpack15_encode(&input).unwrap(); + + assert!( + packed.len() < 330, + "very-long LongLZ should encode a 258-byte repeat compactly, got {} bytes", + packed.len() + ); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn short_lz_accepts_the_two_byte_wire_minimum() { + let input = b"abXabY"; + + assert_eq!( + find_short_lz(input, 3), + Some(ShortLz { + distance: 3, + length: 2, + }) + ); + let packed = unpack15_encode(input).unwrap(); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn one_bit_match_flags_fit_at_every_open_position() { + for used in 0..8 { + assert!(flag_fits(used, &[true]), "flag bit {used}"); + } + assert!(!flag_fits(8, &[true])); +} + +#[test] +fn long_lz_search_accepts_near_distance_boundaries() { + let distance_one = vec![b'A'; 64]; + assert_eq!( + find_long_lz(&distance_one, 1, 0x8000), + Some(LongLz { + distance: 1, + length: 63, + }) + ); + + let distance_sixteen = b"abcdefghijklmnop".repeat(4); + assert_eq!( + find_long_lz(&distance_sixteen, 16, 0x8000), + Some(LongLz { + distance: 16, + length: 48, + }) + ); + + let distance_256: Vec<_> = (0u8..=255).cycle().take(512).collect(); + assert_eq!( + find_long_lz(&distance_256, 256, 0x8000), + Some(LongLz { + distance: 256, + length: 256, + }) + ); +} + +#[test] +fn near_long_lz_requires_the_eleven_byte_wire_minimum() { + let input = b"abcdefghijXabcdefghijY"; + + assert_eq!(find_long_lz(input, 11, 0x8000), None); +} + +#[test] +fn distance_257_remains_a_far_long_lz_match() { + let mut state = 0x1234_5678u32; + let mut input: Vec<_> = (0..257) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let repeated = input[..32].to_vec(); + input.extend_from_slice(&repeated); + + assert_eq!( + find_long_lz(&input, 257, 0x8000), + Some(LongLz { + distance: 257, + length: 32, + }) + ); +} + +#[test] +fn near_candidates_do_not_spend_the_far_match_budget() { + let pos = 2048; + let mut state = 0x9e37_79b9u32; + let mut input: Vec<_> = (0..pos + 32) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let pattern = b"ABCDEFGHIJKLMNOPQRST"; + input[128..128 + pattern.len()].copy_from_slice(pattern); + input[pos..pos + pattern.len()].copy_from_slice(pattern); + + let far_distractors: Vec<_> = (0..63).map(|index| 512 + index * 4).collect(); + let near_distractors: Vec<_> = (0..64).map(|index| pos - 256 + index * 4).collect(); + for &candidate in far_distractors.iter().chain(&near_distractors) { + input[candidate..candidate + 4].copy_from_slice(b"ABC!"); + } + + let mut positions = vec![128]; + positions.extend(far_distractors); + positions.extend(near_distractors); + let mut buckets = vec![Vec::new(); 1 << super::LONG_LZ_HASH_BITS]; + buckets[Rar13MatchFinder::hash(&input, pos)] = positions; + let finder = Rar13MatchFinder { buckets }; + + assert_eq!( + find_long_lz_with_buckets(&input, pos, 0x8000, &finder, 64), + Some(LongLz { + distance: (pos - 128) as u32, + length: pattern.len() as u32, + }) + ); +} + +#[test] +fn encoder_selects_and_round_trips_a_near_long_lz_match() { + let input = b"abcdefghijklmnop".repeat(64); + let buckets = long_lz_buckets(&input); + let encoder = Unpack15Encoder::new(); + + assert!(matches!( + encoder.choose_lz_token(&input, 16, &buckets, encoder.lz_plan_state()), + Some(MatchToken::LongLz(LongLz { + distance: 16, + length: 258, + })) + )); + + let packed = unpack15_encode(&input).unwrap(); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +/// Ad-hoc token census for comparing equivalent RAR 1.4 archives. +/// +/// Run with a platform-path-separated list of archive paths in +/// `RARS_RAR14_TOKEN_ARCHIVES` and `--ignored --nocapture`. +#[test] +#[ignore = "requires RARS_RAR14_TOKEN_ARCHIVES"] +fn report_rar14_token_census() { + let paths = + std::env::var_os("RARS_RAR14_TOKEN_ARCHIVES").expect("set RARS_RAR14_TOKEN_ARCHIVES"); + for path in std::env::split_paths(&paths) { + let bytes = std::fs::read(&path).unwrap(); + let archive = crate::rar13::Archive::parse(&bytes).unwrap(); + let mut decoder = Unpack15::new(); + println!("{}", path.display()); + for entry in &archive.entries { + if entry.is_stored() || entry.is_directory() { + continue; + } + decoder.state.token_stats = super::DecodeTokenStats::default(); + decoder.state.old_distance_events.clear(); + decoder + .decode_member( + entry.packed_data(&archive).unwrap(), + entry.header.unp_size as usize, + entry.header.flags & 0x10 != 0, + ) + .unwrap(); + if decoder.state.token_stats.old_distance_matches != 0 { + println!( + " {}: {:?}", + String::from_utf8_lossy(&entry.name), + decoder.state.token_stats + ); + if let Ok(from) = std::env::var("RARS_RAR14_EVENT_FROM") { + let from: usize = from.parse().unwrap(); + for event in decoder.state.old_distance_events.iter().filter(|event| { + event.output_position >= from + && event.output_position < from.saturating_add(500) + }) { + println!( + " pos={} code={} distance={} length={} max_dist3={}", + event.output_position, + event.short_code, + event.distance, + event.length, + event.max_dist3 + ); + } + } + } + } + } +} + +#[test] +fn encoder_adjusts_rar15_long_lz_length_for_far_distance_bonus() { + let mut input: Vec<_> = (0..9000).map(|index| (index * 73 + 19) as u8).collect(); + input.extend_from_within(..10); + + let packed = unpack15_encode(&input).unwrap(); + + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_reuses_rar15_repeat_last_token() { + let input = b"abcdefghijklmnop".repeat(64); + let packed = unpack15_encode(&input).unwrap(); + + assert!( + packed.len() < 100, + "repeat-last tokens should keep a simple repeated pattern compact, got {} bytes", + packed.len() + ); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn old_distance_finder_maps_ring_entries_to_short_lz_codes() { + let mut input: Vec<_> = (0..80).map(|index| (index * 37 + 11) as u8).collect(); + let pos = input.len(); + input.extend_from_within(pos - 33..pos - 13); + + assert_eq!( + find_old_dist_lz(&input, pos, [11, 22, 33, 44], 0, 0x2001), + Some(OldDistLz { + distance: 33, + length: 20, + short_code: 11, + }) + ); +} + +#[test] +fn old_distance_finder_rejects_dos_incompatible_maximum_length() { + let mut input = b"abcd".repeat(128); + let pos = input.len(); + input.extend((0..257).map(|index| b"abcd"[index % 4])); + + assert_eq!( + find_old_dist_lz(&input, pos, [u32::MAX, 4, u32::MAX, u32::MAX], 2, 0x2001), + None, + "the unsafe old-distance candidate should fall back to another token kind" + ); +} + +#[test] +fn old_distance_length_rejects_all_ones_symbol_for_every_short_code() { + for short_code in 10..=13 { + assert_eq!( + super::old_dist_lz_length_code(257, 4, 0x2001, short_code), + None, + "near old-distance code {short_code}" + ); + assert_eq!( + super::old_dist_lz_length_code(258, 330, 0x2001, short_code), + None, + "far old-distance code {short_code}" + ); + assert_eq!( + super::old_dist_lz_length_code(256, 4, 0x2001, short_code), + Some(254) + ); + assert_eq!( + super::old_dist_lz_length_code(257, 330, 0x2001, short_code), + Some(254) + ); + } +} + +#[test] +fn planner_emits_safe_old_distance_token() { + let mut input: Vec<_> = (0..80).map(|index| (index * 37 + 11) as u8).collect(); + let pos = input.len(); + input.extend_from_within(pos - 33..pos - 13); + + let encoder = Unpack15Encoder::new(); + let buckets = long_lz_buckets(&input); + let token = encoder + .choose_lz_token( + &input, + pos, + &buckets, + LzPlanState { + last_dist: u32::MAX, + last_length: 0, + old_dist: [11, 22, 33, 44], + old_dist_ptr: 0, + max_dist3: 0x2001, + nlzb: encoder.nlzb, + nhfb: encoder.nhfb, + l_count: encoder.l_count, + }, + ) + .expect("old-distance candidate should be selected"); + + assert_eq!( + token, + MatchToken::OldDist(OldDistLz { + distance: 33, + length: 20, + short_code: 11, + }) + ); +} + +#[test] +fn encoder_exits_stmode_when_literal_runs_trigger_decoder_mode() { + let input: Vec<_> = (0..96).map(|index| (index * 73 + 19) as u8).collect(); + let packed = unpack15_encode(&input).unwrap(); + + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_stmode_literals_for_long_literal_runs() { + let input: Vec<_> = (0..128).map(|index| (index * 73 + 19) as u8).collect(); + let mut encoder = Unpack15Encoder::new(); + let packed = encoder.encode_member(&input).unwrap(); + + assert!( + encoder.stmode_literal_count > 0, + "long literal runs should use stmode literals before exiting stmode" + ); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_options_can_disable_stmode_literal_runs() { + let input: Vec<_> = (0..128).map(|index| (index * 73 + 19) as u8).collect(); + let mut encoder = + Unpack15Encoder::with_options(EncodeOptions::new().with_stmode_literal_runs(false)); + let packed = encoder.encode_member(&input).unwrap(); + + assert_eq!(encoder.stmode_literal_count, 0); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_options_bound_long_lz_search_distance() { + let mut input: Vec<_> = (0u8..=255).cycle().take(300).collect(); + input.extend_from_within(..64); + + assert_eq!( + find_long_lz(&input, 300, 256), + Some(LongLz { + distance: 44, + length: 44, + }) + ); + assert_eq!( + find_long_lz(&input, 300, 0x8000), + Some(LongLz { + distance: 300, + length: 64 + }) + ); +} + +#[test] +fn long_lz_search_rejects_unencodable_32k_distance() { + let mut input = Vec::with_capacity(0x8000 + 64); + let mut state = 0x1234_5678u32; + for _ in 0..0x8000 + 64 { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + input.push((state >> 24) as u8); + } + let repeated = input[..64].to_vec(); + input[0x8000..0x8000 + 64].copy_from_slice(&repeated); + + let token = find_long_lz(&input, 0x8000, 0x8000); + + assert_ne!(token.map(|token| token.distance), Some(0x8000)); +} + +#[test] +fn lazy_match_prefers_longer_next_position_match() { + let input = b"abcXbcQRSTabcQRSTUV"; + let buckets = long_lz_buckets(input); + let token = find_lz_token( + input, + 10, + &buckets, + LzPlanState { + last_dist: u32::MAX, + last_length: 0, + old_dist: [u32::MAX; 4], + old_dist_ptr: 0, + max_dist3: 0x2001, + nlzb: 0, + nhfb: 0, + l_count: 0, + }, + EncodeOptions::default(), + ) + .unwrap(); + + assert!(matches!( + token, + MatchToken::ShortLz(super::ShortLz { length: 3, .. }) + )); + assert!(should_lazy_emit_literal( + input, + 10, + &buckets, + token, + 0x2001, + EncodeOptions::default() + )); + + let packed = unpack15_encode(input).unwrap(); + assert_eq!(unpack15_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn cost_aware_selection_prefers_better_bits_per_byte_token() { + let mut input = vec![b'Z'; 40]; + input[7] = b'A'; + input[8] = b'A'; + input[9] = b'A'; + input[10] = b'B'; + input[39] = b'A'; + let pos = input.len(); + input.extend_from_slice(b"AAAAAAAAAA"); + + let mut encoder = Unpack15Encoder::new(); + encoder.old_dist = [u32::MAX, u32::MAX, u32::MAX, 33]; + let buckets = long_lz_buckets(&input); + let token = encoder + .choose_lz_token( + &input, + pos, + &buckets, + LzPlanState { + last_dist: u32::MAX, + last_length: 0, + old_dist: encoder.old_dist, + old_dist_ptr: encoder.old_dist_ptr, + max_dist3: encoder.max_dist3, + nlzb: encoder.nlzb, + nhfb: encoder.nhfb, + l_count: encoder.l_count, + }, + ) + .unwrap(); + + assert_eq!( + token, + MatchToken::ShortLz(ShortLz { + distance: 1, + length: 10, + }) + ); +} + +#[test] +fn planner_uses_simulated_max_dist3_for_old_distance_candidates() { + let mut state = 0x1234_5678u32; + let mut input = Vec::with_capacity(9004); + for _ in 0..9004 { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + input.push(state as u8); + } + let pos = 9000; + let prefix = [input[0], input[1], input[2]]; + input[pos..pos + 3].copy_from_slice(&prefix); + input[pos + 3] = input[3].wrapping_add(1); + + let mut encoder = Unpack15Encoder::new(); + encoder.max_dist3 = 0x7f00; + let buckets = long_lz_buckets(&input); + let token = encoder.choose_lz_token( + &input, + pos, + &buckets, + LzPlanState { + last_dist: u32::MAX, + last_length: 0, + old_dist: [u32::MAX, u32::MAX, u32::MAX, 9000], + old_dist_ptr: 0, + max_dist3: 0x2001, + nlzb: encoder.nlzb, + nhfb: encoder.nhfb, + l_count: encoder.l_count, + }, + ); + + assert_eq!(token, None); +} + +#[test] +fn encoder_round_trips_source_shaped_payload() { + let source = concat!(include_str!("../rar13.rs"), include_str!("encoder.rs")).as_bytes(); + let input = &source[..source.len().min(50_902)]; + + let packed = unpack15_encode(input).unwrap(); + let decoded = unpack15_decode(&packed, input.len()).unwrap(); + + let first_diff = decoded + .iter() + .zip(input) + .position(|(actual, expected)| actual != expected); + assert_eq!(first_diff, None, "first differing byte in decoded payload"); + assert_eq!(decoded, input); +} + +/// Match-heavy input drives `nlzb` above `nhfb`, which widens the literal +/// flag to two bits, which is what lets a flag reach the last bit of a +/// flags byte with a bit still to place. The encoder used to pad the byte +/// and start the next group cleanly; the decoder read that padding as a +/// flag and everything after it decoded to the wrong bytes. +#[test] +fn a_flag_straddling_two_flags_bytes_round_trips() { + let input = match_heavy_payload(176, 8000); + + let packed = + unpack15_encode_with_options(&input, EncodeOptions::new().with_lazy_matching(false)) + .unwrap(); + let decoded = unpack15_decode(&packed, input.len()).unwrap(); + + let first_diff = decoded + .iter() + .zip(&input) + .position(|(actual, expected)| actual != expected); + assert_eq!(first_diff, None, "first differing byte in decoded payload"); +} + +fn match_heavy_payload(seed: u64, len: usize) -> Vec { + let mut state = seed | 1; + let mut next = move || { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + state + }; + let mut out = Vec::with_capacity(len); + while out.len() < len { + let value = next(); + if out.len() > 4096 && value % 3 != 0 { + let distance = 64 + (value >> 8) as usize % (out.len() - 64); + let length = 3 + (value >> 40) as usize % 24; + let start = out.len() - distance; + for index in 0..length { + let byte = out[start + index % distance]; + out.push(byte); + } + } else { + out.push((value >> 24) as u8); + } + } + out.truncate(len); + out +} diff --git a/arca-rar/vendor/rars/src/codec/rar20.rs b/arca-rar/vendor/rars/src/codec/rar20.rs new file mode 100644 index 00000000..b6cc0597 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar20.rs @@ -0,0 +1,760 @@ +#[cfg(feature = "write")] +mod encoder; +#[cfg(feature = "write")] +pub(crate) use encoder::unpack20_encode_auto_with_options_and_progress; +#[cfg(feature = "write")] +pub use encoder::{ + unpack20_encode_auto, unpack20_encode_auto_with_options, unpack20_encode_literals, + unpack20_encode_literals_with_options, EncodeOptions, Unpack20Encoder, +}; + +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; +use std::io::{Read, Write}; + +const MAIN_COUNT: usize = 298; +const OFFSET_COUNT: usize = 48; +const LENGTH_COUNT: usize = 28; +const LEVEL_COUNT: usize = 19; +const TABLE_COUNT: usize = MAIN_COUNT + OFFSET_COUNT + LENGTH_COUNT; +const AUDIO_COUNT: usize = 257; +const MAX_CHANNELS: usize = 4; +const OLD_LEVEL_COUNT: usize = AUDIO_COUNT * MAX_CHANNELS; +const MAX_HISTORY: usize = 1024 * 1024; + +const LENGTH_BASES: [usize; LENGTH_COUNT] = [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, + 160, 192, 224, +]; +const LENGTH_BITS: [u8; LENGTH_COUNT] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, +]; +const OFFSET_BASES: [usize; OFFSET_COUNT] = [ + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, + 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152, 65536, 98304, 131072, 196608, + 262144, 327680, 393216, 458752, 524288, 589824, 655360, 720896, 786432, 851968, 917504, 983040, +]; +const OFFSET_BITS: [u8; OFFSET_COUNT] = [ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, + 13, 14, 14, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +]; +const SHORT_BASES: [usize; 8] = [0, 4, 8, 16, 32, 64, 128, 192]; +const SHORT_BITS: [u8; 8] = [2, 2, 3, 4, 5, 6, 6, 6]; + +pub fn unpack20_decode(input: &[u8], output_size: usize) -> Result> { + let mut decoder = Unpack20::new(); + decoder.decode_member(input, output_size) +} + +#[derive(Debug, Clone)] +pub struct Unpack20 { + pub(crate) read_control: crate::read_control::ReadControl, + state: Reader20State, +} +impl Clone for Reader20State { + fn clone(&self) -> Self { + self.try_clone().expect("unlimited legacy decoder copy") + } +} +impl Unpack20 { + pub fn new() -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + state: Reader20State::with_allowance(&Allowance::default()), + } + } + pub fn decode_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_owned(input, output_size) + .map(Buffer::into_vec) + } + pub fn decode_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state.decode_member_to(input, output_size, out) + } + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader(input, output_size, out) + } +} +#[cfg(all(test, feature = "write"))] +impl Reader20State { + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } + fn decode_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.decode_member_owned(input, output_size) + .map(Buffer::into_vec) + } +} +#[derive(Debug)] +pub(crate) struct Reader20State { + pub(crate) read_control: crate::read_control::ReadControl, + bits: BitReader, + levels: [u8; OLD_LEVEL_COUNT], + main: Huffman, + offsets: Huffman, + lengths: Huffman, + audio_tables: [Huffman; MAX_CHANNELS], + audio_block: bool, + channels: usize, + cur_channel: usize, + audio: [AudioState; MAX_CHANNELS], + channel_delta: i32, + old_offsets: [usize; 4], + last_offset: usize, + last_length: usize, + pending_match: Option<(usize, usize)>, + in_block: bool, + output: Buffer, + base_offset: usize, +} + +impl Reader20State { + pub(crate) fn with_allowance(allowance: &B) -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + bits: BitReader::with_allowance(allowance), + levels: [0; OLD_LEVEL_COUNT], + main: Huffman::with_allowance(allowance), + offsets: Huffman::with_allowance(allowance), + lengths: Huffman::with_allowance(allowance), + audio_tables: std::array::from_fn(|_| Huffman::with_allowance(allowance)), + audio_block: false, + channels: 1, + cur_channel: 0, + audio: [AudioState::default(); MAX_CHANNELS], + channel_delta: 0, + old_offsets: [0; 4], + last_offset: 0, + last_length: 0, + pending_match: None, + in_block: false, + output: Buffer::new(allowance), + base_offset: 0, + } + } + + pub(crate) fn try_clone(&self) -> Result { + Ok(Self { + read_control: self.read_control.clone(), + bits: self.bits.try_clone()?, + levels: self.levels, + main: self.main.try_clone()?, + offsets: self.offsets.try_clone()?, + lengths: self.lengths.try_clone()?, + audio_tables: [ + self.audio_tables[0].try_clone()?, + self.audio_tables[1].try_clone()?, + self.audio_tables[2].try_clone()?, + self.audio_tables[3].try_clone()?, + ], + audio_block: self.audio_block, + channels: self.channels, + cur_channel: self.cur_channel, + audio: self.audio, + channel_delta: self.channel_delta, + old_offsets: self.old_offsets, + last_offset: self.last_offset, + last_length: self.last_length, + pending_match: self.pending_match, + in_block: self.in_block, + output: Buffer::copied(&self.output, &self.output.allowance())?, + base_offset: self.base_offset, + }) + } + pub fn decode_member_owned( + &mut self, + input: &[u8], + output_size: usize, + ) -> Result> { + self.read_control.check_codec()?; + let start = self.current_pos(); + let target = start + .checked_add(output_size) + .ok_or(Error::InvalidData("RAR 2.0 output size overflows"))?; + if !input.is_empty() { + self.bits = BitReader::with_allowance(&self.output.allowance()); + } + self.bits.append(input)?; + self.decode_until(target).map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.0 bitstream is truncated"), + error => error, + })?; + self.read_last_tables()?; + let out = Buffer::copied(self.raw_range(start, target), &self.output.allowance())?; + self.trim_history(target, target); + Ok(out) + } + + pub fn decode_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + let decoded = self.decode_member_owned(input, output_size)?; + out.write_all(&decoded).map_err(Error::from) + } + + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + let start = self.current_pos(); + let target = start + .checked_add(output_size) + .ok_or(Error::InvalidData("RAR 2.0 output size overflows"))?; + self.bits = BitReader::with_allowance(&self.output.allowance()); + self.bits.input.read_to_end(input)?; + if !self.in_block && self.bits.remaining_bytes_from_current() > 0 { + self.read_tables().map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.0 bitstream is truncated"), + error => error, + })?; + self.in_block = true; + } + self.decode_until(target).map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.0 bitstream is truncated"), + error => error, + })?; + self.read_last_tables()?; + + let decoded = self.raw_range(start, target); + out.write_all(decoded).map_err(Error::from)?; + self.trim_history(target, target); + Ok(()) + } + + fn decode_until(&mut self, target: usize) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.current_pos() < target { + poller.check_codec(self.current_pos())?; + self.drain_pending_match(target)?; + if self.current_pos() >= target { + break; + } + if !self.in_block { + self.read_tables()?; + self.in_block = true; + } + self.decode_lz(target)?; + } + Ok(()) + } + + fn read_tables(&mut self) -> Result<()> { + let bit_field = self.bits.peek_bits(16)?; + self.audio_block = bit_field & 0x8000 != 0; + let keep_tables = bit_field & 0x4000 != 0; + self.bits.read_bits(2)?; + if !keep_tables { + self.levels = [0; OLD_LEVEL_COUNT]; + } + + let table_size = if self.audio_block { + self.channels = ((bit_field >> 12) as usize & 3) + 1; + if self.cur_channel >= self.channels { + self.cur_channel = 0; + } + self.bits.read_bits(2)?; + AUDIO_COUNT * self.channels + } else { + TABLE_COUNT + }; + + let level_lengths = Self::read_level_lengths(&mut self.bits)?; + let level_decoder = Huffman::with_lengths(&level_lengths, &self.output.allowance())?; + let mut new_levels = [0u8; OLD_LEVEL_COUNT]; + let mut pos = 0usize; + while pos < table_size { + let symbol = level_decoder.decode(&mut self.bits)?; + match symbol { + 0..=15 => { + new_levels[pos] = (self.levels[pos].wrapping_add(symbol as u8)) & 0x0f; + pos += 1; + } + 16 => { + if pos == 0 { + return Err(Error::InvalidData("RAR 2.0 table repeat at start")); + } + let count = 3 + self.bits.read_bits(2)? as usize; + let value = new_levels[pos - 1]; + fill_levels(&mut new_levels, &mut pos, count, value)?; + } + 17 => { + let count = 3 + self.bits.read_bits(3)? as usize; + fill_levels(&mut new_levels, &mut pos, count, 0)?; + } + _ => { + // 18: the pre-table contains exactly 19 symbols. + let count = 11 + self.bits.read_bits(7)? as usize; + fill_levels(&mut new_levels, &mut pos, count, 0)?; + } + } + } + + self.levels = new_levels; + if self.audio_block { + for channel in 0..self.channels { + let start = channel * AUDIO_COUNT; + self.audio_tables[channel] = Huffman::with_lengths( + &self.levels[start..start + AUDIO_COUNT], + &self.output.allowance(), + )?; + } + } else { + self.main = + Huffman::with_lengths(&self.levels[..MAIN_COUNT], &self.output.allowance())?; + self.offsets = Huffman::with_lengths( + &self.levels[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT], + &self.output.allowance(), + )?; + self.lengths = Huffman::with_lengths( + &self.levels[MAIN_COUNT + OFFSET_COUNT..TABLE_COUNT], + &self.output.allowance(), + )?; + } + Ok(()) + } + + fn read_level_lengths(bits: &mut BitReader) -> Result<[u8; LEVEL_COUNT]> { + let mut lengths = [0u8; LEVEL_COUNT]; + for length in &mut lengths { + *length = bits.read_bits(4)? as u8; + } + Ok(lengths) + } + + fn decode_lz(&mut self, output_size: usize) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.current_pos() < output_size { + poller.check_codec(self.current_pos())?; + if self.audio_block { + self.decode_audio_byte()?; + if !self.in_block { + return Ok(()); + } + continue; + } + let symbol = self.main.decode(&mut self.bits)?; + match symbol { + 0..=255 => self.output.try_push(symbol as u8)?, + 256 => { + if self.last_length != 0 { + let length = self.last_length; + let offset = self.last_offset; + self.push_old_offset(offset); + self.copy_match(length, offset, output_size)?; + } + } + 257..=260 => { + let index = symbol - 257; + let offset = self.old_offsets[index]; + let length_slot = self.lengths.decode(&mut self.bits)?; + let mut length = LENGTH_BASES[length_slot] + 2; + if LENGTH_BITS[length_slot] != 0 { + length += self.bits.read_bits(LENGTH_BITS[length_slot])? as usize; + } + if offset >= 0x101 { + length += 1; + } + if offset >= 0x2000 { + length += 1; + } + if offset >= 0x40000 { + length += 1; + } + self.push_old_offset(offset); + self.last_offset = offset; + self.last_length = length; + self.copy_match(length, offset, output_size)?; + } + 261..=268 => { + let index = symbol - 261; + let mut offset = SHORT_BASES[index] + 1; + offset += self.bits.read_bits(SHORT_BITS[index])? as usize; + self.push_old_offset(offset); + self.last_offset = offset; + self.last_length = 2; + self.copy_match(2, offset, output_size)?; + } + 269 => { + self.in_block = false; + return Ok(()); + } + _ => { + // 270..=297: the main table contains exactly 298 symbols. + let length_slot = symbol - 270; + let mut length = LENGTH_BASES[length_slot] + 3; + if LENGTH_BITS[length_slot] != 0 { + length += self.bits.read_bits(LENGTH_BITS[length_slot])? as usize; + } + let offset = self.read_offset()?; + if offset >= 0x2000 { + length += 1; + } + if offset >= 0x40000 { + length += 1; + } + self.push_old_offset(offset); + self.last_offset = offset; + self.last_length = length; + self.copy_match(length, offset, output_size)?; + } + } + } + Ok(()) + } + + fn decode_audio_byte(&mut self) -> Result<()> { + let symbol = self.audio_tables[self.cur_channel].decode(&mut self.bits)?; + if symbol == 256 { + self.in_block = false; + return Ok(()); + } + let byte = self.decode_audio(symbol as u8); + self.output.try_push(byte)?; + self.cur_channel += 1; + if self.cur_channel == self.channels { + self.cur_channel = 0; + } + Ok(()) + } + + fn decode_audio(&mut self, delta: u8) -> u8 { + let state = &mut self.audio[self.cur_channel]; + state.byte_count = state.byte_count.wrapping_add(1); + state.d4 = state.d3; + state.d3 = state.d2; + state.d2 = state.last_delta - state.d1; + state.d1 = state.last_delta; + + let predicted = 8 * state.last_char + + state.k[0] * state.d1 + + state.k[1] * state.d2 + + state.k[2] * state.d3 + + state.k[3] * state.d4 + + state.k[4] * self.channel_delta; + let predicted = (predicted >> 3) & 0xff; + let byte = predicted.wrapping_sub(delta as i32) as u8; + + let d = (delta as i8 as i32) << 3; + state.dif[0] = state.dif[0].wrapping_add(d.unsigned_abs()); + state.dif[1] = state.dif[1].wrapping_add((d - state.d1).unsigned_abs()); + state.dif[2] = state.dif[2].wrapping_add((d + state.d1).unsigned_abs()); + state.dif[3] = state.dif[3].wrapping_add((d - state.d2).unsigned_abs()); + state.dif[4] = state.dif[4].wrapping_add((d + state.d2).unsigned_abs()); + state.dif[5] = state.dif[5].wrapping_add((d - state.d3).unsigned_abs()); + state.dif[6] = state.dif[6].wrapping_add((d + state.d3).unsigned_abs()); + state.dif[7] = state.dif[7].wrapping_add((d - state.d4).unsigned_abs()); + state.dif[8] = state.dif[8].wrapping_add((d + state.d4).unsigned_abs()); + state.dif[9] = state.dif[9].wrapping_add((d - self.channel_delta).unsigned_abs()); + state.dif[10] = state.dif[10].wrapping_add((d + self.channel_delta).unsigned_abs()); + + self.channel_delta = (byte.wrapping_sub(state.last_char as u8)) as i8 as i32; + state.last_delta = self.channel_delta; + state.last_char = byte as i32; + + if state.byte_count & 0x1f == 0 { + let mut min_dif = state.dif[0]; + let mut num_min_dif = 0usize; + state.dif[0] = 0; + for index in 1..state.dif.len() { + if state.dif[index] < min_dif { + min_dif = state.dif[index]; + num_min_dif = index; + } + state.dif[index] = 0; + } + match num_min_dif { + 1 if state.k[0] >= -16 => state.k[0] -= 1, + 2 if state.k[0] < 16 => state.k[0] += 1, + 3 if state.k[1] >= -16 => state.k[1] -= 1, + 4 if state.k[1] < 16 => state.k[1] += 1, + 5 if state.k[2] >= -16 => state.k[2] -= 1, + 6 if state.k[2] < 16 => state.k[2] += 1, + 7 if state.k[3] >= -16 => state.k[3] -= 1, + 8 if state.k[3] < 16 => state.k[3] += 1, + 9 if state.k[4] >= -16 => state.k[4] -= 1, + 10 if state.k[4] < 16 => state.k[4] += 1, + _ => {} + } + } + + byte + } + + fn read_offset(&mut self) -> Result { + let slot = self.offsets.decode(&mut self.bits)?; + let mut offset = OFFSET_BASES[slot] + 1; + if OFFSET_BITS[slot] != 0 { + offset += self.bits.read_bits(OFFSET_BITS[slot])? as usize; + } + Ok(offset) + } + + fn copy_match(&mut self, length: usize, offset: usize, output_size: usize) -> Result<()> { + let offset = if offset == 0 { 1 } else { offset }; + // A match reaching past the start of the stream writes zeroes rather + // than failing. WinRAR never clears its window and guards the copy + // with a first-wrap flag instead, so those bytes read as zero there, + // and an archive that leans on it stays readable here. The decision + // is taken once for the whole match, as it is there: a copy does not + // start on zeroes and cross into real bytes partway. + let before_window = offset > self.current_pos(); + for index in 0..length { + if self.current_pos() >= output_size { + self.pending_match = Some((length - index, offset)); + break; + } + let byte = if before_window { + 0 + } else { + let src = self.current_pos() - offset; + self.raw_byte(src) + }; + self.output.try_push(byte)?; + } + Ok(()) + } + + fn drain_pending_match(&mut self, output_size: usize) -> Result<()> { + let Some((length, offset)) = self.pending_match.take() else { + return Ok(()); + }; + self.copy_match(length, offset, output_size)?; + Ok(()) + } + + fn read_last_tables(&mut self) -> Result<()> { + if self.bits.remaining_bytes_from_current() < 5 { + return Ok(()); + } + if self.audio_block { + if self.audio_tables[self.cur_channel].state.is_empty() { + return Ok(()); + } + if self.audio_tables[self.cur_channel].decode(&mut self.bits)? == 256 { + self.read_tables()?; + self.in_block = true; + } + } else { + if self.main.state.is_empty() { + return Ok(()); + } + if self.main.decode(&mut self.bits)? == 269 { + self.read_tables()?; + self.in_block = true; + } + } + Ok(()) + } + + fn push_old_offset(&mut self, offset: usize) { + self.old_offsets[3] = self.old_offsets[2]; + self.old_offsets[2] = self.old_offsets[1]; + self.old_offsets[1] = self.old_offsets[0]; + self.old_offsets[0] = offset; + } + + fn current_pos(&self) -> usize { + self.base_offset + self.output.len() + } + + fn raw_byte(&self, position: usize) -> u8 { + // Decoder offsets are at most MAX_HISTORY; trimming retains that window. + self.output[position - self.base_offset] + } + + fn raw_range(&self, start: usize, end: usize) -> &[u8] { + // Callers take the range before trimming the completed member. + let rel_start = start - self.base_offset; + let rel_end = end - self.base_offset; + &self.output[rel_start..rel_end] + } + + fn trim_history(&mut self, flushed_pos: usize, current_pos: usize) { + let keep_from = current_pos.saturating_sub(MAX_HISTORY).min(flushed_pos); + if keep_from <= self.base_offset { + return; + } + let drain = keep_from - self.base_offset; + self.output.discard_prefix(drain); + self.base_offset = keep_from; + } +} + +impl Default for Unpack20 { + fn default() -> Self { + Self::new() + } +} + +#[derive(Debug, Clone, Copy, Default)] +struct AudioState { + k: [i32; 5], + d1: i32, + d2: i32, + d3: i32, + d4: i32, + last_delta: i32, + last_char: i32, + byte_count: u32, + dif: [u32; 11], +} + +fn fill_levels(levels: &mut [u8], pos: &mut usize, count: usize, value: u8) -> Result<()> { + let end = pos + .checked_add(count) + .ok_or(Error::InvalidData("RAR 2.0 table run overflows"))?; + let end = end.min(levels.len()); + for item in &mut levels[*pos..end] { + *item = value; + } + *pos = end; + Ok(()) +} + +#[derive(Debug)] +struct Huffman { + state: super::canonical::Huffman, +} + +impl Huffman { + fn with_allowance(allowance: &B) -> Self { + Self { + state: super::canonical::Huffman::with_allowance(allowance), + } + } + fn with_lengths(lengths: &[u8], allowance: &B) -> Result { + let mut count = [0u16; 16]; + for &len in lengths { + if len > 15 { + return Err(Error::InvalidData("RAR 2.0 Huffman length is too large")); + } + if len != 0 { + count[len as usize] += 1; + } + } + if count.iter().all(|&value| value == 0) { + return Ok(Self::with_allowance(allowance)); + } + validate_huffman_counts(&count)?; + + Ok(Self { + state: super::canonical::Huffman::from_counts(lengths, count, allowance)?, + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + state: self.state.try_clone()?, + }) + } + fn decode(&self, bits: &mut BitReader) -> Result { + self.state.decode( + || bits.read_bit().map(|bit| bit as u16), + "RAR 2.0 empty Huffman table", + "RAR 2.0 invalid Huffman code", + ) + } +} + +#[cfg(all(test, feature = "write"))] +impl Huffman { + fn from_lengths(lengths: &[u8]) -> Result { + Self::with_lengths(lengths, &Allowance::default()) + } +} + +fn validate_huffman_counts(count: &[u16; 16]) -> Result<()> { + super::canonical::validate_counts(count, "RAR 2.0 oversubscribed Huffman table") +} + +#[derive(Debug)] +struct BitReader { + input: Buffer, + bit_pos: usize, +} + +impl BitReader { + fn with_allowance(allowance: &B) -> Self { + Self { + input: Buffer::new(allowance), + bit_pos: 0, + } + } + + fn try_clone(&self) -> Result { + Ok(Self { + input: Buffer::copied(&self.input, &self.input.allowance())?, + bit_pos: self.bit_pos, + }) + } + fn append(&mut self, input: &[u8]) -> Result<()> { + self.compact(); + self.input.extend_from_slice(input).map_err(Into::into) + } + + fn compact(&mut self) { + let bytes = self.bit_pos / 8; + if bytes == 0 { + return; + } + self.input.discard_prefix(bytes); + self.bit_pos -= bytes * 8; + } + + fn read_bit(&mut self) -> Result { + self.read_bits(1).map(|value| value as u8) + } + + fn read_bits(&mut self, count: u8) -> Result { + let value = self.peek_bits(count)?; + self.bit_pos += count as usize; + Ok(value) + } + + fn peek_bits(&self, count: u8) -> Result { + if count > 24 { + return Err(Error::InvalidData("RAR 2.0 bit read is too wide")); + } + let mut value = 0u32; + for i in 0..count as usize { + let bit_index = self.bit_pos + i; + let byte = *self.input.get(bit_index / 8).ok_or(Error::NeedMoreInput)?; + let bit = (byte >> (7 - (bit_index % 8))) & 1; + value = (value << 1) | bit as u32; + } + Ok(value) + } + + fn remaining_bytes_from_current(&self) -> usize { + self.input.len().saturating_sub(self.bit_pos / 8) + } +} + +#[cfg(all(test, feature = "write"))] +impl BitReader { + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar20/encoder.rs b/arca-rar/vendor/rars/src/codec/rar20/encoder.rs new file mode 100644 index 00000000..89a69531 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar20/encoder.rs @@ -0,0 +1,1533 @@ +//! RAR20 member encoding and bit emission. +use super::super::{huffman, match_finder}; +use super::*; + +const MAX_ENCODER_MATCH_OFFSET: usize = MAX_HISTORY; + +const MAX_ENCODER_MATCH_LENGTH: usize = 258; + +const MAX_MATCH_CANDIDATES: usize = 256; + +type Rar20MatchFinder = match_finder::MatchFinder<3>; + +pub fn unpack20_encode_literals(input: &[u8]) -> Result> { + unpack20_encode_literals_with_options(input, EncodeOptions::default()) +} + +pub fn unpack20_encode_literals_with_options( + input: &[u8], + options: EncodeOptions, +) -> Result> { + encode_member(input, &[], None, options, None) +} + +pub fn unpack20_encode_auto(input: &[u8]) -> Result> { + unpack20_encode_auto_with_options(input, EncodeOptions::default()) +} + +pub fn unpack20_encode_auto_with_options(input: &[u8], options: EncodeOptions) -> Result> { + let lz = unpack20_encode_literals_with_options(input, options)?; + let mut best = lz; + if options.try_audio { + for channels in 1..=MAX_CHANNELS { + if input.len() < channels * 64 { + continue; + } + let audio = encode_audio_member(input, channels)?; + if audio.len() < best.len() { + best = audio; + } + } + } + Ok(best) +} + +pub(crate) fn unpack20_encode_auto_with_options_and_progress( + input: &[u8], + options: EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + let mut best = encode_member(input, &[], None, options, Some(progress))?; + if options.try_audio { + for channels in 1..=MAX_CHANNELS { + if input.len() < channels * 64 { + continue; + } + let audio = encode_audio_member(input, channels)?; + if audio.len() < best.len() { + best = audio; + } + } + } + Ok(best) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct EncodeOptions { + pub max_match_candidates: usize, + pub max_match_distance: usize, + pub lazy_matching: bool, + pub lazy_lookahead: usize, + /// Parse by shortest path rather than greedily. Costs several times the + /// encode time, so it belongs at the top of the level ladder. + pub optimal_parse: bool, + pub try_audio: bool, +} + +impl EncodeOptions { + pub const fn new(max_match_candidates: usize) -> Self { + Self { + max_match_candidates, + max_match_distance: MAX_ENCODER_MATCH_OFFSET, + lazy_matching: false, + lazy_lookahead: 1, + optimal_parse: false, + try_audio: true, + } + } + + pub const fn with_max_match_distance(mut self, distance: usize) -> Self { + self.max_match_distance = if distance > MAX_ENCODER_MATCH_OFFSET { + MAX_ENCODER_MATCH_OFFSET + } else { + distance + }; + self + } + + pub const fn with_lazy_matching(mut self, enabled: bool) -> Self { + self.lazy_matching = enabled; + self + } + + pub const fn with_optimal_parse(mut self, enabled: bool) -> Self { + self.optimal_parse = enabled; + self + } + + pub const fn with_lazy_lookahead(mut self, bytes: usize) -> Self { + self.lazy_lookahead = bytes; + self + } + + pub const fn with_try_audio(mut self, enabled: bool) -> Self { + self.try_audio = enabled; + self + } + + const fn constrained(mut self) -> Self { + if self.max_match_distance > MAX_ENCODER_MATCH_OFFSET { + self.max_match_distance = MAX_ENCODER_MATCH_OFFSET; + } + self + } +} + +impl Default for EncodeOptions { + fn default() -> Self { + Self::new(MAX_MATCH_CANDIDATES) + } +} + +#[derive(Debug, Clone, Default)] +pub struct Unpack20Encoder { + history: Vec, + table: Option, + options: EncodeOptions, +} + +impl Unpack20Encoder { + pub fn new() -> Self { + Self::default() + } + + pub fn with_options(options: EncodeOptions) -> Self { + Self { + history: Vec::new(), + table: None, + options: options.constrained(), + } + } + + pub fn encode_member(&mut self, input: &[u8]) -> Result> { + self.encode_member_inner(input, None) + } + + pub(crate) fn encode_member_with_progress( + &mut self, + input: &[u8], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result> { + self.encode_member_inner(input, Some(progress)) + } + + fn encode_member_inner( + &mut self, + input: &[u8], + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + if input.is_empty() { + return Ok(Vec::new()); + } + let table = match self.table { + Some(table) => table, + None => { + let table = FixedEncodeTable::new()?; + self.table = Some(table); + table + } + }; + let packed = encode_member(input, &self.history, Some(table), self.options, progress)?; + self.remember(input); + Ok(packed) + } + + fn remember(&mut self, input: &[u8]) { + self.history.extend_from_slice(input); + let keep_from = self + .history + .len() + .saturating_sub(self.options.max_match_distance); + if keep_from != 0 { + self.history.drain(..keep_from); + } + } +} + +fn encode_member( + input: &[u8], + history: &[u8], + fixed_table: Option, + options: EncodeOptions, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + if input.is_empty() { + return Ok(Vec::new()); + } + // The public field can be assigned directly, bypassing the builder clamp. + let options = options.constrained(); + + let tokens = match progress.as_mut() { + Some(report) => { + encode_tokens_with_progress(input, history, options, None, Some(&mut **report))? + } + None => encode_tokens_with_progress(input, history, options, None, None)?, + }; + let table_lengths = table_lengths_for_tokens(&tokens, fixed_table)?; + let packed = encode_member_with_tables(&tokens, history, fixed_table, &table_lengths)?; + if fixed_table.is_some() { + return Ok(packed); + } + + // Re-parse against the prices the first pass implies, then again against + // the prices that produced. A greedy parse has converged by the first + // re-parse and a second buys 0.02%, but the shortest-path parse is far more + // sensitive to its prices and a second pass is worth 0.12% to it. + let refinements = if options.optimal_parse { 2 } else { 1 }; + let mut best_tokens = tokens; + let mut best_table = table_lengths; + let mut best_packed = packed; + for _ in 0..refinements { + let cost_model = CostModel::new(&best_table); + let next_tokens = match progress.as_mut() { + Some(report) => encode_tokens_with_progress( + input, + history, + options, + Some(&cost_model), + Some(&mut **report), + )?, + None => encode_tokens_with_progress(input, history, options, Some(&cost_model), None)?, + }; + if next_tokens == best_tokens { + break; + } + let next_table = table_lengths_for_tokens(&next_tokens, fixed_table)?; + let next_packed = + encode_member_with_tables(&next_tokens, history, fixed_table, &next_table)?; + if next_packed.len() >= best_packed.len() { + break; + } + best_tokens = next_tokens; + best_table = next_table; + best_packed = next_packed; + } + Ok(best_packed) +} + +fn table_lengths_for_tokens( + tokens: &[EncodeToken], + fixed_table: Option, +) -> Result<[u8; TABLE_COUNT]> { + let mut main_frequencies = [0usize; MAIN_COUNT]; + let mut offset_frequencies = [0usize; OFFSET_COUNT]; + let mut length_frequencies = [0usize; LENGTH_COUNT]; + for token in tokens { + match *token { + EncodeToken::Literal(byte) => main_frequencies[byte as usize] += 1, + EncodeToken::RepeatLast => main_frequencies[256] += 1, + EncodeToken::OldOffset { + index, + length, + offset, + } => { + main_frequencies[257 + index] += 1; + let (slot, _) = old_length_slot_for_match(length, offset)?; + length_frequencies[slot] += 1; + } + EncodeToken::ShortOffset { offset } => { + let (slot, _) = short_slot_for_match(offset)?; + main_frequencies[261 + slot] += 1; + } + EncodeToken::Match { length, offset } => { + let encoded_length = length - match_length_adjustment(offset); + let (slot, _) = length_slot_for_match(encoded_length)?; + main_frequencies[270 + slot] += 1; + let (offset_slot, _) = offset_slot_for_match(offset)?; + offset_frequencies[offset_slot] += 1; + } + } + } + let mut table_lengths = [0u8; TABLE_COUNT]; + let literal_len = if let Some(table) = fixed_table { + table.length + } else { + let main_symbol_count = main_frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count() + + offset_frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count() + + length_frequencies + .iter() + .filter(|&&frequency| frequency != 0) + .count(); + literal_code_len(main_symbol_count) + }; + + if fixed_table.is_some() { + for len in &mut table_lengths[..256] { + *len = literal_len; + } + table_lengths[256] = literal_len; + for len in &mut table_lengths[270..270 + LENGTH_COUNT] { + *len = literal_len; + } + for len in &mut table_lengths[257..269] { + *len = literal_len; + } + for len in &mut table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT] { + *len = literal_len; + } + for len in &mut table_lengths[MAIN_COUNT + OFFSET_COUNT..TABLE_COUNT] { + *len = literal_len; + } + } else { + table_lengths[..MAIN_COUNT] + .copy_from_slice(&huffman::lengths_for_frequency_array(&main_frequencies, 15)); + table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT].copy_from_slice( + &huffman::lengths_for_frequency_array(&offset_frequencies, 15), + ); + table_lengths[MAIN_COUNT + OFFSET_COUNT..TABLE_COUNT].copy_from_slice( + &huffman::lengths_for_frequency_array(&length_frequencies, 15), + ); + } + Ok(table_lengths) +} + +fn encode_member_with_tables( + tokens: &[EncodeToken], + history: &[u8], + fixed_table: Option, + table_lengths: &[u8; TABLE_COUNT], +) -> Result> { + let level_tokens = encode_table_level_tokens(table_lengths); + let level_lengths = level_code_lengths_for_tokens(&level_tokens); + let level_codes = canonical_codes(&level_lengths)?; + let main_codes = canonical_codes(&table_lengths[..MAIN_COUNT])?; + + let mut bits = BitWriter::default(); + if fixed_table.is_none() || history.is_empty() { + bits.write_bits(0, 2); // LZ block, do not keep previous tables. + for &len in &level_lengths { + bits.write_bits(len as u32, 4); + } + for token in level_tokens { + let code = level_codes[token.symbol].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing level Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + if token.extra_bits != 0 { + bits.write_bits(token.extra_value as u32, token.extra_bits); + } + } + } + let offset_codes = canonical_codes(&table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT])?; + let length_codes = canonical_codes(&table_lengths[MAIN_COUNT + OFFSET_COUNT..TABLE_COUNT])?; + for token in tokens { + match *token { + EncodeToken::Literal(byte) => { + let code = main_codes[byte as usize].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing literal Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + } + EncodeToken::RepeatLast => { + let code = main_codes[256].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing repeat-last Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + } + EncodeToken::OldOffset { + index, + length, + offset, + } => { + let code = main_codes[257 + index].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing old-offset Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + let (slot, extra) = old_length_slot_for_match(length, offset)?; + let length_code = length_codes[slot].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing old-offset length Huffman code", + ))?; + bits.write_bits(length_code.code as u32, length_code.len); + if LENGTH_BITS[slot] != 0 { + bits.write_bits(extra as u32, LENGTH_BITS[slot]); + } + } + EncodeToken::ShortOffset { offset } => { + let (slot, extra) = short_slot_for_match(offset)?; + let code = main_codes[261 + slot].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing short-offset Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + bits.write_bits(extra as u32, SHORT_BITS[slot]); + } + EncodeToken::Match { length, offset } => { + let encoded_length = length - match_length_adjustment(offset); + let (slot, extra) = length_slot_for_match(encoded_length)?; + let code = main_codes[270 + slot].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing match Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + if LENGTH_BITS[slot] != 0 { + bits.write_bits(extra as u32, LENGTH_BITS[slot]); + } + let (offset_slot, offset_extra) = offset_slot_for_match(offset)?; + let offset = offset_codes[offset_slot].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing offset Huffman code", + ))?; + bits.write_bits(offset.code as u32, offset.len); + if OFFSET_BITS[offset_slot] != 0 { + bits.write_bits(offset_extra as u32, OFFSET_BITS[offset_slot]); + } + } + } + } + Ok(bits.finish()) +} + +#[derive(Debug, Clone, Copy)] +struct FixedEncodeTable { + length: u8, +} + +impl FixedEncodeTable { + fn new() -> Result { + Ok(Self { + length: literal_code_len(256 + LENGTH_COUNT + OFFSET_COUNT), + }) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum EncodeToken { + Literal(u8), + RepeatLast, + OldOffset { + index: usize, + length: usize, + offset: usize, + }, + ShortOffset { + offset: usize, + }, + Match { + length: usize, + offset: usize, + }, +} + +/// Lengths worth trying for a match at one position. +/// +/// Every length inside a length slot is priced the same: the slot's Huffman +/// code plus its fixed extra bits, with the extra value itself costing nothing. +/// So the parse only needs the longest length in each slot, plus the longest +/// match found. That is at most twenty-nine candidates where trying every +/// length is up to two hundred and fifty-six, for 0.03% of packed size. +fn candidate_lengths(best_length: usize, offset: usize, out: &mut Vec) { + out.clear(); + let adjustment = match_length_adjustment(offset); + for slot in 0..LENGTH_COUNT { + let widest = LENGTH_BASES[slot] + (1usize << LENGTH_BITS[slot]) - 1; + let length = widest + 3 + adjustment; + if (3..=best_length).contains(&length) { + out.push(length); + } + } + // Callers only pass matches of at least three bytes. + out.push(best_length); + out.sort_unstable(); + out.dedup(); +} + +/// Parse the member by shortest path, priced by the previous pass's tables. +/// +/// The greedy parse commits to a match the moment it finds one, with a two +/// position lazy check as its only way out. This asks instead what the cheapest +/// route to the end of the member is, so a match that looks good on its own can +/// lose to one that leaves the positions after it cheaper. Worth about 0.9% on +/// the bench corpus, which is more than everything else tried put together. +/// +/// One approximation. The four recent offsets depend on the route taken, and +/// carrying every reachable rep state would multiply the search out of reach. +/// Each position keeps the rep list of the cheapest route that reached it, +/// which is what LZMA's optimal parser does with the same justification. +fn encode_tokens_optimal( + input: &[u8], + start: usize, + end: usize, + finder: &mut Rar20MatchFinder, + options: EncodeOptions, + cost_model: &CostModel<'_>, +) -> Vec { + const UNREACHED: u64 = u64::MAX / 4; + let span = end - start; + let mut cost = vec![UNREACHED; span + 1]; + let mut from = vec![0usize; span + 1]; + let mut token: Vec> = vec![None; span + 1]; + let mut reps = vec![[0usize; 4]; span + 1]; + let mut lengths = Vec::new(); + cost[0] = 0; + + for index in 0..span { + // Every position is reachable through the one-byte literal edge. + let pos = start + index; + let here = cost[index]; + let node_reps = reps[index]; + + let mut relax = |next: usize, price: u64, what: EncodeToken, next_reps: [usize; 4]| { + // Literal, fresh, old-offset and short-match edges all end within span. + if here + price < cost[next] { + cost[next] = here + price; + from[next] = index; + token[next] = Some(what); + reps[next] = next_reps; + } + }; + + relax( + index + 1, + cost_model.literal_bits(input, pos, 1) as u64, + EncodeToken::Literal(input[pos]), + node_reps, + ); + + let cap = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if let Some((best_length, offset)) = + best_match(input, pos, end, finder, options, Some(cost_model)) + { + let mut pushed = node_reps; + push_old_offset(&mut pushed, offset); + candidate_lengths(best_length.min(cap), offset, &mut lengths); + for &length in &lengths { + let candidate = SelectedMatch::Fresh { length, offset }; + if let Some(price) = cost_model.selected_cost(candidate) { + relax( + index + length, + price as u64, + EncodeToken::Match { length, offset }, + pushed, + ); + } + } + } + + for (rep_index, &offset) in node_reps.iter().enumerate() { + let reach = match_run_length(input, pos, offset, cap); + if reach < 3 { + continue; + } + let mut pushed = node_reps; + push_old_offset(&mut pushed, offset); + candidate_lengths(reach, offset, &mut lengths); + for &length in &lengths { + let candidate = SelectedMatch::OldOffset { + index: rep_index, + length, + offset, + }; + if let Some(price) = cost_model.selected_cost(candidate) { + relax( + index + length, + price as u64, + EncodeToken::OldOffset { + index: rep_index, + length, + offset, + }, + pushed, + ); + } + } + } + + if let Some(SelectedMatch::ShortOffset { offset }) = + best_short_offset_match(input, pos, end) + { + let slot = short_slot_index(offset); + let price = usize::from(cost_model.main[261 + slot]) + usize::from(SHORT_BITS[slot]); + let mut pushed = node_reps; + push_old_offset(&mut pushed, offset); + relax( + index + 2, + price as u64, + EncodeToken::ShortOffset { offset }, + pushed, + ); + } + + finder.insert(input, pos); + } + + let mut out = Vec::new(); + let mut at = span; + while at > 0 { + let what = token[at].expect("every parse position has a literal edge"); + out.push(what); + at = from[at]; + } + out.reverse(); + out +} + +/// How far the bytes at `pos` repeat the bytes `offset` back, up to `cap`. +fn match_run_length(input: &[u8], pos: usize, offset: usize, cap: usize) -> usize { + if offset == 0 { + return 0; + } + let mut length = 0; + while length < cap && input[pos + length] == input[pos - offset + length] { + length += 1; + } + length +} + +fn encode_tokens_with_progress( + input: &[u8], + history: &[u8], + options: EncodeOptions, + cost_model: Option<&CostModel>, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let mut tokens = Vec::new(); + let history = &history[history.len().saturating_sub(options.max_match_distance)..]; + let mut combined = Vec::with_capacity(history.len() + input.len()); + combined.extend_from_slice(history); + combined.extend_from_slice(input); + let mut finder = Rar20MatchFinder::new(combined.len()); + for history_pos in 0..history.len() { + finder.insert(&combined, history_pos); + } + + if let Some(cost_model) = cost_model.filter(|_| options.optimal_parse) { + let start = history.len(); + let end = combined.len(); + return Ok(encode_tokens_optimal( + &combined, + start, + end, + &mut finder, + options, + cost_model, + )); + } + + let mut pos = history.len(); + let end = combined.len(); + let mut last_match = None; + let mut old_offsets = [0usize; 4]; + let mut next_report = 0usize; + while pos < end { + let selected = select_match( + &combined, + pos, + end, + &finder, + options, + &old_offsets, + cost_model, + ); + if let Some(selected) = selected { + let lazy = LazyMatchContext { + input: &combined, + end, + finder: &finder, + options, + old_offsets: &old_offsets, + cost_model, + }; + if should_lazy_emit_literal(pos, selected, lazy) { + tokens.push(EncodeToken::Literal(combined[pos])); + finder.insert(&combined, pos); + pos += 1; + continue; + } + let (length, offset) = match selected { + SelectedMatch::Fresh { length, offset } => { + if last_match == Some((length, offset)) { + tokens.push(EncodeToken::RepeatLast); + } else { + tokens.push(EncodeToken::Match { length, offset }); + last_match = Some((length, offset)); + } + (length, offset) + } + SelectedMatch::OldOffset { + index, + length, + offset, + } => { + if last_match == Some((length, offset)) { + tokens.push(EncodeToken::RepeatLast); + } else { + tokens.push(EncodeToken::OldOffset { + index, + length, + offset, + }); + last_match = Some((length, offset)); + } + (length, offset) + } + SelectedMatch::ShortOffset { offset } => { + let length = 2; + tokens.push(EncodeToken::ShortOffset { offset }); + last_match = Some((length, offset)); + (length, offset) + } + }; + push_old_offset(&mut old_offsets, offset); + for history_pos in pos..pos + length { + finder.insert(&combined, history_pos); + } + pos += length; + } else { + tokens.push(EncodeToken::Literal(combined[pos])); + finder.insert(&combined, pos); + pos += 1; + } + let consumed = pos.saturating_sub(history.len()); + if consumed >= next_report { + if progress + .as_deref_mut() + .is_some_and(|report| !report(consumed)) + { + return Err(Error::Cancelled); + } + next_report = consumed.saturating_add(1024 * 1024); + } + } + if progress.is_some_and(|report| !report(input.len())) { + return Err(Error::Cancelled); + } + Ok(tokens) +} + +/// Stand-in price for a literal the current table has no code for. +const ABSENT_LITERAL_BITS: usize = 15; + +#[derive(Debug, Clone, Copy)] +struct CostModel<'a> { + main: &'a [u8], + offsets: &'a [u8], + lengths: &'a [u8], +} + +impl<'a> CostModel<'a> { + fn new(table_lengths: &'a [u8; TABLE_COUNT]) -> Self { + Self { + main: &table_lengths[..MAIN_COUNT], + offsets: &table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT], + lengths: &table_lengths[MAIN_COUNT + OFFSET_COUNT..TABLE_COUNT], + } + } + + fn selected_cost(self, selected: SelectedMatch) -> Option { + match selected { + SelectedMatch::Fresh { length, offset } => { + let encoded_length = length.checked_sub(match_length_adjustment(offset))?; + let (length_slot, _) = length_slot_for_match(encoded_length).ok()?; + let (offset_slot, _) = offset_slot_for_match(offset).ok()?; + Some( + usize::from(self.main[270 + length_slot]) + + usize::from(LENGTH_BITS[length_slot]) + + usize::from(self.offsets[offset_slot]) + + usize::from(OFFSET_BITS[offset_slot]), + ) + } + SelectedMatch::OldOffset { + index, + length, + offset, + } => { + let (length_slot, _) = old_length_slot_for_match(length, offset).ok()?; + Some( + usize::from(self.main[257 + index]) + + usize::from(self.lengths[length_slot]) + + usize::from(LENGTH_BITS[length_slot]), + ) + } + SelectedMatch::ShortOffset { offset } => { + let (slot, _) = short_slot_for_match(offset).ok()?; + Some(usize::from(self.main[261 + slot]) + usize::from(SHORT_BITS[slot])) + } + } + } + + /// What these bytes cost spelled out one literal at a time, in bits. + /// + /// A symbol the previous pass never emitted as a literal has no code, so it + /// cannot be spelled that way at all. Price it high rather than free. + fn literal_bits(self, input: &[u8], pos: usize, length: usize) -> usize { + input[pos..(pos + length).min(input.len())] + .iter() + .map(|&byte| match self.main[usize::from(byte)] { + 0 => ABSENT_LITERAL_BITS, + bits => usize::from(bits), + }) + .sum() + } + + /// Bits saved by taking this match instead of the literals it covers. + /// + /// The literals are priced from the table rather than assumed to be eight + /// bits each. On text they run nearer four, so a flat eight overstates what + /// every match is worth by around half. + fn selected_score(self, selected: SelectedMatch, input: &[u8], pos: usize) -> Option { + let cost = self.selected_cost(selected)?; + let saved = self.literal_bits(input, pos, selected.length()); + Some(saved as isize - cost as isize) + } +} + +#[derive(Debug, Clone, Copy)] +enum SelectedMatch { + Fresh { + length: usize, + offset: usize, + }, + OldOffset { + index: usize, + length: usize, + offset: usize, + }, + ShortOffset { + offset: usize, + }, +} + +impl SelectedMatch { + fn length(self) -> usize { + match self { + SelectedMatch::Fresh { length, .. } | SelectedMatch::OldOffset { length, .. } => length, + SelectedMatch::ShortOffset { .. } => 2, + } + } + + fn score(self) -> isize { + let length_score = self.length() as isize * 8; + let cost = match self { + SelectedMatch::OldOffset { .. } | SelectedMatch::ShortOffset { .. } => 4, + SelectedMatch::Fresh { offset, .. } => 8 + OFFSET_BITS[offset_slot_index(offset)], + }; + length_score - isize::from(cost) + } +} + +fn select_match( + input: &[u8], + pos: usize, + end: usize, + finder: &Rar20MatchFinder, + options: EncodeOptions, + old_offsets: &[usize; 4], + cost_model: Option<&CostModel<'_>>, +) -> Option { + let fresh = best_match(input, pos, end, finder, options, cost_model); + let old = best_old_offset_match(input, pos, end, old_offsets, cost_model); + if let Some(cost_model) = cost_model { + return [ + fresh.map(|(length, offset)| SelectedMatch::Fresh { length, offset }), + old.map(|(index, length, offset)| SelectedMatch::OldOffset { + index, + length, + offset, + }), + best_short_offset_match(input, pos, end), + ] + .into_iter() + .flatten() + .max_by_key(|&selected| { + ( + cost_model + .selected_score(selected, input, pos) + .unwrap_or(isize::MIN), + selected.length(), + ) + }); + } + + match (fresh, old) { + (Some((fresh_length, _)), Some((index, old_length, old_offset))) + if old_length + 1 >= fresh_length => + { + Some(SelectedMatch::OldOffset { + index, + length: old_length, + offset: old_offset, + }) + } + (Some((length, offset)), _) => Some(SelectedMatch::Fresh { length, offset }), + (None, Some((index, length, offset))) => Some(SelectedMatch::OldOffset { + index, + length, + offset, + }), + (None, None) => best_short_offset_match(input, pos, end), + } +} + +struct LazyMatchContext<'a> { + input: &'a [u8], + end: usize, + finder: &'a Rar20MatchFinder, + options: EncodeOptions, + old_offsets: &'a [usize; 4], + cost_model: Option<&'a CostModel<'a>>, +} + +fn should_lazy_emit_literal( + pos: usize, + current: SelectedMatch, + context: LazyMatchContext<'_>, +) -> bool { + if !context.options.lazy_matching { + return false; + } + let lookahead = context.options.lazy_lookahead.max(1); + (1..=lookahead) + .take_while(|offset| pos + offset < context.end) + .any(|offset| { + select_match( + context.input, + pos + offset, + context.end, + context.finder, + context.options, + context.old_offsets, + context.cost_model, + ) + .is_some_and(|next| { + let current_score = context + .cost_model + .and_then(|cost_model| cost_model.selected_score(current, context.input, pos)) + .unwrap_or_else(|| current.score()); + let next_score = context + .cost_model + .and_then(|cost_model| { + cost_model.selected_score(next, context.input, pos + offset) + }) + .unwrap_or_else(|| next.score()); + let skipped_literal_score = context + .cost_model + .map_or(offset as isize * 8, |cost_model| { + cost_model.literal_bits(context.input, pos, offset) as isize + }); + next_score > current_score + skipped_literal_score + }) + }) +} + +fn best_match( + input: &[u8], + pos: usize, + end: usize, + finder: &Rar20MatchFinder, + options: EncodeOptions, + cost_model: Option<&CostModel<'_>>, +) -> Option<(usize, usize)> { + let max_offset = pos.min(options.max_match_distance); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_offset == 0 || max_length < 3 { + return None; + } + let mut best = None; + let mut checked = 0usize; + let mut candidate = finder.first(input, pos); + while candidate != match_finder::NO_POSITION { + // Callers search before inserting this position, so every candidate is older. + let offset = pos - candidate; + if offset > max_offset { + break; + } + checked += 1; + // Without a cost model, a candidate can only improve on the current + // best when it matches at least one byte past the best length, so + // probe that byte first. The cost-model pass may prefer shorter but + // cheaper matches, so it must evaluate every candidate. Probing is + // safe because a best match reaching `max_length` breaks the loop. + let best_length = best.map_or(0, |(length, _)| length); + let probe_ok = cost_model.is_some() + || best_length == 0 + || input[candidate + best_length] == input[pos + best_length]; + if probe_ok { + let length = super::super::fast::match_length(input, pos, offset, max_length); + let encodable = length >= 3 + match_length_adjustment(offset); + if encodable && is_better_fresh_match(cost_model, input, pos, length, offset, best) { + best = Some((length, offset)); + if length == max_length { + break; + } + } + } + if checked >= options.max_match_candidates { + break; + } + candidate = finder.previous(candidate); + } + best +} + +fn offset_slot_index(offset: usize) -> usize { + offset_slot_for_match(offset) + .map(|(slot, _)| slot) + .unwrap_or(OFFSET_BITS.len() - 1) +} + +fn is_better_fresh_match( + cost_model: Option<&CostModel<'_>>, + input: &[u8], + pos: usize, + length: usize, + offset: usize, + best: Option<(usize, usize)>, +) -> bool { + let Some((best_length, best_offset)) = best else { + return true; + }; + if let Some(cost_model) = cost_model { + let candidate = SelectedMatch::Fresh { length, offset }; + let best = SelectedMatch::Fresh { + length: best_length, + offset: best_offset, + }; + let candidate_score = cost_model + .selected_score(candidate, input, pos) + .unwrap_or(isize::MIN); + let best_score = cost_model + .selected_score(best, input, pos) + .unwrap_or(isize::MIN); + return candidate_score > best_score + || (candidate_score == best_score && length > best_length); + } + // The hash chain visits nearest matches first, so an equal-length later + // candidate cannot have a smaller offset. + length > best_length +} + +fn best_old_offset_match( + input: &[u8], + pos: usize, + end: usize, + old_offsets: &[usize; 4], + cost_model: Option<&CostModel<'_>>, +) -> Option<(usize, usize, usize)> { + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + let mut best = None; + for (index, &offset) in old_offsets.iter().enumerate() { + if offset == 0 { + continue; + } + let length = match_length_at_offset(input, pos, max_length, offset); + if old_length_slot_for_match(length, offset).is_ok() + && is_better_old_offset_match(cost_model, input, pos, index, length, offset, best) + { + best = Some((index, length, offset)); + } + } + best +} + +fn is_better_old_offset_match( + cost_model: Option<&CostModel<'_>>, + input: &[u8], + pos: usize, + index: usize, + length: usize, + offset: usize, + best: Option<(usize, usize, usize)>, +) -> bool { + let Some((best_index, best_length, best_offset)) = best else { + return true; + }; + if let Some(cost_model) = cost_model { + let candidate = SelectedMatch::OldOffset { + index, + length, + offset, + }; + let best = SelectedMatch::OldOffset { + index: best_index, + length: best_length, + offset: best_offset, + }; + let candidate_score = cost_model + .selected_score(candidate, input, pos) + .unwrap_or(isize::MIN); + let best_score = cost_model + .selected_score(best, input, pos) + .unwrap_or(isize::MIN); + return candidate_score > best_score + || (candidate_score == best_score + && (length > best_length || (length == best_length && offset < best_offset))); + } + length > best_length || (length == best_length && offset < best_offset) +} + +fn best_short_offset_match(input: &[u8], pos: usize, end: usize) -> Option { + if end - pos < 2 { + return None; + } + let max_offset = pos.min(256); + (1..=max_offset) + .find(|&offset| { + input[pos] == input[pos - offset] && input[pos + 1] == input[pos + 1 - offset] + }) + .map(|offset| SelectedMatch::ShortOffset { offset }) +} + +fn match_length_at_offset(input: &[u8], pos: usize, max_length: usize, offset: usize) -> usize { + super::super::fast::match_length(input, pos, offset, max_length) +} + +fn match_length_adjustment(offset: usize) -> usize { + usize::from(offset >= 0x2000) + usize::from(offset >= 0x40000) +} + +fn old_length_adjustment(offset: usize) -> usize { + usize::from(offset >= 0x101) + usize::from(offset >= 0x2000) + usize::from(offset >= 0x40000) +} + +fn push_old_offset(old_offsets: &mut [usize; 4], offset: usize) { + old_offsets[3] = old_offsets[2]; + old_offsets[2] = old_offsets[1]; + old_offsets[1] = old_offsets[0]; + old_offsets[0] = offset; +} + +fn length_slot_for_match(length: usize) -> Result<(usize, usize)> { + if length < 3 { + return Err(Error::InvalidData("RAR 2.0 match length is too short")); + } + if length > MAX_ENCODER_MATCH_LENGTH { + return Err(Error::InvalidData("RAR 2.0 match length is too long")); + } + let adjusted = length - 3; + let slot = LENGTH_BASES.partition_point(|&base| base <= adjusted) - 1; + Ok((slot, adjusted - LENGTH_BASES[slot])) +} + +fn old_length_slot_for_match(length: usize, offset: usize) -> Result<(usize, usize)> { + let encoded = length + .checked_sub(old_length_adjustment(offset)) + .ok_or(Error::InvalidData( + "RAR 2.0 adjusted old-offset length underflows", + ))?; + if encoded < 2 { + return Err(Error::InvalidData( + "RAR 2.0 old-offset match length is too short", + )); + } + let adjusted = encoded - 2; + if adjusted > 255 { + return Err(Error::InvalidData( + "RAR 2.0 old-offset match length is too long", + )); + } + let slot = LENGTH_BASES.partition_point(|&base| base <= adjusted) - 1; + Ok((slot, adjusted - LENGTH_BASES[slot])) +} + +fn offset_slot_for_match(offset: usize) -> Result<(usize, usize)> { + if offset == 0 { + return Err(Error::InvalidData("RAR 2.0 match offset is zero")); + } + if offset > MAX_ENCODER_MATCH_OFFSET { + return Err(Error::InvalidData("RAR 2.0 match offset is too large")); + } + let adjusted = offset - 1; + let slot = OFFSET_BASES.partition_point(|&base| base <= adjusted) - 1; + Ok((slot, adjusted - OFFSET_BASES[slot])) +} + +fn short_slot_for_match(offset: usize) -> Result<(usize, usize)> { + if offset == 0 || offset > 256 { + return Err(Error::InvalidData( + "RAR 2.0 short match offset is out of range", + )); + } + let adjusted = offset - 1; + let slot = short_slot_index(offset); + Ok((slot, adjusted - SHORT_BASES[slot])) +} + +fn short_slot_index(offset: usize) -> usize { + let adjusted = offset - 1; + SHORT_BASES.partition_point(|&base| base <= adjusted) - 1 +} + +fn literal_code_len(symbol_count: usize) -> u8 { + // A nonempty member always emits at least one token and there are at most + // TABLE_COUNT distinct symbols, so the result fits in u8. + let len = usize::BITS - (symbol_count - 1).leading_zeros(); + len.max(1) as u8 +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct LevelToken { + symbol: usize, + extra_bits: u8, + extra_value: u8, +} + +impl LevelToken { + const fn plain(symbol: usize) -> Self { + Self { + symbol, + extra_bits: 0, + extra_value: 0, + } + } + + const fn repeat_previous(count: usize) -> Self { + Self { + symbol: 16, + extra_bits: 2, + extra_value: (count - 3) as u8, + } + } + + const fn zero_run_short(count: usize) -> Self { + Self { + symbol: 17, + extra_bits: 3, + extra_value: (count - 3) as u8, + } + } + + const fn zero_run_long(count: usize) -> Self { + Self { + symbol: 18, + extra_bits: 7, + extra_value: (count - 11) as u8, + } + } +} + +fn encode_table_level_tokens(lengths: &[u8; TABLE_COUNT]) -> Vec { + encode_level_tokens(lengths) +} + +fn encode_level_tokens(lengths: &[u8]) -> Vec { + let mut tokens = Vec::new(); + let mut pos = 0usize; + let mut previous = None; + while pos < lengths.len() { + let value = lengths[pos]; + let mut run = 1usize; + while pos + run < lengths.len() && lengths[pos + run] == value { + run += 1; + } + + if value == 0 { + emit_zero_level_run(&mut tokens, run); + previous = Some(0); + pos += run; + continue; + } + + if previous == Some(value) && run >= 3 { + let mut remaining = run; + while remaining != 0 { + let chunk = remaining.min(6); + if chunk >= 3 { + tokens.push(LevelToken::repeat_previous(chunk)); + remaining -= chunk; + } else { + tokens.extend(std::iter::repeat_n( + LevelToken::plain(value as usize), + chunk, + )); + remaining = 0; + } + } + pos += run; + continue; + } + + tokens.push(LevelToken::plain(value as usize)); + previous = Some(value); + pos += 1; + } + tokens +} + +fn emit_zero_level_run(tokens: &mut Vec, mut run: usize) { + while run != 0 { + if run >= 11 { + let mut chunk = run.min(138); + if matches!(run - chunk, 1 | 2) { + chunk -= 3; + } + tokens.push(LevelToken::zero_run_long(chunk)); + run -= chunk; + } else if run >= 3 { + let chunk = run.min(10); + tokens.push(LevelToken::zero_run_short(chunk)); + run -= chunk; + } else { + tokens.extend(std::iter::repeat_n(LevelToken::plain(0), run)); + break; + } + } +} + +fn level_code_lengths_for_tokens(tokens: &[LevelToken]) -> [u8; LEVEL_COUNT] { + let mut used = [false; LEVEL_COUNT]; + for token in tokens { + used[token.symbol] = true; + } + level_code_lengths_for_used_symbols(used) +} + +fn encode_audio_member(input: &[u8], channels: usize) -> Result> { + if channels == 0 || channels > MAX_CHANNELS { + return Err(Error::InvalidData("RAR 2.0 audio channel count is invalid")); + } + let deltas = audio_encode(input, channels); + let mut levels = vec![0u8; AUDIO_COUNT * channels]; + for channel in 0..channels { + let mut frequencies = [0usize; AUDIO_COUNT]; + for index in (channel..deltas.len()).step_by(channels) { + frequencies[deltas[index] as usize] += 1; + } + let channel_lengths = huffman::lengths_for_frequency_array(&frequencies, 15); + for (symbol, len) in channel_lengths.into_iter().enumerate() { + levels[channel * AUDIO_COUNT + symbol] = len; + } + } + + let level_symbols = encode_audio_table_level_symbols(&levels); + let level_lengths = level_code_lengths_for_symbols(&level_symbols); + let level_codes = canonical_codes(&level_lengths)?; + let mut bits = BitWriter::default(); + bits.write_bits(0b10, 2); // audio block, do not keep previous tables. + bits.write_bits((channels - 1) as u32, 2); + for &len in &level_lengths { + bits.write_bits(len as u32, 4); + } + for symbol in level_symbols { + let code = level_codes[symbol].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing audio-level Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + // Audio levels are emitted directly as 0..=15, without run symbols. + } + + let audio_codes = (0..channels) + .map(|channel| canonical_codes(&levels[channel * AUDIO_COUNT..(channel + 1) * AUDIO_COUNT])) + .collect::>>()?; + for (index, &delta) in deltas.iter().enumerate() { + let channel = index % channels; + let code = audio_codes[channel][delta as usize].ok_or(Error::InvalidData( + "RAR 2.0 encoder missing audio Huffman code", + ))?; + bits.write_bits(code.code as u32, code.len); + } + Ok(bits.finish()) +} + +fn encode_audio_table_level_symbols(levels: &[u8]) -> Vec { + levels.iter().map(|&len| len as usize).collect() +} + +fn level_code_lengths_for_symbols(symbols: &[usize]) -> [u8; LEVEL_COUNT] { + let mut used = [false; LEVEL_COUNT]; + for &symbol in symbols { + used[symbol] = true; + } + level_code_lengths_for_used_symbols(used) +} + +fn level_code_lengths_for_used_symbols(used: [bool; LEVEL_COUNT]) -> [u8; LEVEL_COUNT] { + let mut lengths = [0u8; LEVEL_COUNT]; + for (symbol, is_used) in used.into_iter().enumerate() { + if is_used { + lengths[symbol] = 1; + } + } + huffman::assign_flat_complete_code(&mut lengths); + lengths +} + +fn audio_encode(input: &[u8], channels: usize) -> Vec { + let mut states = [AudioState::default(); MAX_CHANNELS]; + let mut channel_delta = 0i32; + let mut deltas = Vec::with_capacity(input.len()); + for (index, &byte) in input.iter().enumerate() { + let channel = index % channels; + let state = &mut states[channel]; + state.byte_count = state.byte_count.wrapping_add(1); + state.d4 = state.d3; + state.d3 = state.d2; + state.d2 = state.last_delta - state.d1; + state.d1 = state.last_delta; + + let predicted = 8 * state.last_char + + state.k[0] * state.d1 + + state.k[1] * state.d2 + + state.k[2] * state.d3 + + state.k[3] * state.d4 + + state.k[4] * channel_delta; + let predicted = (predicted >> 3) & 0xff; + let delta = (predicted as u8).wrapping_sub(byte); + + let d = (delta as i8 as i32) << 3; + state.dif[0] = state.dif[0].wrapping_add(d.unsigned_abs()); + state.dif[1] = state.dif[1].wrapping_add((d - state.d1).unsigned_abs()); + state.dif[2] = state.dif[2].wrapping_add((d + state.d1).unsigned_abs()); + state.dif[3] = state.dif[3].wrapping_add((d - state.d2).unsigned_abs()); + state.dif[4] = state.dif[4].wrapping_add((d + state.d2).unsigned_abs()); + state.dif[5] = state.dif[5].wrapping_add((d - state.d3).unsigned_abs()); + state.dif[6] = state.dif[6].wrapping_add((d + state.d3).unsigned_abs()); + state.dif[7] = state.dif[7].wrapping_add((d - state.d4).unsigned_abs()); + state.dif[8] = state.dif[8].wrapping_add((d + state.d4).unsigned_abs()); + state.dif[9] = state.dif[9].wrapping_add((d - channel_delta).unsigned_abs()); + state.dif[10] = state.dif[10].wrapping_add((d + channel_delta).unsigned_abs()); + + channel_delta = (byte.wrapping_sub(state.last_char as u8)) as i8 as i32; + state.last_delta = channel_delta; + state.last_char = byte as i32; + + if state.byte_count & 0x1f == 0 { + let mut min_dif = state.dif[0]; + let mut num_min_dif = 0usize; + state.dif[0] = 0; + for diff_index in 1..state.dif.len() { + if state.dif[diff_index] < min_dif { + min_dif = state.dif[diff_index]; + num_min_dif = diff_index; + } + state.dif[diff_index] = 0; + } + match num_min_dif { + 1 if state.k[0] >= -16 => state.k[0] -= 1, + 2 if state.k[0] < 16 => state.k[0] += 1, + 3 if state.k[1] >= -16 => state.k[1] -= 1, + 4 if state.k[1] < 16 => state.k[1] += 1, + 5 if state.k[2] >= -16 => state.k[2] -= 1, + 6 if state.k[2] < 16 => state.k[2] += 1, + 7 if state.k[3] >= -16 => state.k[3] -= 1, + 8 if state.k[3] < 16 => state.k[3] += 1, + 9 if state.k[4] >= -16 => state.k[4] -= 1, + 10 if state.k[4] < 16 => state.k[4] += 1, + _ => {} + } + } + + deltas.push(delta); + } + deltas +} + +#[derive(Debug, Clone, Copy)] +struct HuffmanCode { + code: u16, + len: u8, +} + +fn canonical_codes(lengths: &[u8]) -> Result>> { + let mut count = [0u16; 16]; + for &len in lengths { + if len > 15 { + return Err(Error::InvalidData("RAR 2.0 Huffman length is too large")); + } + if len != 0 { + count[len as usize] += 1; + } + } + validate_huffman_counts(&count)?; + + let mut next_code = [0u16; 16]; + let mut code = 0u16; + for len in 1..=15 { + code = (code + count[len - 1]) << 1; + next_code[len] = code; + } + + let mut codes = vec![None; lengths.len()]; + for (symbol, &len) in lengths.iter().enumerate() { + if len == 0 { + continue; + } + let code = next_code[len as usize]; + next_code[len as usize] += 1; + codes[symbol] = Some(HuffmanCode { code, len }); + } + Ok(codes) +} + +#[derive(Default)] +struct BitWriter { + bytes: Vec, + bit_pos: usize, +} + +impl BitWriter { + fn write_bits(&mut self, value: u32, count: u8) { + super::super::fast::write_msb_bits( + &mut self.bytes, + &mut self.bit_pos, + u64::from(value), + usize::from(count), + ); + } + + #[cfg(test)] + fn write_bit(&mut self, bit: bool) { + self.write_bits(u32::from(bit), 1); + } + + fn finish(self) -> Vec { + self.bytes + } +} + +#[cfg(test)] +#[path = "tests.rs"] +mod tests; diff --git a/arca-rar/vendor/rars/src/codec/rar20/tests.rs b/arca-rar/vendor/rars/src/codec/rar20/tests.rs new file mode 100644 index 00000000..482faa52 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar20/tests.rs @@ -0,0 +1,1227 @@ +#[test] +fn reader20_workspace_refusals_release_lz_audio_input_and_checkpoints() { + use crate::codec::workspace::RefusingBudget; + let data = b"resource accounting for legacy audio and LZ\n".repeat(24); + let streams = [ + super::unpack20_encode_literals(&data).unwrap(), + super::encode_audio_member(&data, 4).unwrap(), + ]; + for packed in streams { + for streaming in [false, true] { + let run = |budget: &RefusingBudget| -> super::Result<()> { + let mut decoder = super::Reader20State::with_allowance(budget); + if streaming { + let mut output = super::Buffer::new(budget); + decoder.decode_member_from_reader( + &mut packed.as_slice(), + data.len(), + &mut output, + )?; + assert_eq!(&*output, &data); + } else { + let output = decoder.decode_member_owned(&packed, data.len())?; + assert_eq!(&*output, &data); + } + let checkpoint = decoder.try_clone()?; + assert_eq!(checkpoint.output, decoder.output); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts > 10); + assert_eq!(baseline.used(), 0); + for index in 0..attempts { + let budget = RefusingBudget::new(index); + assert!( + matches!(run(&budget), Err(Error::Cancelled)), + "allocation {index}, streaming={streaming}" + ); + assert_eq!(budget.used(), 0); + } + } + } +} + +#[test] +fn reader20_workspace_keeps_returned_data_charged_after_decoder_drop() { + let data = b"owned legacy result".repeat(32); + let packed = unpack20_encode_literals(&data).unwrap(); + let ledger = super::Allowance::limited(256 * 1024); + let mut decoder = super::Reader20State::with_allowance(&ledger); + let output = decoder.decode_member_owned(&packed, data.len()).unwrap(); + assert!(ledger.used() > output.capacity() as u64); + drop(decoder); + assert_eq!(ledger.used(), output.capacity() as u64); + assert_eq!(&*output, &data); + drop(output); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn cancellation_interrupts_buffered_symbol_work() { + let data = b"cancellable legacy symbols ".repeat(16384); + let packed = unpack20_encode_literals(&data).unwrap(); + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack20::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + decoder.read_control.cancel_after_checks(3); + assert_eq!( + decoder.decode_member(&packed, data.len()).unwrap_err(), + Error::Cancelled + ); + assert!(decoder.current_pos() > 0 && decoder.current_pos() < data.len()); +} +type Unpack20 = super::Reader20State; +use super::{ + encode_tokens_with_progress, level_code_lengths_for_used_symbols, unpack20_decode, + unpack20_encode_literals, BitWriter, CostModel, EncodeOptions, EncodeToken, Error, Huffman, + Unpack20Encoder, LEVEL_COUNT, +}; + +/// 7-Zip builds the RAR pre-table with `k_BuildMode_Full` and refuses a +/// code that leaves part of the code space unassigned, where unrar takes +/// it. Giving every used symbol the same length only fills the space when +/// the count is a power of two, so the flat table we used to emit was +/// under-full for 3, 5, 6, 7, 9 symbols and so on, and 7-Zip rejected the +/// archive before decoding a byte. +#[test] +fn the_pre_table_fills_its_code_space_for_every_symbol_count() { + for count in 1..=LEVEL_COUNT { + let mut used = [false; LEVEL_COUNT]; + for slot in used.iter_mut().take(count) { + *slot = true; + } + let lengths = level_code_lengths_for_used_symbols(used); + + let longest = lengths.iter().copied().max().unwrap(); + let kraft: u32 = lengths + .iter() + .filter(|&&len| len != 0) + .map(|&len| 1u32 << (longest - len)) + .sum(); + assert_eq!( + kraft, + 1 << longest, + "{count} symbols gave the incomplete code {lengths:?}" + ); + } +} + +fn encode_tokens( + input: &[u8], + history: &[u8], + options: EncodeOptions, + cost_model: Option<&CostModel>, +) -> Vec { + encode_tokens_with_progress(input, history, options, cost_model, None) + .expect("encoding without cancellation cannot be cancelled") +} + +const AUTOREJ_PACKED: &[u8] = &[ + 0x09, 0x14, 0x0c, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0xce, 0xf8, 0x1f, 0xc1, 0xe6, 0x05, 0xfc, + 0x39, 0xc3, 0x50, 0x65, 0x08, 0x41, 0x94, 0xc4, 0x1d, 0xf3, 0xcd, 0x0d, 0x8e, 0x20, 0xf5, 0x9d, + 0x8e, 0x76, 0x1d, 0xc5, 0x19, 0xde, 0x16, 0x5b, 0x52, 0xb8, 0x8e, 0x75, 0xcd, 0xaf, 0x1f, 0xfc, + 0x9e, 0xf7, 0x00, 0x01, 0xbe, 0x90, +]; + +#[test] +fn decodes_rar20_lz_member() { + assert_eq!( + unpack20_decode(AUTOREJ_PACKED, expected_text().len()).unwrap(), + expected_text() + ); +} + +#[test] +fn rejects_oversubscribed_rar20_huffman_tables() { + assert!(matches!( + Huffman::from_lengths(&[1, 1, 1]), + Err(Error::InvalidData("RAR 2.0 oversubscribed Huffman table")) + )); +} + +#[test] +fn rejects_an_empty_main_huffman_table() { + let mut bits = BitWriter::default(); + bits.write_bits(0, 2); // LZ block with fresh tables. + for symbol in 0..LEVEL_COUNT { + bits.write_bits(u32::from(symbol == 0 || symbol == 18), 4); + } + for run in [138u32, 138, 98] { + bits.write_bit(true); // Pre-table symbol 18. + bits.write_bits(run - 11, 7); + } + + assert_eq!( + Unpack20::new() + .decode_member(&bits.finish(), 1) + .unwrap_err(), + Error::InvalidData("RAR 2.0 empty Huffman table") + ); +} + +#[test] +fn internal_bit_and_huffman_helpers_reject_out_of_range_requests() { + assert!(matches!( + Huffman::from_lengths(&[16]), + Err(Error::InvalidData("RAR 2.0 Huffman length is too large")) + )); + assert!(matches!( + super::canonical_codes(&[16]), + Err(Error::InvalidData("RAR 2.0 Huffman length is too large")) + )); + assert_eq!( + super::BitReader::new().peek_bits(25).unwrap_err(), + Error::InvalidData("RAR 2.0 bit read is too wide") + ); +} + +#[test] +fn decode_member_from_reader_accepts_incremental_input() { + struct TinyReader<'a> { + input: &'a [u8], + } + + impl std::io::Read for TinyReader<'_> { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if self.input.is_empty() { + return Ok(0); + } + let len = self.input.len().min(out.len()).min(3); + out[..len].copy_from_slice(&self.input[..len]); + self.input = &self.input[len..]; + Ok(len) + } + } + + let mut decoder = Unpack20::new(); + let mut reader = TinyReader { + input: AUTOREJ_PACKED, + }; + let mut output = Vec::new(); + decoder + .decode_member_from_reader(&mut reader, expected_text().len(), &mut output) + .unwrap(); + + assert_eq!(output, expected_text()); +} + +#[test] +fn decode_member_from_reader_rejects_a_truncated_payload() { + for end in [AUTOREJ_PACKED.len() / 2, AUTOREJ_PACKED.len() - 1] { + let mut decoder = Unpack20::new(); + let mut packed = &AUTOREJ_PACKED[..end]; + assert_eq!( + decoder + .decode_member_from_reader(&mut packed, expected_text().len(), &mut Vec::new()) + .unwrap_err(), + Error::InvalidData("RAR 2.0 bitstream is truncated") + ); + } +} + +#[test] +fn decode_member_from_reader_accepts_an_empty_member() { + let mut decoder = Unpack20::new(); + let mut input = &[][..]; + let mut output = Vec::new(); + decoder + .decode_member_from_reader(&mut input, 0, &mut output) + .unwrap(); + assert!(output.is_empty()); +} + +#[test] +fn decoder_reports_truncated_tables_and_member_payloads() { + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&[0], 1).unwrap_err(), + Error::InvalidData("RAR 2.0 bitstream is truncated") + ); + + let input = expected_text(); + for packed in [ + &AUTOREJ_PACKED[..1], + &AUTOREJ_PACKED[..AUTOREJ_PACKED.len() / 2], + ] { + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(packed, input.len()).unwrap_err(), + Error::InvalidData("RAR 2.0 bitstream is truncated") + ); + } +} + +#[test] +fn rejects_a_table_repeat_without_a_previous_level() { + let mut bits = BitWriter::default(); + bits.write_bits(0, 2); // LZ, new tables. + for symbol in 0..LEVEL_COUNT { + bits.write_bits(u32::from(symbol == 0 || symbol == 16), 4); + } + bits.write_bit(true); // Pre-table symbol 16 at position zero. + assert_eq!( + Unpack20::new() + .decode_member(&bits.finish(), 1) + .unwrap_err(), + Error::InvalidData("RAR 2.0 table repeat at start") + ); +} + +#[test] +fn empty_member_does_not_try_to_decode_an_absent_main_table() { + let mut decoder = Unpack20::new(); + assert_eq!(decoder.decode_member(&[0; 5], 0).unwrap(), b""); + + decoder.audio_block = true; + assert_eq!(decoder.decode_member(&[0; 5], 0).unwrap(), b""); +} + +#[test] +fn audio_table_resets_the_channel_when_channel_count_shrinks() { + let mut decoder = Unpack20::new(); + decoder.channels = 4; + decoder.cur_channel = 3; + assert_eq!( + decoder.decode_member(&synthetic_audio_block(1), 1).unwrap(), + b"\0" + ); + assert_eq!(decoder.cur_channel, 0); +} + +#[test] +fn audio_lookahead_keeps_a_block_without_an_end_marker() { + let mut packed = synthetic_audio_block(4); + packed.extend_from_slice(&[0; 5]); + let mut decoder = Unpack20::new(); + assert_eq!(decoder.decode_member(&packed, 4).unwrap(), vec![0; 4]); + assert!(decoder.in_block); +} + +#[test] +fn audio_predictor_coefficients_stop_at_their_format_limits() { + for winning_difference in 1..=10 { + let mut decoder = Unpack20::new(); + let state = &mut decoder.audio[0]; + state.byte_count = 31; + state.dif = [u32::MAX / 4; 11]; + state.dif[winning_difference] = 0; + let coefficient = (winning_difference - 1) / 2; + state.k[coefficient] = if winning_difference % 2 == 1 { -17 } else { 16 }; + let before = state.k; + + decoder.decode_audio(0); + assert_eq!( + decoder.audio[0].k, before, + "difference {winning_difference}" + ); + } +} + +#[test] +fn copy_match_zero_fills_an_offset_that_reaches_past_the_stream() { + let mut decoder = Unpack20::new(); + decoder.output.extend_from_slice(b"AB").unwrap(); + + decoder.copy_match(4, 9, 6).unwrap(); + + assert_eq!(&*decoder.output, b"AB\0\0\0\0"); +} + +#[test] +fn repeat_last_without_a_previous_match_is_a_no_op() { + let mut lengths = [0u8; super::MAIN_COUNT]; + lengths[0] = 1; + lengths[256] = 1; + let mut decoder = Unpack20::new(); + decoder.main = Huffman::from_lengths(&lengths).unwrap(); + decoder.in_block = true; + decoder.bits.append(&[0b1000_0000]).unwrap(); // Repeat last, then literal zero. + + decoder.decode_until(1).unwrap(); + assert_eq!(&*decoder.output, b"\0"); + assert_eq!(decoder.last_length, 0); +} + +#[test] +fn old_offset_match_applies_the_long_distance_length_adjustment() { + let mut main_lengths = [0u8; super::MAIN_COUNT]; + main_lengths[0] = 1; + main_lengths[257] = 1; + let mut length_lengths = [0u8; super::LENGTH_COUNT]; + length_lengths[0] = 1; + let mut decoder = Unpack20::new(); + decoder.main = Huffman::from_lengths(&main_lengths).unwrap(); + decoder.lengths = Huffman::from_lengths(&length_lengths).unwrap(); + decoder.old_offsets[0] = 0x40000; + decoder.in_block = true; + decoder.bits.append(&[0b1000_0000]).unwrap(); // Old offset 0, length slot 0. + + decoder.decode_until(1).unwrap(); + assert_eq!(&*decoder.output, b"\0"); + assert_eq!(decoder.last_length, 5); // 2 + three distance adjustments. + assert_eq!(decoder.pending_match, Some((4, 0x40000))); +} + +#[test] +fn unset_old_offset_match_uses_the_first_dictionary_byte() { + let mut main_lengths = [0u8; super::MAIN_COUNT]; + main_lengths[0] = 1; + main_lengths[257] = 1; + let mut length_lengths = [0u8; super::LENGTH_COUNT]; + length_lengths[0] = 1; + let mut decoder = Unpack20::new(); + decoder.main = Huffman::from_lengths(&main_lengths).unwrap(); + decoder.lengths = Huffman::from_lengths(&length_lengths).unwrap(); + decoder.in_block = true; + decoder.bits.append(&[0b1000_0000]).unwrap(); + + decoder.decode_until(2).unwrap(); + assert_eq!(&*decoder.output, b"\0\0"); + assert_eq!(decoder.last_offset, 0); +} + +#[test] +fn offset_slot_without_extra_bits_decodes_the_first_distance() { + let mut decoder = Unpack20::new(); + decoder.offsets = Huffman::from_lengths(&[1, 1]).unwrap(); + decoder.bits.append(&[0]).unwrap(); + assert_eq!(decoder.read_offset().unwrap(), 1); +} + +#[test] +fn encoder_slot_tables_cover_their_entire_format_ranges() { + for length in 3..=super::MAX_ENCODER_MATCH_LENGTH { + let (slot, extra) = super::length_slot_for_match(length).unwrap(); + assert_eq!(super::LENGTH_BASES[slot] + extra + 3, length); + assert!(extra < 1usize << super::LENGTH_BITS[slot]); + } + for offset in 1..=256 { + let (slot, extra) = super::short_slot_for_match(offset).unwrap(); + assert_eq!(super::SHORT_BASES[slot] + extra + 1, offset); + assert!(extra < 1usize << super::SHORT_BITS[slot]); + } + for slot in 0..super::OFFSET_COUNT { + for extra in [0, (1usize << super::OFFSET_BITS[slot]) - 1] { + let offset = super::OFFSET_BASES[slot] + extra + 1; + let (actual_slot, actual_extra) = super::offset_slot_for_match(offset).unwrap(); + assert_eq!((actual_slot, actual_extra), (slot, extra)); + } + } + assert_eq!( + super::OFFSET_BASES[super::OFFSET_COUNT - 1] + 65536, + super::MAX_HISTORY + ); + + assert!(super::length_slot_for_match(2).is_err()); + assert!(super::length_slot_for_match(259).is_err()); + assert!(super::offset_slot_for_match(0).is_err()); + assert!(super::offset_slot_for_match(super::MAX_HISTORY + 1).is_err()); + assert!(super::short_slot_for_match(0).is_err()); + assert!(super::short_slot_for_match(257).is_err()); + + for offset in [1, 0x40000] { + let adjustment = super::old_length_adjustment(offset); + for adjusted in 0..=255 { + let length = adjusted + 2 + adjustment; + let (slot, extra) = super::old_length_slot_for_match(length, offset).unwrap(); + assert_eq!(super::LENGTH_BASES[slot] + extra, adjusted); + } + assert!(super::old_length_slot_for_match(258 + adjustment, offset).is_err()); + } +} + +#[test] +fn generated_huffman_lengths_are_canonical_for_rar20_table_sizes() { + fn check() { + let mut seed = 0x9e37_79b9u32; + for round in 0..128 { + let mut frequencies = [0usize; N]; + for frequency in &mut frequencies { + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + if !seed.is_multiple_of(5) { + *frequency = 1 + (seed as usize % (1 + round * round)); + } + } + if round % 2 == 0 { + frequencies[0] = 1 << 24; + } + let lengths = super::huffman::lengths_for_frequency_array(&frequencies, 15); + assert!( + super::canonical_codes(&lengths).is_ok(), + "size {N}, round {round}" + ); + } + } + check::<{ super::MAIN_COUNT }>(); + check::<{ super::OFFSET_COUNT }>(); + check::<{ super::LENGTH_COUNT }>(); +} + +#[test] +fn decodes_synthetic_audio_block() { + let packed = synthetic_audio_block(8); + let mut decoder = Unpack20::new(); + + assert_eq!(decoder.decode_member(&packed, 8).unwrap(), vec![0; 8]); +} + +#[test] +fn audio_encoder_round_trips_interleaved_pcm_like_payload() { + let input = interleaved_pcm_like_payload(); + let packed = super::encode_audio_member(&input, 4).unwrap(); + let decoded = unpack20_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn auto_encoder_uses_audio_when_it_beats_lz() { + let input = interleaved_pcm_like_payload(); + let lz = unpack20_encode_literals(&input).unwrap(); + let auto = super::unpack20_encode_auto(&input).unwrap(); + let decoded = unpack20_decode(&auto, input.len()).unwrap(); + + assert!(auto.len() < lz.len()); + assert_eq!(decoded, input); +} + +#[test] +fn short_auto_encoded_members_skip_audio_candidates() { + let input = b"short"; + let packed = super::unpack20_encode_auto(input).unwrap(); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); + + let packed = super::unpack20_encode_auto_with_options( + input, + EncodeOptions::default().with_try_audio(false), + ) + .unwrap(); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); + + let mut always_continue = |_| true; + let packed = super::unpack20_encode_auto_with_options_and_progress( + input, + EncodeOptions::default(), + &mut always_continue, + ) + .unwrap(); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_checks_cancellation_after_the_last_symbol() { + let mut calls = 0; + let mut cancel_at_end = |_| { + calls += 1; + calls == 1 + }; + assert_eq!( + super::unpack20_encode_auto_with_options_and_progress( + b"end", + EncodeOptions::new(0).with_try_audio(false), + &mut cancel_at_end, + ) + .unwrap_err(), + Error::Cancelled + ); + assert_eq!(calls, 2); +} + +#[test] +fn encoder_checks_cancellation_during_refinement() { + let mut calls = 0; + let mut cancel_during_refinement = |_| { + calls += 1; + calls <= 2 + }; + assert_eq!( + super::unpack20_encode_auto_with_options_and_progress( + b"ABCDABCDABCD", + EncodeOptions::default().with_try_audio(false), + &mut cancel_during_refinement, + ) + .unwrap_err(), + Error::Cancelled + ); + assert_eq!(calls, 3); +} + +#[test] +fn encoder_rejects_matches_beyond_the_configured_distance() { + let input = b"abcXYabc"; + let mut finder = super::Rar20MatchFinder::new(input.len()); + finder.insert(input, 0); + assert_eq!( + super::best_match( + input, + 5, + input.len(), + &finder, + EncodeOptions::default().with_max_match_distance(2), + None, + ), + None + ); +} + +#[test] +fn missing_literal_code_has_a_nonzero_refinement_cost() { + let lengths = [0u8; super::TABLE_COUNT]; + let prices = CostModel::new(&lengths); + assert_eq!(prices.literal_bits(b"x", 0, 1), super::ABSENT_LITERAL_BITS); +} + +#[test] +fn old_offset_ties_prefer_the_shorter_distance() { + let lengths = [0u8; super::TABLE_COUNT]; + let prices = CostModel::new(&lengths); + assert!(super::is_better_old_offset_match( + Some(&prices), + b"aaa", + 0, + 1, + 3, + 1, + Some((0, 3, 2)), + )); + assert!(!super::is_better_old_offset_match( + Some(&prices), + b"aaa", + 0, + 1, + 3, + 3, + Some((0, 3, 2)), + )); + + // One extra bit for a longer match can exactly cancel the extra + // literal it saves. On that score tie, prefer the longer match. + let mut lengths = [0u8; super::TABLE_COUNT]; + lengths[b'a' as usize] = 1; + lengths[super::MAIN_COUNT + super::OFFSET_COUNT + 2] = 1; + let prices = CostModel::new(&lengths); + let short = super::SelectedMatch::OldOffset { + index: 0, + length: 3, + offset: 1, + }; + let long = super::SelectedMatch::OldOffset { + index: 1, + length: 4, + offset: 1, + }; + assert_eq!( + prices.selected_score(short, b"aaaa", 0), + prices.selected_score(long, b"aaaa", 0) + ); + assert!(super::is_better_old_offset_match( + Some(&prices), + b"aaaa", + 0, + 1, + 4, + 1, + Some((0, 3, 1)), + )); + assert!(!super::is_better_old_offset_match( + Some(&prices), + b"aaaa", + 0, + 0, + 3, + 1, + Some((1, 4, 1)), + )); +} + +#[test] +fn audio_encoder_rejects_channel_counts_outside_the_format() { + for channels in [0, 5] { + assert_eq!( + super::encode_audio_member(b"audio", channels).unwrap_err(), + Error::InvalidData("RAR 2.0 audio channel count is invalid") + ); + } +} + +#[test] +fn default_encode_options_match_legacy_entry_points() { + let input = b"rar20 option plumbing preserves default output ".repeat(128); + assert_eq!( + unpack20_encode_literals(&input).unwrap(), + super::unpack20_encode_literals_with_options(&input, EncodeOptions::default()).unwrap() + ); + assert_eq!( + super::unpack20_encode_auto(&input).unwrap(), + super::unpack20_encode_auto_with_options(&input, EncodeOptions::default()).unwrap() + ); + + let first = b"solid rar20 option seed ".repeat(64); + let second = b"solid rar20 option seed with suffix ".repeat(32); + let mut legacy = Unpack20Encoder::new(); + let mut explicit = Unpack20Encoder::with_options(EncodeOptions::default()); + assert_eq!( + legacy.encode_member(&first).unwrap(), + explicit.encode_member(&first).unwrap() + ); + assert_eq!( + legacy.encode_member(&second).unwrap(), + explicit.encode_member(&second).unwrap() + ); +} + +#[test] +fn direct_option_field_assignment_cannot_exceed_rar20_distance_limit() { + let mut options = EncodeOptions::new(1); + options.max_match_distance = super::MAX_ENCODER_MATCH_OFFSET + 1; + assert_eq!( + options.constrained().max_match_distance, + super::MAX_ENCODER_MATCH_OFFSET + ); + assert_eq!( + Unpack20Encoder::with_options(options) + .options + .max_match_distance, + super::MAX_ENCODER_MATCH_OFFSET + ); +} + +#[test] +fn optimal_parser_skips_an_out_of_format_fresh_match() { + let start = super::MAX_ENCODER_MATCH_OFFSET + 1; + let end = start + 5; + let mut input = vec![b'X'; end]; + input[..5].copy_from_slice(b"abcde"); + input[start..].copy_from_slice(b"abcde"); + let mut finder = super::Rar20MatchFinder::new(input.len()); + finder.insert(&input, 0); + let mut options = EncodeOptions::new(1).with_optimal_parse(true); + options.max_match_distance = start; + let lengths = [0u8; super::TABLE_COUNT]; + let prices = CostModel::new(&lengths); + + let tokens = super::encode_tokens_optimal(&input, start, end, &mut finder, options, &prices); + assert_eq!(tokens.len(), 5); + assert!(tokens + .iter() + .all(|token| matches!(token, EncodeToken::Literal(_)))); +} + +#[test] +fn encode_options_can_disable_fresh_lz_matches() { + let input = b"abcdefabcdefabcdefabcdef"; + let default_tokens = encode_tokens(input, &[], EncodeOptions::default(), None); + let literalish_tokens = encode_tokens(input, &[], EncodeOptions::new(0), None); + + assert!(default_tokens + .iter() + .any(|token| matches!(token, EncodeToken::Match { .. }))); + assert!(!literalish_tokens + .iter() + .any(|token| matches!(token, EncodeToken::Match { .. }))); +} + +#[test] +fn table_level_encoder_uses_rar20_run_symbols() { + let lengths = [0, 0, 0, 0, 5, 5, 5, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]; + let tokens = super::encode_level_tokens(&lengths); + + assert_eq!( + tokens, + vec![ + super::LevelToken::zero_run_short(4), + super::LevelToken::plain(5), + super::LevelToken::repeat_previous(3), + super::LevelToken::plain(7), + super::LevelToken::zero_run_short(10), + super::LevelToken::plain(2), + ] + ); +} + +#[test] +fn decodes_back_to_back_fresh_audio_blocks() { + // No real RAR 2.x encoder we tested emits a mid-stream `audio_block, + // !keep_tables` transition; reference encoders always either keep the + // existing audio tables across boundaries or switch out to LZ. The + // decoder branch that rebuilds `audio_tables` from a freshly-read level + // table inside an audio sequence is therefore only reachable via a + // hand-crafted fixture. + let mut bits = BitWriter::default(); + write_fresh_audio_block(&mut bits, 4, /*emit_end_sentinel=*/ true); + write_fresh_audio_block(&mut bits, 4, /*emit_end_sentinel=*/ false); + let packed = bits.finish(); + + let mut decoder = Unpack20::new(); + + assert_eq!(decoder.decode_member(&packed, 8).unwrap(), vec![0; 8]); +} + +#[test] +fn audio_member_reads_trailing_table_for_next_solid_member() { + let mut bits = BitWriter::default(); + write_fresh_audio_block(&mut bits, 4, /*emit_end_sentinel=*/ true); + write_fresh_audio_block(&mut bits, 4, /*emit_end_sentinel=*/ false); + let packed = bits.finish(); + + let mut decoder = Unpack20::new(); + assert_eq!(decoder.decode_member(&packed, 4).unwrap(), vec![0; 4]); + assert_eq!(decoder.decode_member(&[], 4).unwrap(), vec![0; 4]); +} + +#[test] +fn lz_member_reads_trailing_table_for_next_solid_member() { + let mut bits = BitWriter::default(); + write_fresh_lz_zero_block(&mut bits, 4, true); + write_fresh_lz_zero_block(&mut bits, 4, false); + let packed = bits.finish(); + + let mut decoder = Unpack20::new(); + assert_eq!(decoder.decode_member(&packed, 4).unwrap(), vec![0; 4]); + assert_eq!(decoder.decode_member(&[], 4).unwrap(), vec![0; 4]); +} + +fn write_fresh_lz_zero_block(bits: &mut BitWriter, count: usize, end: bool) { + let mut table = [0u8; super::TABLE_COUNT]; + table[0] = 1; + table[269] = 1; + let level_tokens = super::encode_table_level_tokens(&table); + let level_lengths = super::level_code_lengths_for_tokens(&level_tokens); + let level_codes = super::canonical_codes(&level_lengths).unwrap(); + let main_codes = super::canonical_codes(&table[..super::MAIN_COUNT]).unwrap(); + + bits.write_bits(0, 2); + for &len in &level_lengths { + bits.write_bits(len as u32, 4); + } + for token in level_tokens { + let code = level_codes[token.symbol].unwrap(); + bits.write_bits(code.code as u32, code.len); + bits.write_bits(token.extra_value as u32, token.extra_bits); + } + let zero = main_codes[0].unwrap(); + for _ in 0..count { + bits.write_bits(zero.code as u32, zero.len); + } + if end { + let end_code = main_codes[269].unwrap(); + bits.write_bits(end_code.code as u32, end_code.len); + } +} + +#[test] +fn decoder_and_encoder_retain_only_the_last_window_of_solid_history() { + let first = vec![b'A'; super::MAX_HISTORY / 2 + 64]; + let second = vec![b'B'; super::MAX_HISTORY / 2 + 64]; + let mut encoder = Unpack20Encoder::with_options(EncodeOptions::new(0)); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(&second).unwrap(); + assert_eq!(encoder.history.len(), super::MAX_HISTORY); + + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); + assert_eq!(decoder.output.len(), super::MAX_HISTORY); + assert_eq!(decoder.base_offset, 128); +} + +#[test] +fn decode_member_carries_a_match_across_output_boundary() { + let input = b"ABCD".repeat(20); + let packed = unpack20_encode_literals(&input).unwrap(); + let mut decoder = Unpack20::new(); + + let first = decoder.decode_member(&packed, 6).unwrap(); + assert!(decoder.pending_match.is_some()); + let second = decoder + .decode_member(&[], input.len() - first.len()) + .unwrap(); + + assert_eq!([first, second].concat(), input); + assert!(decoder.pending_match.is_none()); +} + +fn expected_text() -> Vec { + b"Hello text not audio.\r\n".repeat(100) +} + +fn interleaved_pcm_like_payload() -> Vec { + let mut input = Vec::new(); + for sample in 0..8192i16 { + let left = sample.wrapping_mul(3).wrapping_add(200); + let right = sample.wrapping_mul(3).wrapping_sub(200); + input.extend_from_slice(&left.to_le_bytes()); + input.extend_from_slice(&right.to_le_bytes()); + } + input +} + +fn synthetic_audio_block(samples: usize) -> Vec { + let mut bits = BitWriter::default(); + + bits.write_bits(0b10, 2); // audio block, do not keep previous tables. + bits.write_bits(0, 2); // one channel. + + for symbol in 0..19 { + let len = if symbol == 1 || symbol == 18 { 1 } else { 0 }; + bits.write_bits(len, 4); + } + + bits.write_bit(false); // level symbol 1: audio delta 0 has code length 1. + bits.write_bit(true); // level symbol 18: 138 zeros. + bits.write_bits(127, 7); + bits.write_bit(true); // level symbol 18: 118 zeros. + bits.write_bits(107, 7); + + for _ in 0..samples { + bits.write_bit(false); // audio delta 0. + } + + bits.finish() +} + +fn write_fresh_audio_block(bits: &mut BitWriter, samples: usize, emit_end_sentinel: bool) { + bits.write_bits(0b10, 2); // audio block, do not keep previous tables. + bits.write_bits(0, 2); // one channel. + + for symbol in 0..19 { + let len = if symbol == 1 || symbol == 18 { 1 } else { 0 }; + bits.write_bits(len, 4); + } + + // Audio table: symbol 0 (delta 0) = "0", symbol 256 (block end) = "1". + bits.write_bit(false); // level symbol 1: audio delta 0 has code length 1. + bits.write_bit(true); // level symbol 18: 138 zeros (audio symbols 1..=138). + bits.write_bits(127, 7); + bits.write_bit(true); // level symbol 18: 117 zeros (audio symbols 139..=255). + bits.write_bits(106, 7); + bits.write_bit(false); // level symbol 1: block-end (256) has code length 1. + + for _ in 0..samples { + bits.write_bit(false); // audio delta 0. + } + if emit_end_sentinel { + bits.write_bit(true); // audio symbol 256: end of audio block. + } +} + +#[test] +fn literal_encoder_round_trips_rar20_lz_blocks() { + let input = b"literal-only RAR 2.0 baseline\nwith repeated text literal-only\n"; + let packed = unpack20_encode_literals(input).unwrap(); + + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_offset_one_matches_for_repeated_bytes() { + let input = b"A".repeat(1024); + let packed = unpack20_encode_literals(&input).unwrap(); + + assert!(packed.len() < input.len() / 4); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_dictionary_matches_for_repeated_sequences() { + let input = b"abc123xyz-".repeat(128); + let packed = unpack20_encode_literals(&input).unwrap(); + + assert!(packed.len() < input.len() / 2); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_repeat_last_matches_for_regular_streams() { + let input = b"\x00\x01\x02\x03".repeat(4096); + let tokens = encode_tokens(&input, &[], EncodeOptions::default(), None); + let packed = unpack20_encode_literals(&input).unwrap(); + + assert!(tokens + .iter() + .any(|token| matches!(token, EncodeToken::RepeatLast))); + assert!(packed.len() < input.len() / 8); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_minimum_length_fresh_matches() { + let input = b"abcabc"; + let tokens = encode_tokens(input, &[], EncodeOptions::default(), None); + let packed = unpack20_encode_literals(input).unwrap(); + + assert!(matches!( + tokens.as_slice(), + [ + EncodeToken::Literal(b'a'), + EncodeToken::Literal(b'b'), + EncodeToken::Literal(b'c'), + EncodeToken::Match { + length: 3, + offset: 3 + } + ] + )); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_short_offset_matches() { + let input = b"abab"; + let tokens = encode_tokens(input, &[], EncodeOptions::default(), None); + let packed = unpack20_encode_literals(input).unwrap(); + + assert!(matches!( + tokens.as_slice(), + [ + EncodeToken::Literal(b'a'), + EncodeToken::Literal(b'b'), + EncodeToken::ShortOffset { offset: 2 } + ] + )); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar20_old_offset_matches() { + let input = b"abcdabcdXYZXYZwxyzwxyz"; + let tokens = encode_tokens(input, &[], EncodeOptions::default(), None); + let packed = unpack20_encode_literals(input).unwrap(); + + assert!(tokens + .iter() + .any(|token| matches!(token, EncodeToken::OldOffset { .. }))); + assert_eq!(unpack20_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_finds_rar20_matches_beyond_near_offsets() { + let phrase = b"long-distance repeated phrase for rar20 match finder."; + let mut input = Vec::new(); + input.extend_from_slice(phrase); + input.extend(std::iter::repeat_n(0, 300 * 1024)); + input.extend_from_slice(phrase); + input.extend_from_slice(phrase); + let tokens = encode_tokens(&input, &[], EncodeOptions::default(), None); + let packed = unpack20_encode_literals(&input).unwrap(); + + assert!(tokens.iter().any(|token| matches!( + token, + EncodeToken::Match { offset, .. } if *offset > 0x40000 + ))); + assert!(packed.len() < input.len()); + let decoded = unpack20_decode(&packed, input.len()).unwrap(); + assert!( + decoded == input, + "RAR 2.0 long-distance match round-trip failed" + ); +} + +#[test] +fn solid_encoder_emits_rar20_matches_against_previous_member_history() { + let first = b"solid rar20 shared phrase alpha beta gamma ".repeat(4); + let second = b"solid rar20 shared phrase alpha beta gamma ".repeat(2); + let independent = unpack20_encode_literals(&second).unwrap(); + let mut encoder = Unpack20Encoder::new(); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(&second).unwrap(); + + assert!(second_packed.len() < independent.len()); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); +} + +#[test] +fn the_optimal_parse_never_loses_to_the_greedy_one() { + // Repeated phrases at varying distances with literal noise between + // them, which is where committing to the first match found costs + // something: the greedy parse takes a short match that a later, longer + // one would have covered for free. + let mut input = Vec::new(); + for round in 0..64u8 { + input.extend_from_slice(b"the quick brown fox jumps over the lazy dog"); + input.extend_from_slice(&[round, round ^ 0x5a, round.wrapping_mul(31)]); + input.extend_from_slice(b"over the lazy dog and the quick brown fox"); + input.push(round ^ 0xa5); + } + + let greedy_options = EncodeOptions::new(256) + .with_lazy_matching(true) + .with_lazy_lookahead(2); + let greedy = super::unpack20_encode_literals_with_options(&input, greedy_options).unwrap(); + let optimal = super::unpack20_encode_literals_with_options( + &input, + greedy_options.with_optimal_parse(true), + ) + .unwrap(); + + assert!( + optimal.len() <= greedy.len(), + "optimal {} greedy {}", + optimal.len(), + greedy.len() + ); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&optimal, input.len()).unwrap(), + input, + "the optimal parse produced something the decoder disagrees with" + ); +} + +#[test] +fn the_optimal_parse_decodes_whatever_it_is_given() { + // Shapes that stress different corners of the parse: nothing to match, + // one long run, matches that reach back exactly to the rep offsets, and + // bytes with no structure at all. + let mut noise = Vec::new(); + let mut seed = 0x9e37_79b9_7f4a_7c15u64; + for _ in 0..8192 { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + noise.push(seed as u8); + } + let cases: Vec> = vec![ + b"a".to_vec(), + b"abc".to_vec(), + vec![0u8; 5000], + (0u8..=255).cycle().take(4096).collect(), + b"xyzzy".repeat(700), + noise, + ]; + + for input in cases { + let options = EncodeOptions::new(256) + .with_lazy_matching(true) + .with_lazy_lookahead(2) + .with_optimal_parse(true); + let packed = super::unpack20_encode_literals_with_options(&input, options).unwrap(); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&packed, input.len()).unwrap(), + input, + "round trip failed for a {} byte member", + input.len() + ); + } +} + +#[test] +fn solid_encoder_reuses_rar20_tables_at_member_boundary() { + let first: Vec<_> = (0u8..=255).cycle().take(4096).collect(); + let second = b"short literal member after reused rar20 table boundary\n"; + let independent = unpack20_encode_literals(second).unwrap(); + let mut encoder = Unpack20Encoder::new(); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(second).unwrap(); + + assert!(second_packed.len() < independent.len()); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); +} + +#[test] +fn solid_encoder_matches_immediately_after_rar20_table_boundary() { + let phrase = b"rar20 table boundary match phrase with enough bytes "; + let first = phrase.repeat(128); + let second = phrase.repeat(8); + let independent = unpack20_encode_literals(&second).unwrap(); + let mut encoder = Unpack20Encoder::new(); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(&second).unwrap(); + let tokens = encode_tokens(&second, &first, EncodeOptions::default(), None); + + assert!(matches!(tokens.first(), Some(EncodeToken::Match { .. }))); + assert!(second_packed.len() < independent.len()); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); +} + +#[test] +fn solid_encoder_carries_rar20_history_across_multiple_members() { + let first = b"rar20 multi member solid seed ".repeat(512); + let second = b"rar20 multi member solid seed with middle tail ".repeat(128); + let third = b"with middle tail ".repeat(64); + let independent = unpack20_encode_literals(&third).unwrap(); + let mut encoder = Unpack20Encoder::new(); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(&second).unwrap(); + let third_packed = encoder.encode_member(&third).unwrap(); + + assert!(third_packed.len() < independent.len()); + let mut decoder = Unpack20::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); + assert_eq!( + decoder.decode_member(&third_packed, third.len()).unwrap(), + third + ); +} + +#[test] +fn decode_member_to_streams_decoded_payload_through_writer_sink() { + let input = b"abcabcabcabcabcabcabcabcabcabcabcabc"; + let packed = unpack20_encode_literals(input).unwrap(); + + let mut decoder = Unpack20::new(); + let mut sink = Vec::new(); + decoder + .decode_member_to(&packed, input.len(), &mut sink) + .unwrap(); + assert_eq!(sink, input); + + // The error-mapping closure inside decode_member_to fires when the + // sink's write_all returns Err — feed it a writer that always fails. + struct FailingWriter; + impl std::io::Write for FailingWriter { + fn write(&mut self, _buf: &[u8]) -> std::io::Result { + Err(std::io::Error::other("disk full")) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let mut decoder = Unpack20::new(); + let err = decoder + .decode_member_to(&packed, input.len(), &mut FailingWriter) + .unwrap_err(); + assert_eq!(err, Error::from(std::io::Error::other("disk full"))); +} diff --git a/arca-rar/vendor/rars/src/codec/rar29.rs b/arca-rar/vendor/rars/src/codec/rar29.rs new file mode 100644 index 00000000..11609bb1 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar29.rs @@ -0,0 +1,1407 @@ +#[cfg(feature = "write")] +mod encoder; +#[cfg(feature = "write")] +pub(crate) use encoder::{ + filtered_members, unpack29_encode_literals_with_options_and_progress, + unpack29_encode_ppmd_with_progress, MAX_VM_DELTA_FILTER_BLOCK_SIZE, +}; +#[cfg(feature = "write")] +pub use encoder::{ + unpack29_encode_literals, unpack29_encode_literals_with_options, unpack29_encode_ppmd, + unpack29_encode_ppmd_literals, unpack29_encode_ppmd_with_filter, ChainEngine, EncodeOptions, + Unpack29Encoder, +}; + +mod standard_filters; +#[cfg(all(test, feature = "write"))] +use standard_filters::{ + apply_standard_filter, apply_standard_filter_with_control, audio_decode_with_control, + itanium_decode, itanium_decode_with_control, rgb_decode_with_control, +}; +use standard_filters::{apply_standard_filter_with_allowance, identify_standard_filter}; + +use super::filters::DeltaErrorMessages; +#[cfg(all(test, feature = "write"))] +use super::filters::MAX_DELTA_CHANNELS; +use super::ppmd::{PpmdByteReader, PpmdState}; +use super::rarvm; +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; +use std::io::{Read, Write}; + +const MAIN_COUNT: usize = 299; +const OFFSET_COUNT: usize = 60; +const LOW_OFFSET_COUNT: usize = 17; +const LENGTH_COUNT: usize = 28; +const LEVEL_COUNT: usize = 20; +const TABLE_COUNT: usize = MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT + LENGTH_COUNT; +const MAX_HISTORY: usize = 4 * 1024 * 1024; +const STREAM_CHUNK: usize = 1024 * 1024; +// RARVM's standard AUDIO filter reserves an eight-bit-ish compatibility +// range wider than WinRAR's usual 1..=4 channel choices. UnRAR accepts up to +// 128; keep this distinct from DELTA's 1024-channel ceiling. +const MAX_AUDIO_CHANNELS: usize = 128; +const MAX_VM_GLOBAL_DATA: usize = 0x2000; +const VM_SYSTEM_GLOBAL_SIZE: usize = 64; +const MAX_VM_USER_GLOBAL_DATA: usize = MAX_VM_GLOBAL_DATA - VM_SYSTEM_GLOBAL_SIZE; +const MAX_VM_CODE_SIZE: usize = 64 * 1024; +const MAX_VM_PROGRAMS: usize = 8192; +const MAX_VM_FILTERS: usize = 8192; + +const LENGTH_BASES: [usize; LENGTH_COUNT] = [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, + 160, 192, 224, +]; +const LENGTH_BITS: [u8; LENGTH_COUNT] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, +]; +const OFFSET_BASES: [usize; OFFSET_COUNT] = [ + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, + 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152, 65536, 98304, 131072, 196608, + 262144, 327680, 393216, 458752, 524288, 589824, 655360, 720896, 786432, 851968, 917504, 983040, + 1048576, 1310720, 1572864, 1835008, 2097152, 2359296, 2621440, 2883584, 3145728, 3407872, + 3670016, 3932160, +]; +const OFFSET_BITS: [u8; OFFSET_COUNT] = [ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, + 13, 14, 14, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 18, 18, 18, 18, + 18, 18, 18, 18, 18, 18, 18, +]; +const SHORT_BASES: [usize; 8] = [0, 4, 8, 16, 32, 64, 128, 192]; +const SHORT_BITS: [u8; 8] = [2, 2, 3, 4, 5, 6, 6, 6]; +const INVALID_MATCH_OFFSET: usize = usize::MAX; + +pub fn unpack29_decode(input: &[u8], output_size: usize) -> Result> { + let mut decoder = Unpack29::new(); + decoder.decode_non_solid_member(input, output_size) +} + +/// The filters the RAR 2.9 family ships as RarVM programs. +/// +/// Narrower than [`crate::FilterKind`], which names every filter any format +/// can apply. The conversion below is where a filter this family cannot encode +/// is turned away. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum Rar29Filter { + E8, + E8E9, + Delta { channels: usize }, + Itanium, + Rgb { width: usize, pos_r: usize }, + Audio { channels: usize }, +} + +impl TryFrom for Rar29Filter { + type Error = crate::UnsupportedFilterKind; + + fn try_from(kind: crate::FilterKind) -> std::result::Result { + use crate::FilterKind as Kind; + match kind { + Kind::E8 => Ok(Self::E8), + Kind::E8E9 => Ok(Self::E8E9), + Kind::Delta { channels } => Ok(Self::Delta { channels }), + Kind::Itanium => Ok(Self::Itanium), + Kind::Rgb { width, pos_r } => Ok(Self::Rgb { width, pos_r }), + Kind::Audio { channels } => Ok(Self::Audio { channels }), + // No wildcard arm: an eighth filter has to be decided about here. + kind @ Kind::Arm => Err(crate::UnsupportedFilterKind(kind)), + } + } +} + +fn rar29_delta_messages() -> DeltaErrorMessages { + DeltaErrorMessages { + invalid_channels: "RAR 2.9 DELTA filter channel count is invalid", + zero_channels: "RAR 2.9 DELTA filter has zero channels", + truncated_source: "RAR 2.9 DELTA filter source is truncated", + } +} + +#[derive(Debug, Clone)] +pub struct Unpack29 { + pub(crate) read_control: crate::read_control::ReadControl, + state: Reader29State, +} +impl Clone for Reader29State { + fn clone(&self) -> Self { + self.try_clone().expect("unlimited RAR3 decoder copy") + } +} +impl Default for Unpack29 { + fn default() -> Self { + Self::new() + } +} +impl Unpack29 { + pub fn new() -> Self { + Self { + read_control: Default::default(), + state: Reader29State::with_allowance(&Allowance::default()), + } + } + pub fn reset_non_solid(&mut self) { + self.state.reset_non_solid(); + } + pub fn decode_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_owned(input, output_size) + .map(Buffer::into_vec) + } + pub fn decode_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state.decode_member_to(input, output_size, out) + } + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader(input, output_size, out) + } + pub fn decode_non_solid_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_non_solid_member_owned(input, output_size) + .map(Buffer::into_vec) + } + pub fn decode_non_solid_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_non_solid_member_to(input, output_size, out) + } + pub fn decode_non_solid_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_non_solid_member_from_reader(input, output_size, out) + } +} +#[derive(Debug)] +pub(crate) struct Reader29State { + pub(crate) read_control: crate::read_control::ReadControl, + bits: BitReader, + levels: [u8; TABLE_COUNT], + main: Huffman, + offsets: Huffman, + low_offsets: Huffman, + lengths: Huffman, + old_offsets: [usize; 4], + last_offset: usize, + last_length: usize, + last_low_offset: usize, + low_offset_repeats: usize, + pending_match: Option<(usize, usize)>, + in_lz_block: bool, + block_mode: BlockMode, + ppmd: PpmdState, + ppmd_esc: u8, + filters: Buffer, B>, + programs: Buffer, B>, + last_filter: usize, + base_offset: usize, + output: Buffer, + last_block_end: Option, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum BlockMode { + Lz, + Ppmd, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum LzBlockEnd { + SameFileNewTable, + NewFileKeepTables, + NewFileNewTables, +} + +fn require_ppmd_symbol(symbol: Option) -> Result { + symbol.ok_or(Error::InvalidData("RAR 2.9 PPMd model is corrupt")) +} + +#[derive(Debug)] +struct VmFilter { + program: usize, + start: usize, + size: usize, + regs: [u32; 7], + global_data: Buffer, +} + +#[derive(Debug)] +struct VmProgram { + kind: VmProgramKind, + block_size: usize, + exec_count: u32, + globals: Buffer, +} + +#[derive(Debug)] +enum VmProgramKind { + Standard(StandardFilter), + Generic(rarvm::OwnedProgram), +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum StandardFilter { + E8, + E8E9, + Itanium, + Delta, + Rgb, + Audio, +} + +impl Reader29State { + pub(crate) fn with_allowance(allowance: &B) -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + bits: BitReader::with_allowance(allowance), + levels: [0; TABLE_COUNT], + main: Huffman::with_allowance(allowance), + offsets: Huffman::with_allowance(allowance), + low_offsets: Huffman::with_allowance(allowance), + lengths: Huffman::with_allowance(allowance), + // UnRAR uses an invalid all-bits-one distance here. If a malformed + // stream repeats a distance before defining one, CopyString sees + // it as unavailable history and writes deterministic zeroes. + old_offsets: [INVALID_MATCH_OFFSET; 4], + last_offset: INVALID_MATCH_OFFSET, + last_length: 0, + last_low_offset: 0, + low_offset_repeats: 0, + pending_match: None, + in_lz_block: false, + block_mode: BlockMode::Lz, + ppmd: PpmdState::with_allowance(allowance), + ppmd_esc: 2, + filters: Buffer::new(allowance), + programs: Buffer::new(allowance), + last_filter: 0, + base_offset: 0, + output: Buffer::new(allowance), + last_block_end: None, + } + } + + pub(crate) fn try_clone(&self) -> Result { + let allowance = self.output.allowance(); + Ok(Self { + read_control: self.read_control.clone(), + bits: self.bits.try_clone()?, + levels: self.levels, + main: self.main.try_clone()?, + offsets: self.offsets.try_clone()?, + low_offsets: self.low_offsets.try_clone()?, + lengths: self.lengths.try_clone()?, + old_offsets: self.old_offsets, + last_offset: self.last_offset, + last_length: self.last_length, + last_low_offset: self.last_low_offset, + low_offset_repeats: self.low_offset_repeats, + pending_match: self.pending_match, + in_lz_block: self.in_lz_block, + block_mode: self.block_mode, + ppmd: self.ppmd.try_clone()?, + ppmd_esc: self.ppmd_esc, + filters: Buffer::try_collect( + self.filters.iter().map(|filter| { + Ok(VmFilter { + program: filter.program, + start: filter.start, + size: filter.size, + regs: filter.regs, + global_data: Buffer::copied(&filter.global_data, &allowance)?, + }) + }), + &allowance, + )?, + programs: Buffer::try_collect( + self.programs.iter().map(|program| { + Ok(VmProgram { + kind: match &program.kind { + VmProgramKind::Standard(kind) => VmProgramKind::Standard(*kind), + VmProgramKind::Generic(program) => { + VmProgramKind::Generic(program.try_clone()?) + } + }, + block_size: program.block_size, + exec_count: program.exec_count, + globals: Buffer::copied(&program.globals, &allowance)?, + }) + }), + &allowance, + )?, + last_filter: self.last_filter, + base_offset: self.base_offset, + output: Buffer::copied(&self.output, &allowance)?, + last_block_end: self.last_block_end, + }) + } + pub fn reset_non_solid(&mut self) { + let control = self.read_control.clone(); + *self = Self::with_allowance(&self.output.allowance()); + self.read_control = control; + } + + pub fn decode_non_solid_member_owned( + &mut self, + input: &[u8], + output_size: usize, + ) -> Result> { + self.read_control.check_codec()?; + self.reset_non_solid(); + self.decode_member_owned(input, output_size) + } + + pub fn decode_non_solid_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + self.reset_non_solid(); + self.decode_member_to(input, output_size, out) + } + + pub fn decode_non_solid_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + self.reset_non_solid(); + self.decode_member_from_reader(input, output_size, out) + } + + pub fn decode_member_owned( + &mut self, + input: &[u8], + output_size: usize, + ) -> Result> { + let mut out = Buffer::new(&self.output.allowance()); + self.decode_member_to(input, output_size, &mut out)?; + Ok(out) + } + + pub fn decode_member_to( + &mut self, + input: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.decode_loaded_member_to(input, output_size, out) + } + + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + self.bits = BitReader::with_allowance(&self.output.allowance()); + self.bits.input.read_to_end(input)?; + self.decode_bits_member_to(output_size, out) + } + + /// Decodes one complete packed member while retaining solid dictionary, + /// table, PPMd and VM state for the next member. + fn decode_loaded_member_to( + &mut self, + packed: &[u8], + output_size: usize, + out: &mut impl Write, + ) -> Result<()> { + self.read_control.check_codec()?; + self.bits = BitReader::from_bytes_with_allowance(packed, &self.output.allowance())?; + self.decode_bits_member_to(output_size, out) + } + fn decode_bits_member_to(&mut self, output_size: usize, out: &mut impl Write) -> Result<()> { + // `last_block_end` describes control flow within one member. A solid + // follower legitimately starts after the previous member's new-file + // marker, so do not mistake that marker for an early end in this one. + self.last_block_end = None; + let start = self.current_pos(); + let final_target = start + .checked_add(output_size) + .ok_or(Error::InvalidData("RAR 2.9 output size overflows"))?; + let mut flushed = start; + let mut target = start.saturating_add(STREAM_CHUNK).min(final_target); + // Empty members in solid mode still carry their own block init bytes + // (typically the (esc, 0) end-of-block marker + 4-byte range coder + // flush). When output_size is zero, decode_until skips its loop body + // and never reads tables, so do the init here so finish_member can + // observe the block end. + if final_target == start && !self.in_lz_block && !self.bits.input.is_empty() { + self.read_tables().map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.9 bitstream is truncated"), + error => error, + })?; + self.in_lz_block = true; + } + + while flushed < final_target { + self.decode_until(target).map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.9 bitstream is truncated"), + error => error, + })?; + + let safe_end = self.safe_flush_end(flushed, target, final_target)?; + if safe_end <= flushed { + target = self + .current_pos() + .saturating_add(STREAM_CHUNK) + .min(final_target); + continue; + } + + let decoded = self.filtered_range_owned(flushed, safe_end, start)?; + out.write_all(&decoded).map_err(Error::from)?; + flushed = safe_end; + self.trim_history(flushed, self.current_pos()); + target = self + .current_pos() + .saturating_add(STREAM_CHUNK) + .min(final_target); + } + if self.pending_match.is_some() { + return Err(Error::InvalidData( + "RAR 2.9 member produces more output than its declared size", + )); + } + self.finish_member().map_err(|error| match error { + Error::NeedMoreInput => Error::InvalidData("RAR 2.9 bitstream is truncated"), + error => error, + })?; + Ok(()) + } + + fn decode_until(&mut self, target: usize) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.current_pos() < target { + poller.check_codec(self.current_pos())?; + self.drain_pending_match(target)?; + if self.current_pos() >= target { + break; + } + if !self.in_lz_block { + if matches!( + self.last_block_end, + Some(LzBlockEnd::NewFileKeepTables | LzBlockEnd::NewFileNewTables) + ) { + return Err(Error::InvalidData( + "RAR 2.9 member ended before its declared size", + )); + } + self.read_tables()?; + self.in_lz_block = true; + } + match self.block_mode { + BlockMode::Lz => self.decode_lz(target)?, + BlockMode::Ppmd => self.decode_ppmd(target)?, + } + } + Ok(()) + } + + fn read_tables(&mut self) -> Result<()> { + self.bits.align_byte(); + if self.bits.peek_bit()? != 0 { + let first_byte = self.bits.read_bits(8)? as u8; + self.ppmd.set_read_control(self.read_control.clone()); + self.ppmd + .decode_init(first_byte, &mut self.bits, &mut self.ppmd_esc)?; + self.block_mode = BlockMode::Ppmd; + return Ok(()); + } + self.bits.read_bit()?; + self.block_mode = BlockMode::Lz; + let keep_tables = self.bits.read_bit()? != 0; + self.last_low_offset = 0; + self.low_offset_repeats = 0; + if !keep_tables { + self.levels = [0; TABLE_COUNT]; + } + + let level_lengths = Self::read_level_lengths(&mut self.bits)?; + let level_decoder = + Huffman::from_lengths_with_allowance(&level_lengths, &self.output.allowance())?; + let mut new_levels = [0u8; TABLE_COUNT]; + let mut pos = 0usize; + while pos < TABLE_COUNT { + let symbol = level_decoder.decode(&mut self.bits)?; + match symbol { + 0..=15 => { + new_levels[pos] = (self.levels[pos].wrapping_add(symbol as u8)) & 0x0f; + pos += 1; + } + 16 => { + if pos == 0 { + return Err(Error::InvalidData("RAR 2.9 table repeat at start")); + } + let count = 3 + self.bits.read_bits(3)? as usize; + let value = new_levels[pos - 1]; + fill_levels(&mut new_levels, &mut pos, count, value)?; + } + 17 => { + if pos == 0 { + return Err(Error::InvalidData("RAR 2.9 long table repeat at start")); + } + let count = 11 + self.bits.read_bits(7)? as usize; + let value = new_levels[pos - 1]; + fill_levels(&mut new_levels, &mut pos, count, value)?; + } + 18 => { + let count = 3 + self.bits.read_bits(3)? as usize; + fill_levels(&mut new_levels, &mut pos, count, 0)?; + } + _ => { + let count = 11 + self.bits.read_bits(7)? as usize; + fill_levels(&mut new_levels, &mut pos, count, 0)?; + } + } + } + + self.levels = new_levels; + self.main = Huffman::from_lengths_with_allowance( + &self.levels[..MAIN_COUNT], + &self.output.allowance(), + )?; + self.offsets = Huffman::from_lengths_with_allowance( + &self.levels[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT], + &self.output.allowance(), + )?; + self.low_offsets = Huffman::from_lengths_with_allowance( + &self.levels[MAIN_COUNT + OFFSET_COUNT..MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT], + &self.output.allowance(), + )?; + self.lengths = Huffman::from_lengths_with_allowance( + &self.levels[MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT..], + &self.output.allowance(), + )?; + Ok(()) + } + + fn read_level_lengths(bits: &mut BitReader) -> Result<[u8; LEVEL_COUNT]> { + let mut lengths = [0u8; LEVEL_COUNT]; + let mut pos = 0usize; + while pos < LEVEL_COUNT { + let value = bits.read_bits(4)? as u8; + if value == 15 { + let zero_count = bits.read_bits(4)? as usize; + if zero_count == 0 { + lengths[pos] = 15; + pos += 1; + } else { + pos = pos.saturating_add(zero_count + 2).min(LEVEL_COUNT); + } + } else { + lengths[pos] = value; + pos += 1; + } + } + Ok(lengths) + } + + fn decode_lz(&mut self, output_size: usize) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.current_pos() < output_size { + poller.check_codec(self.current_pos())?; + let symbol = self.main.decode(&mut self.bits)?; + match symbol { + 0..=255 => self.output.try_push(symbol as u8)?, + 256 => { + self.read_end_of_block()?; + return Ok(()); + } + 257 => { + self.read_vm_code()?; + } + 258 => { + if self.last_length != 0 { + self.copy_match(self.last_length, self.last_offset, output_size)?; + } + } + 259..=262 => { + let index = symbol - 259; + let offset = self.old_offsets[index]; + let length_slot = self.lengths.decode(&mut self.bits)?; + let mut length = LENGTH_BASES[length_slot] + 2; + if LENGTH_BITS[length_slot] != 0 { + length += self.bits.read_bits(LENGTH_BITS[length_slot])? as usize; + } + self.rotate_old_offset(index); + self.last_offset = offset; + self.last_length = length; + self.copy_match(length, offset, output_size)?; + } + 263..=270 => { + let index = symbol - 263; + let mut offset = SHORT_BASES[index] + 1; + offset += self.bits.read_bits(SHORT_BITS[index])? as usize; + self.push_old_offset(offset); + self.last_offset = offset; + self.last_length = 2; + self.copy_match(2, offset, output_size)?; + } + _ => { + let length_slot = symbol - 271; + let mut length = LENGTH_BASES[length_slot] + 3; + if LENGTH_BITS[length_slot] != 0 { + length += self.bits.read_bits(LENGTH_BITS[length_slot])? as usize; + } + let offset = self.read_offset()?; + if offset >= 0x2000 { + length += 1; + } + if offset >= 0x40000 { + length += 1; + } + self.push_old_offset(offset); + self.last_offset = offset; + self.last_length = length; + self.copy_match(length, offset, output_size)?; + } + } + } + Ok(()) + } + + fn decode_ppmd(&mut self, output_size: usize) -> Result<()> { + let mut poller = self.read_control.poller(); + while self.current_pos() < output_size { + poller.check_codec(self.current_pos())?; + let symbol = require_ppmd_symbol(self.ppmd.decode_symbol(&mut self.bits)?)?; + if symbol != self.ppmd_esc { + self.output.try_push(symbol)?; + continue; + } + + let next = require_ppmd_symbol(self.ppmd.decode_symbol(&mut self.bits)?)?; + match next { + 0 => { + self.in_lz_block = false; + return Ok(()); + } + 1 => self.output.try_push(self.ppmd_esc)?, + 2 => { + return Err(Error::InvalidData( + "RAR 2.9 member ended before its declared size", + )); + } + 3 => { + self.read_vm_code_ppmd()?; + } + 4 => { + let mut offset = 0usize; + for _ in 0..3 { + offset = (offset << 8) | self.read_ppmd_required_byte()? as usize; + } + offset += 2; + let length = self.read_ppmd_required_byte()? as usize + 32; + self.copy_match(length, offset, output_size)?; + } + 5 => { + let length = self.read_ppmd_required_byte()? as usize + 4; + self.copy_match(length, 1, output_size)?; + } + 6..=u8::MAX => { + return Err(Error::InvalidData("RAR 2.9 PPMd command is invalid")); + } + } + } + Ok(()) + } + + fn read_ppmd_required_byte(&mut self) -> Result { + require_ppmd_symbol(self.ppmd.decode_symbol(&mut self.bits)?) + } + + fn finish_ppmd_member(&mut self) -> Result { + let symbol = require_ppmd_symbol(self.ppmd.decode_symbol(&mut self.bits)?)?; + if symbol != self.ppmd_esc { + return Err(Error::InvalidData("RAR 2.9 PPMd member has trailing data")); + } + let next = require_ppmd_symbol(self.ppmd.decode_symbol(&mut self.bits)?)?; + match next { + 2 => { + self.in_lz_block = false; + Ok(true) + } + 0 => { + self.in_lz_block = false; + self.read_tables()?; + self.in_lz_block = true; + Ok(false) + } + _ => Err(Error::InvalidData("RAR 2.9 PPMd member has trailing data")), + } + } + + fn finish_member(&mut self) -> Result<()> { + loop { + let finished = match self.block_mode { + BlockMode::Lz => self.finish_lz_member()?, + BlockMode::Ppmd => self.finish_ppmd_member()?, + }; + if finished { + return Ok(()); + } + } + } + + fn finish_lz_member(&mut self) -> Result { + if !self.in_lz_block { + return Ok(true); + } + let symbol = self.main.decode(&mut self.bits)?; + if symbol != 256 { + return Err(Error::InvalidData("RAR 2.9 LZ member has trailing data")); + } + match self.read_end_of_block()? { + LzBlockEnd::SameFileNewTable => { + self.read_tables()?; + self.in_lz_block = true; + Ok(false) + } + LzBlockEnd::NewFileKeepTables | LzBlockEnd::NewFileNewTables => Ok(true), + } + } + + fn read_end_of_block(&mut self) -> Result { + let end = self.read_end_of_block_inner()?; + self.last_block_end = Some(end); + Ok(end) + } + + fn read_end_of_block_inner(&mut self) -> Result { + if self.bits.read_bit()? != 0 { + self.in_lz_block = false; + return Ok(LzBlockEnd::SameFileNewTable); + } + if self.bits.read_bit()? != 0 { + self.in_lz_block = false; + Ok(LzBlockEnd::NewFileNewTables) + } else { + self.in_lz_block = true; + Ok(LzBlockEnd::NewFileKeepTables) + } + } + + fn read_offset(&mut self) -> Result { + let slot = self.offsets.decode(&mut self.bits)?; + let mut offset = OFFSET_BASES[slot] + 1; + let extra_bits = OFFSET_BITS[slot]; + if extra_bits != 0 { + if slot > 9 { + if extra_bits > 4 { + offset += (self.bits.read_bits(extra_bits - 4)? as usize) << 4; + } + if self.low_offset_repeats > 0 { + self.low_offset_repeats -= 1; + offset += self.last_low_offset; + } else { + let low = self.low_offsets.decode(&mut self.bits)?; + if low == 16 { + self.low_offset_repeats = 15; + offset += self.last_low_offset; + } else { + self.last_low_offset = low; + offset += low; + } + } + } else { + offset += self.bits.read_bits(extra_bits)? as usize; + } + } + Ok(offset) + } + + fn read_vm_code(&mut self) -> Result<()> { + let mut poller = self.read_control.poller(); + let first_byte = self.bits.read_bits(8)?; + let mut len = (first_byte & 7) + 1; + if len == 7 { + len = self.bits.read_bits(8)? + 7; + } else if len == 8 { + len = self.bits.read_bits(16)?; + } + let mut data = Buffer::with_capacity(len as usize, &self.output.allowance())?; + for _ in 0..len { + poller.check_codec(data.len())?; + data.push_admitted(self.bits.read_bits(8)? as u8); + } + + self.parse_vm_code_owned(first_byte, data) + } + + fn read_vm_code_ppmd(&mut self) -> Result<()> { + let mut poller = self.read_control.poller(); + let first_byte = u32::from(self.read_ppmd_required_byte()?); + let mut len = (first_byte & 7) + 1; + if len == 7 { + len = u32::from(self.read_ppmd_required_byte()?) + 7; + } else if len == 8 { + len = (u32::from(self.read_ppmd_required_byte()?) << 8) + | u32::from(self.read_ppmd_required_byte()?); + } + let mut data = Buffer::with_capacity(len as usize, &self.output.allowance())?; + for _ in 0..len { + poller.check_codec(data.len())?; + data.push_admitted(self.read_ppmd_required_byte()?); + } + + self.parse_vm_code_owned(first_byte, data) + } + + fn parse_vm_code_owned(&mut self, first_byte: u32, data: Buffer) -> Result<()> { + let mut vm = BitReader { + input: data, + bit_pos: 0, + }; + let program_index = if first_byte & 0x80 != 0 { + let value = vm.read_encoded_u32()?; + if value == 0 { + self.filters.clear(); + self.programs.clear(); + 0 + } else { + usize::try_from(value - 1) + .map_err(|_| Error::InvalidData("RAR 2.9 VM program index overflows"))? + } + } else { + self.last_filter + }; + if program_index > self.programs.len() { + return Err(Error::InvalidData("RAR 2.9 VM program index is invalid")); + } + self.last_filter = program_index; + let new_program = program_index == self.programs.len(); + + let mut block_start = vm.read_encoded_u32()? as usize; + if first_byte & 0x40 != 0 { + block_start += 258; + } + block_start = self + .current_pos() + .checked_add(block_start) + .ok_or(Error::InvalidData("RAR 2.9 VM block start overflows"))?; + + let mut block_size = self + .programs + .get(program_index) + .map(|program| program.block_size) + .unwrap_or(0); + if first_byte & 0x20 != 0 { + block_size = vm.read_encoded_u32()? as usize; + } + + let mut regs = [0u32; 7]; + regs[3] = 0x3c000; + regs[4] = block_size as u32; + if let Some(program) = self.programs.get(program_index) { + regs[5] = program.exec_count; + } + if first_byte & 0x10 != 0 { + let mask = vm.read_bits(7)?; + for (index, reg) in regs.iter_mut().enumerate() { + if mask & (1 << index) != 0 { + *reg = vm.read_encoded_u32()?; + } + } + } + + if new_program { + if self.programs.len() >= MAX_VM_PROGRAMS { + return Err(Error::InvalidData("RAR 2.9 VM program limit exceeded")); + } + let code_size = vm.read_encoded_u32()? as usize; + if code_size == 0 { + return Err(Error::InvalidData("RAR 2.9 VM code is empty")); + } + if code_size >= MAX_VM_CODE_SIZE { + return Err(Error::InvalidData("RAR 2.9 VM code is too large")); + } + let mut code = Buffer::with_capacity(code_size, &self.output.allowance())?; + for _ in 0..code_size { + code.push_admitted(vm.read_bits(8)? as u8); + } + let kind = identify_standard_filter(&code) + .map(VmProgramKind::Standard) + .map_or_else( + || { + rarvm::OwnedProgram::parse(&code, &self.output.allowance()) + .map(VmProgramKind::Generic) + }, + Ok, + )?; + self.programs.try_push(VmProgram { + kind, + block_size, + exec_count: 0, + globals: Buffer::new(&self.output.allowance()), + })?; + } else { + // Equality is the new-program case above, and greater indices were + // rejected before parsing the record. + let program = &mut self.programs[program_index]; + program.exec_count = program.exec_count.wrapping_add(1); + program.block_size = block_size; + } + + let mut global_data = Buffer::new(&self.output.allowance()); + if first_byte & 0x08 != 0 { + let data_size = vm.read_encoded_u32()? as usize; + if data_size > MAX_VM_USER_GLOBAL_DATA { + return Err(Error::InvalidData("RAR 2.9 VM global data is too large")); + } + global_data = + Buffer::with_capacity(VM_SYSTEM_GLOBAL_SIZE + data_size, &self.output.allowance())?; + global_data.resize(VM_SYSTEM_GLOBAL_SIZE, 0)?; + for _ in 0..data_size { + global_data.push_admitted(vm.read_bits(8)? as u8); + } + } + + if self.filters.len() >= MAX_VM_FILTERS { + return Err(Error::InvalidData("RAR 2.9 VM filter limit exceeded")); + } + self.filters.try_push(VmFilter { + program: program_index, + start: block_start, + size: block_size, + regs, + global_data, + })?; + Ok(()) + } + + fn filtered_range_owned( + &mut self, + start: usize, + end: usize, + member_start: usize, + ) -> Result> { + let mut out = Buffer::with_capacity(end - start, &self.output.allowance())?; + let mut pos = start; + let filters = Buffer::collect( + self.filters + .iter() + .enumerate() + .filter_map(|(index, filter)| { + (filter.start >= start && filter.start + filter.size <= end).then_some(index) + }), + &self.output.allowance(), + )?; + let mut applied = Buffer::filled(self.filters.len(), false, &self.output.allowance())?; + let mut index = 0; + while index < filters.len() { + let first = self + .filters + .get(filters[index]) + .ok_or(Error::InvalidData("RAR 2.9 VM filter is missing"))?; + let filter_start = first.start; + let filter_size = first.size; + if filter_start < pos { + return Err(Error::InvalidData("RAR 2.9 VM filters partially overlap")); + } + out.extend_from_slice(self.raw_range(pos, filter_start)?) + .map_err(Into::into)?; + let mut block = Buffer::copied( + self.raw_range(filter_start, filter_start + filter_size)?, + &self.output.allowance(), + )?; + let file_offset = filter_start + .checked_sub(member_start) + .ok_or(Error::InvalidData("RAR 2.9 VM filter starts before file"))? + as u32; + loop { + let (program_index, regs, global_data) = { + let filter = self + .filters + .get(filters[index]) + .ok_or(Error::InvalidData("RAR 2.9 VM filter is missing"))?; + (filter.program, filter.regs, &filter.global_data) + }; + let program = self + .programs + .get_mut(program_index) + .ok_or(Error::InvalidData("RAR 2.9 VM program is missing"))?; + match &program.kind { + VmProgramKind::Standard(standard) => apply_standard_filter_with_allowance( + *standard, + &mut block, + file_offset, + ®s, + &self.read_control, + )?, + VmProgramKind::Generic(generic) => { + let globals = if global_data.is_empty() { + &program.globals[..] + } else { + &global_data[..] + }; + let result = generic.execute_with_control( + rarvm::Invocation { + input: &block, + regs, + global_data: globals, + file_offset: file_offset as u64, + exec_count: program.exec_count, + }, + &self.read_control, + )?; + program.globals = result.globals; + block = result.output; + } + } + applied[filters[index]] = true; + index += 1; + let Some(next) = filters.get(index).and_then(|&next| self.filters.get(next)) else { + break; + }; + if next.start != filter_start || next.size != block.len() { + break; + } + } + out.extend_from_slice(&block).map_err(Into::into)?; + pos = filter_start + filter_size; + } + out.extend_from_slice(self.raw_range(pos, end)?) + .map_err(Into::into)?; + let mut index = 0; + self.filters.retain(|_| { + let keep = !applied[index]; + index += 1; + keep + }); + Ok(out) + } + + fn safe_flush_end(&self, start: usize, end: usize, final_target: usize) -> Result { + let current = self.current_pos(); + let mut safe_end = end; + for filter in &self.filters { + let filter_end = filter + .start + .checked_add(filter.size) + .ok_or(Error::InvalidData("RAR 2.9 VM filter size overflows"))?; + if filter.start >= safe_end || filter_end <= start { + continue; + } + if filter_end > final_target { + return Err(Error::InvalidData( + "RAR 2.9 VM filter extends beyond output", + )); + } + if filter_end > current { + safe_end = safe_end.min(filter.start); + } + } + Ok(safe_end) + } + + fn copy_match(&mut self, length: usize, offset: usize, output_size: usize) -> Result<()> { + // A match reaching past the start of the stream writes zeroes rather + // than failing. Current UnRAR makes the same decision with its + // first-window flag, and libarchive reads from a zero-initialized + // circular dictionary. The decision is taken once for the whole + // match: a copy does not start on zeroes and cross into real bytes + // partway. + let before_window = offset > self.current_pos(); + for index in 0..length { + if self.current_pos() >= output_size { + self.pending_match = Some((length - index, offset)); + break; + } + let byte = if before_window { + 0 + } else { + let src = self.current_pos() - offset; + *self + .raw_byte(src) + .ok_or(Error::InvalidData("RAR 2.9 match distance is out of range"))? + }; + self.output.try_push(byte)?; + } + Ok(()) + } + + fn drain_pending_match(&mut self, output_size: usize) -> Result<()> { + let Some((length, offset)) = self.pending_match.take() else { + return Ok(()); + }; + self.copy_match(length, offset, output_size) + } + + fn push_old_offset(&mut self, offset: usize) { + self.old_offsets[3] = self.old_offsets[2]; + self.old_offsets[2] = self.old_offsets[1]; + self.old_offsets[1] = self.old_offsets[0]; + self.old_offsets[0] = offset; + } + + fn rotate_old_offset(&mut self, index: usize) { + let value = self.old_offsets[index]; + for i in (1..=index).rev() { + self.old_offsets[i] = self.old_offsets[i - 1]; + } + self.old_offsets[0] = value; + } + + fn current_pos(&self) -> usize { + self.base_offset + self.output.len() + } + + fn raw_byte(&self, position: usize) -> Option<&u8> { + self.output.get(position.checked_sub(self.base_offset)?) + } + + fn raw_range(&self, start: usize, end: usize) -> Result<&[u8]> { + if start < self.base_offset || end < start { + return Err(Error::InvalidData( + "RAR 2.9 retained history is unavailable", + )); + } + let rel_start = start - self.base_offset; + let rel_end = end - self.base_offset; + self.output + .get(rel_start..rel_end) + .ok_or(Error::InvalidData( + "RAR 2.9 retained history is unavailable", + )) + } + + fn trim_history(&mut self, flushed_pos: usize, current_pos: usize) { + let keep_from = current_pos.saturating_sub(MAX_HISTORY); + let keep_from = keep_from.min(flushed_pos); + if keep_from <= self.base_offset { + return; + } + let drain = keep_from - self.base_offset; + self.output.discard_prefix(drain); + self.base_offset = keep_from; + self.filters + .retain(|filter| filter.start + filter.size > self.base_offset); + } +} + +#[cfg(all(test, feature = "write"))] +impl Reader29State { + fn filtered_range(&mut self, start: usize, end: usize, member_start: usize) -> Result> { + self.filtered_range_owned(start, end, member_start) + .map(Buffer::into_vec) + } + fn parse_vm_code(&mut self, first_byte: u32, data: Vec) -> Result<()> { + self.parse_vm_code_owned(first_byte, data.into()) + } + + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } + fn decode_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.decode_member_owned(input, output_size) + .map(Buffer::into_vec) + } + fn decode_non_solid_member(&mut self, input: &[u8], output_size: usize) -> Result> { + self.decode_non_solid_member_owned(input, output_size) + .map(Buffer::into_vec) + } +} +fn fill_levels(levels: &mut [u8], pos: &mut usize, count: usize, value: u8) -> Result<()> { + let end = pos + .checked_add(count) + .ok_or(Error::InvalidData("RAR 2.9 table run overflows"))?; + let end = end.min(levels.len()); + for item in &mut levels[*pos..end] { + *item = value; + } + *pos = end; + Ok(()) +} + +#[derive(Debug)] +struct Huffman { + state: super::canonical::Huffman, +} + +impl Huffman { + fn with_allowance(allowance: &B) -> Self { + Self { + state: super::canonical::Huffman::with_allowance(allowance), + } + } + fn from_lengths_with_allowance(lengths: &[u8], allowance: &B) -> Result { + let mut count = [0u16; 16]; + for &len in lengths { + if len != 0 { + count[len as usize] += 1; + } + } + if count.iter().all(|&value| value == 0) { + return Ok(Self::with_allowance(allowance)); + } + validate_huffman_counts(&count)?; + + Ok(Self { + state: super::canonical::Huffman::from_counts(lengths, count, allowance)?, + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + state: self.state.try_clone()?, + }) + } + fn decode(&self, bits: &mut BitReader) -> Result { + self.state.decode( + || bits.read_bit().map(|bit| bit as u16), + "RAR 2.9 empty Huffman table", + "RAR 2.9 invalid Huffman code", + ) + } +} + +#[cfg(all(test, feature = "write"))] +impl Huffman { + fn from_lengths(lengths: &[u8]) -> Result { + Self::from_lengths_with_allowance(lengths, &Allowance::default()) + } +} + +fn validate_huffman_counts(count: &[u16; 16]) -> Result<()> { + super::canonical::validate_counts(count, "RAR 2.9 oversubscribed Huffman table") +} + +#[derive(Debug)] +struct BitReader { + input: Buffer, + bit_pos: usize, +} + +impl BitReader { + fn with_allowance(allowance: &B) -> Self { + Self { + input: Buffer::new(allowance), + bit_pos: 0, + } + } + + fn from_bytes_with_allowance(input: &[u8], allowance: &B) -> Result { + Ok(Self { + input: Buffer::copied(input, allowance)?, + bit_pos: 0, + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + input: Buffer::copied(&self.input, &self.input.allowance())?, + bit_pos: self.bit_pos, + }) + } + + #[cfg(all(test, feature = "write"))] + fn append(&mut self, input: &[u8]) { + self.compact(); + self.input + .extend_from_slice(input) + .map_err(Into::into) + .expect("test input allowance"); + } + + #[cfg(all(test, feature = "write"))] + fn compact(&mut self) { + let bytes = self.bit_pos / 8; + if bytes == 0 { + return; + } + self.input.discard_prefix(bytes); + self.bit_pos -= bytes * 8; + } + + fn align_byte(&mut self) { + self.bit_pos = (self.bit_pos + 7) & !7; + } + + fn peek_bit(&self) -> Result { + self.peek_bits(1).map(|value| value as u8) + } + + fn read_bit(&mut self) -> Result { + self.read_bits(1).map(|value| value as u8) + } + + fn read_bits(&mut self, count: u8) -> Result { + let value = self.peek_bits(count)?; + self.bit_pos += count as usize; + Ok(value) + } + + fn peek_bits(&self, count: u8) -> Result { + if count > 24 { + return Err(Error::InvalidData("RAR 2.9 bit read is too wide")); + } + let mut value = 0u32; + for i in 0..count as usize { + let bit_index = self.bit_pos + i; + let byte = *self.input.get(bit_index / 8).ok_or(Error::NeedMoreInput)?; + let bit = (byte >> (7 - (bit_index % 8))) & 1; + value = (value << 1) | bit as u32; + } + Ok(value) + } + + fn read_encoded_u32(&mut self) -> Result { + match self.read_bits(2)? { + 0 => self.read_bits(4), + 1 => { + let high = self.read_bits(8)?; + if high >= 16 { + Ok(high) + } else { + Ok(0xffff_ff00 | (high << 4) | self.read_bits(4)?) + } + } + 2 => self.read_bits(16), + _ => Ok((self.read_bits(16)? << 16) | self.read_bits(16)?), + } + } +} + +impl PpmdByteReader for BitReader { + fn read_ppmd_byte(&mut self) -> Result { + self.read_bits(8).map(|value| value as u8) + } +} + +#[cfg(all(test, feature = "write"))] +impl BitReader { + fn from_bytes(input: &[u8]) -> Self { + Self::from_bytes_with_allowance(input, &Allowance::default()).expect("unlimited RAR3 input") + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar29/encoder.rs b/arca-rar/vendor/rars/src/codec/rar29/encoder.rs new file mode 100644 index 00000000..481abd94 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar29/encoder.rs @@ -0,0 +1,2321 @@ +//! RAR29 LZ and PPMd encoding, filter preparation and table emission. +use super::super::ppmd::{PpmdDecoder, PpmdEncoder}; +use super::super::{ + filters::{self, FilterOp}, + huffman, match_finder, +}; +use super::standard_filters::rgb_predict; +use super::*; + +const MAX_VM_FILTER_BLOCK_SIZE: usize = 128 * 1024; +// The standard AUDIO bytecode uses separate input/output regions inside RARVM +// memory. Keep generated blocks below the overlap boundary accepted by period +// decoders. +pub(crate) const MAX_VM_DELTA_FILTER_BLOCK_SIZE: usize = 120_000; +const MAX_VM_AUDIO_FILTER_BLOCK_SIZE: usize = 120_000; +const MAX_ENCODER_MATCH_OFFSET: usize = 1024 * 1024; +const MAX_ENCODER_MATCH_LENGTH: usize = 258; +const MAX_MATCH_CANDIDATES: usize = 256; +const MAX_PPMD_MATCH_LENGTH: usize = 255; +const MIN_PPMD_MATCH_LENGTH: usize = 32; +const MAX_PPMD_REPEAT_LENGTH: usize = 259; +// The parameters rar 3.00 itself declares at -m5, read out of its streams. +const PPMD_ORDER: usize = 8; +const PPMD_DICTIONARY_MB: u8 = 25; +const PPMD_ESC: u8 = 2; +// Seeds and weights for the escape-token cost model in `encode_ppmd_hybrid`. +// The seeds only steer the first few decisions; measured costs take over as +// the member is coded. All five are tuning knobs, not format constants. +const PPMD_LITERAL_BITS_SEED: f64 = 4.0; +const PPMD_MATCH_BITS_SEED: f64 = 60.0; +const PPMD_REPEAT_BITS_SEED: f64 = 24.0; +const PPMD_LITERAL_EMA_WEIGHT: f64 = 1.0 / 32.0; +const PPMD_TOKEN_EMA_WEIGHT: f64 = 1.0 / 8.0; +// An escape token's copied bytes never reach the model, so the literals right +// after it are predicted from the token's own bytes and pay for the broken +// context. That cost lands on the literals' ledger, not the token's, so the +// token is charged a flat estimate of it here. +const PPMD_CONTEXT_BREAK_BITS: f64 = 16.0; +// After a match is priced out, nearby positions almost always price out the +// same way, so the search sleeps a few bytes rather than re-walking the hash +// chain at every literal. +const PPMD_REJECT_SEARCH_COOLDOWN: usize = 8; + +type Rar29MatchFinder = match_finder::MatchFinder<4>; + +// RAR 3.x standard filters are stored as RARVM bytecode in the compressed +// stream. RAR15_40_FORMAT_SPECIFICATION.md §20 and FILTER_TRANSFORMS.md §9 +// define these blobs by byte length plus CRC32 fingerprint; keep the bytes +// verbatim so writer output and reader recognition use the same wire identity. +const RAR3_E8_FILTER_BYTECODE: &[u8] = &[ + 0x97, 0x1b, 0x01, 0x28, 0x07, 0x06, 0x98, 0x08, 0x00, 0x00, 0x00, 0xd1, 0x3a, 0x10, 0x15, 0x92, + 0xec, 0x50, 0xcb, 0x99, 0x20, 0xb9, 0x25, 0xf0, 0x29, 0x19, 0x15, 0x53, 0x03, 0x12, 0xae, 0x51, + 0x10, 0x35, 0x59, 0x2b, 0x60, 0x04, 0x15, 0x6d, 0x40, 0x66, 0xab, 0x02, 0x34, 0x49, 0x04, 0x36, + 0x02, 0x52, 0x3e, 0x97, 0x00, +]; +const RAR3_E8E9_FILTER_BYTECODE: &[u8] = &[ + 0x84, 0x1b, 0x01, 0x28, 0x11, 0x10, 0x69, 0x80, 0x80, 0x00, 0x00, 0x0d, 0x13, 0xa1, 0x01, 0xc6, + 0x89, 0xd2, 0x80, 0xac, 0x97, 0x62, 0x85, 0x5c, 0xc9, 0x05, 0xc9, 0x2f, 0x81, 0x48, 0xc8, 0xaa, + 0x98, 0x18, 0x95, 0x72, 0x88, 0x81, 0xaa, 0xc9, 0x5b, 0x00, 0x20, 0xab, 0x6a, 0x03, 0x35, 0x58, + 0x11, 0xa2, 0x48, 0x21, 0xb0, 0x12, 0x91, 0xf4, 0xb8, +]; +const RAR3_DELTA_FILTER_BYTECODE: &[u8] = &[ + 0x2f, 0x01, 0x9a, 0x41, 0x80, 0xec, 0x27, 0x48, 0x2f, 0x09, 0x76, 0x6d, 0xd3, 0xea, 0x41, 0x5b, + 0x59, 0x44, 0xe8, 0x17, 0x5c, 0xe1, 0x6c, 0x91, 0x4c, 0x4e, 0x3f, 0x77, 0x00, +]; +const RAR3_ITANIUM_FILTER_BYTECODE: &[u8] = &[ + 0x46, 0x9e, 0x08, 0x08, 0x0c, 0x0c, 0x00, 0x00, 0x0e, 0x0e, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, + 0x00, 0x00, 0x6c, 0x11, 0x5a, 0x04, 0xac, 0x0c, 0xc4, 0xcc, 0x5c, 0x08, 0x18, 0x46, 0x24, 0x08, + 0xf9, 0xa0, 0x44, 0x25, 0x12, 0x12, 0x45, 0x85, 0x99, 0x0c, 0x14, 0x00, 0x26, 0x25, 0x58, 0x99, + 0x90, 0x03, 0x38, 0x1a, 0x08, 0xdc, 0x02, 0x30, 0x0c, 0x4e, 0xd1, 0x1d, 0x89, 0xa1, 0xe2, 0xd0, + 0x55, 0x11, 0x33, 0x60, 0x8c, 0x5a, 0x23, 0x06, 0xde, 0x06, 0x18, 0x00, 0x7f, 0xff, 0xfc, 0x4d, + 0xcc, 0x19, 0x17, 0xb3, 0x06, 0xc4, 0x44, 0xb2, 0x32, 0x5a, 0x44, 0xc4, 0xa6, 0x01, 0xf4, 0x24, + 0x88, 0x83, 0x38, 0xcc, 0xc4, 0x11, 0x09, 0x87, 0xa6, 0xe0, 0x46, 0x02, 0xb2, 0x24, 0x03, 0xe2, + 0xa0, 0x32, 0x54, 0x83, 0x52, 0xc5, 0xb1, 0x70, +]; +const RAR3_RGB_FILTER_BYTECODE: &[u8] = &[ + 0xc5, 0x01, 0x9a, 0x41, 0x95, 0xc9, 0xa6, 0x4d, 0xba, 0x4b, 0x14, 0x0a, 0xf4, 0x9b, 0x80, 0x4c, + 0x00, 0x15, 0xa6, 0xa8, 0x07, 0x26, 0x2a, 0xc9, 0xc4, 0x8b, 0x86, 0x62, 0x32, 0x0f, 0x86, 0x64, + 0x24, 0x06, 0x66, 0x71, 0x19, 0x98, 0xcc, 0x43, 0x33, 0x31, 0x99, 0x00, 0x66, 0x88, 0x33, 0x30, + 0xcc, 0xd1, 0x0e, 0x98, 0x0b, 0x33, 0x34, 0x40, 0x0c, 0xd1, 0x46, 0x66, 0x19, 0x9a, 0x28, 0xcc, + 0x49, 0x80, 0xb3, 0x33, 0x45, 0x00, 0xcd, 0x18, 0x66, 0x61, 0x99, 0xa3, 0x0c, 0xc8, 0x98, 0x0b, + 0x33, 0x34, 0x60, 0x4c, 0xd1, 0x06, 0x68, 0xa5, 0x20, 0x62, 0x66, 0x88, 0x33, 0x46, 0x28, 0x05, + 0x0f, 0x32, 0x0c, 0x4c, 0xd1, 0x46, 0x68, 0xc5, 0x00, 0x41, 0xe4, 0x8f, 0xc8, 0x85, 0x5e, 0x02, + 0x7c, 0xc9, 0x26, 0x81, 0x83, 0xb0, 0x9d, 0xc2, 0xde, 0x9c, 0x78, 0xac, 0xd6, 0x68, 0xb4, 0x0e, + 0x71, 0xdb, 0xb2, 0x49, 0x38, 0x6e, 0x02, 0x2a, 0x2c, 0x41, 0x2b, 0x10, 0x98, 0x82, 0x49, 0x03, + 0x14, 0xf4, 0xe1, 0x97, 0x00, +]; +const RAR3_AUDIO_FILTER_BYTECODE: &[u8] = &[ + 0x47, 0x01, 0x9a, 0x41, 0x95, 0xe5, 0x72, 0x0d, 0xc2, 0x64, 0x82, 0x74, 0x93, 0x24, 0xb1, 0x40, + 0x06, 0xd8, 0x38, 0x44, 0x00, 0xa8, 0x01, 0x34, 0x11, 0xdc, 0xa1, 0xba, 0x01, 0x99, 0x0c, 0xc4, + 0x03, 0x31, 0x19, 0xa4, 0x06, 0x66, 0x22, 0x60, 0x4d, 0x9a, 0x40, 0x0d, 0x66, 0x8e, 0x60, 0xd0, + 0x30, 0x40, 0x18, 0x26, 0xc1, 0xc8, 0xf6, 0xe6, 0x26, 0x13, 0x78, 0x92, 0x08, 0xe8, 0x50, 0xbc, + 0x5a, 0x07, 0xc6, 0xe9, 0xf5, 0x20, 0xa9, 0xa0, 0xed, 0x37, 0x33, 0x47, 0x39, 0x66, 0x90, 0x70, + 0x19, 0xa3, 0x9b, 0xcf, 0x25, 0x83, 0x80, 0xc1, 0xbd, 0x30, 0x16, 0x6e, 0x23, 0x34, 0x93, 0x81, + 0x16, 0x09, 0xb0, 0x50, 0x18, 0x3b, 0x4d, 0xc8, 0x4c, 0x05, 0x9b, 0x88, 0xc5, 0x28, 0xe0, 0x76, + 0x93, 0x90, 0x98, 0x0b, 0x37, 0x11, 0x8a, 0x59, 0xc4, 0x80, 0x42, 0x48, 0x43, 0xa9, 0x47, 0xee, + 0x43, 0x34, 0x60, 0x47, 0xd4, 0x4a, 0x0d, 0xbb, 0xd3, 0x59, 0xa4, 0x86, 0xee, 0x05, 0x09, 0x40, + 0x26, 0xc9, 0x34, 0x24, 0x76, 0xa0, 0x30, 0x6a, 0x20, 0xea, 0x02, 0x20, 0x04, 0xa0, 0x41, 0x50, + 0x9e, 0x50, 0x3f, 0xe6, 0xe1, 0x28, 0x94, 0x46, 0x01, 0xbd, 0x8b, 0x40, 0xf0, 0x68, 0x11, 0x36, + 0xc9, 0xa1, 0x92, 0x38, 0x11, 0x41, 0x9c, 0xa8, 0x95, 0x10, 0xee, 0x50, 0x66, 0x2b, 0x00, 0x20, + 0x95, 0x11, 0x04, 0x02, 0x62, 0xac, 0x66, 0x8c, 0x6a, 0xca, 0x26, 0x40, 0xb2, 0x67, 0x1b, 0x4b, + 0x26, 0xcc, 0x64, 0x8a, 0x62, 0x71, 0xa2, 0xb8, +]; + +pub fn unpack29_encode_literals(input: &[u8]) -> Result> { + encode_member(input, &[]) +} + +pub fn unpack29_encode_literals_with_options( + input: &[u8], + options: EncodeOptions, +) -> Result> { + encode_member_with_options(input, &[], options) +} + +pub(crate) fn unpack29_encode_literals_with_options_and_progress( + input: &[u8], + options: EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + encode_member_with_options_and_progress(input, &[], options, &mut [0; TABLE_COUNT], progress) +} + +pub fn unpack29_encode_ppmd_literals(input: &[u8]) -> Result> { + encode_ppmd_member(input, false, &[], 0) +} + +pub(crate) fn unpack29_encode_ppmd_with_progress( + input: &[u8], + lz_escapes: bool, + filter: Option, + max_match_distance: usize, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + if !progress(0) { + return Err(Error::Cancelled); + } + let filtered = if let Some(filter) = filter { + let filters = split_large_filter(input.len(), filter)?; + Some(filtered_members_with_progress( + input, + &filters, + Some(&mut *progress), + )?) + } else { + None + }; + let records = if let Some(filtered) = &filtered { + let refs: Vec<_> = filtered.records.iter().collect(); + encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new())? + } else { + Vec::new() + }; + encode_ppmd_block_with_model( + filtered.as_ref().map_or(input, |filtered| &filtered.data), + lz_escapes, + &records, + max_match_distance, + None, + Some(progress), + ) + .map(|(packed, _)| packed) +} + +/// `max_match_distance` is the dictionary the file header declares. PPMd's +/// escape-4 matches copy out of the same window the LZ decoder uses, so a match +/// that reaches further back than the header promises lands on whatever the +/// decoder still happens to hold, and unrar fails the member on its checksum. +pub fn unpack29_encode_ppmd(input: &[u8], max_match_distance: usize) -> Result> { + encode_ppmd_member(input, true, &[], max_match_distance) +} + +pub fn unpack29_encode_ppmd_with_filter( + input: &[u8], + filter: crate::FilterSpec, + max_match_distance: usize, +) -> Result> { + encode_ppmd_filtered_member(input, filter, true, max_match_distance) +} + +fn encode_ppmd_filtered_member( + input: &[u8], + filter: crate::FilterSpec, + lz_escapes: bool, + max_match_distance: usize, +) -> Result> { + let filters = split_large_filter(input.len(), filter)?; + let filtered = filtered_members(input, &filters)?; + // PPMd codes the member as one unit rather than in LZ blocks, so every + // record is declared at the start and the window does not constrain them. + let refs: Vec<&OwnedVmFilterRecord> = filtered.records.iter().collect(); + let records = encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new())?; + encode_ppmd_member(&filtered.data, lz_escapes, &records, max_match_distance) +} + +pub(crate) fn filtered_members( + input: &[u8], + filters: &[crate::FilterSpec], +) -> Result { + filtered_members_with_progress(input, filters, None) +} + +fn filtered_members_with_progress( + input: &[u8], + filters: &[crate::FilterSpec], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result { + let mut ordered = filters.iter().collect::>(); + ordered.sort_by_key(|filter| filter.range.as_ref().map_or(0, |range| range.start)); + let mut data = input.to_vec(); + let mut records = Vec::with_capacity(filters.len()); + let mut index = 0; + let mut previous_end = 0; + while index < ordered.len() { + let range = checked_filter_range(input.len(), ordered[index])?; + if range.start < previous_end { + return Err(Error::InvalidData("RAR 2.9 VM filters partially overlap")); + } + + let mut group_end = index + 1; + while group_end < ordered.len() + && ordered[group_end].range.clone().unwrap_or(0..input.len()) == range + { + group_end += 1; + } + let mut group_records = Vec::with_capacity(group_end - index); + // Decoding runs records in wire order. Apply their inverses in reverse + // so each decoder invocation receives the prior one's output. + for filter in ordered[index..group_end].iter().rev() { + // Large ranges have already been split into bounded records. Poll + // between them without advancing encoded-byte progress, so filter + // preprocessing cannot hide cancellation for an entire member. + if progress.as_mut().is_some_and(|report| !report(0)) { + return Err(Error::Cancelled); + } + let filtered = filtered_member(&data, filter)?; + data[range.clone()].copy_from_slice(&filtered.data[range.clone()]); + group_records.push(OwnedVmFilterRecord { + block_start: filtered.block_start, + block_size: filtered.block_size, + init_regs: filtered.init_regs, + code: filtered.code, + global_data: Vec::new(), + }); + } + group_records.reverse(); + records.extend(group_records); + previous_end = range.end; + index = group_end; + } + Ok(FilteredMembers { data, records }) +} + +pub(crate) struct FilteredMembers { + pub(crate) data: Vec, + records: Vec, +} + +fn split_large_filter( + input_len: usize, + filter: crate::FilterSpec, +) -> Result> { + let range = checked_filter_range(input_len, &filter)?; + + // The smallest run of bytes each filter can still transform. A trailing + // chunk shorter than this is left unfiltered rather than handed to a filter + // that cannot process it. + let unit = match rar29_filter(filter.kind)? { + Rar29Filter::Delta { channels } | Rar29Filter::Audio { channels } => channels, + Rar29Filter::Rgb { width, .. } => width.max(3), + Rar29Filter::E8 | Rar29Filter::E8E9 | Rar29Filter::Itanium => 4, + }; + let chunk_size = match rar29_filter(filter.kind)? { + Rar29Filter::Delta { channels } => { + if channels == 0 || channels > MAX_VM_DELTA_FILTER_BLOCK_SIZE { + return Err(Error::InvalidData( + "RAR 2.9 VM filter channel count is invalid", + )); + } + MAX_VM_DELTA_FILTER_BLOCK_SIZE - (MAX_VM_DELTA_FILTER_BLOCK_SIZE % channels) + } + Rar29Filter::Audio { channels } => { + if channels == 0 || channels > MAX_AUDIO_CHANNELS { + return Err(Error::InvalidData( + "RAR 2.9 VM filter channel count is invalid", + )); + } + MAX_VM_AUDIO_FILTER_BLOCK_SIZE - (MAX_VM_AUDIO_FILTER_BLOCK_SIZE % channels) + } + Rar29Filter::Rgb { width, .. } => { + if width == 0 || width > MAX_VM_FILTER_BLOCK_SIZE { + return Err(Error::InvalidData( + "RAR 2.9 RGB filter scanline width is invalid", + )); + } + MAX_VM_FILTER_BLOCK_SIZE - (MAX_VM_FILTER_BLOCK_SIZE % width) + } + Rar29Filter::E8 | Rar29Filter::E8E9 | Rar29Filter::Itanium => MAX_VM_FILTER_BLOCK_SIZE, + }; + if range.len() <= chunk_size { + return Ok(vec![filter]); + } + + let mut filters = Vec::new(); + let mut start = range.start; + while start < range.end { + let end = (start + chunk_size).min(range.end); + // Chunking can leave a remainder the filter has no way to transform. + // Those bytes stay as they are; a filter covering part of a member is + // exactly what a range is for. + if end - start < unit { + break; + } + filters.push(crate::FilterSpec::range(filter.kind, start..end)); + start = end; + } + Ok(filters) +} + +fn checked_filter_range( + input_len: usize, + filter: &crate::FilterSpec, +) -> Result> { + let range = filter.range.clone().unwrap_or(0..input_len); + if range.start >= range.end || range.end > input_len { + return Err(Error::InvalidData("RAR 2.9 VM filter range is invalid")); + } + Ok(range) +} + +struct OwnedVmFilterRecord { + block_start: usize, + block_size: usize, + init_regs: Vec<(usize, u32)>, + code: &'static [u8], + global_data: Vec, +} + +fn encode_ppmd_member( + input: &[u8], + lz_escapes: bool, + initial_filters: &[Vec], + max_match_distance: usize, +) -> Result> { + encode_ppmd_block(input, lz_escapes, initial_filters, max_match_distance) +} + +fn encode_ppmd_block( + input: &[u8], + lz_escapes: bool, + initial_filters: &[Vec], + max_match_distance: usize, +) -> Result> { + encode_ppmd_block_with_model( + input, + lz_escapes, + initial_filters, + max_match_distance, + None, + None, + ) + .map(|(packed, _)| packed) +} + +/// Codes one PPMd block, either starting a model or carrying one on. +/// +/// The header byte's 0x20 bit tells the reader to throw its model away and +/// build a new one from the order and dictionary size that follow. Clearing it +/// leaves the reader's model where it is, which is how a solid chain gets a +/// model that has already read every member before this one. WinRAR does this +/// on 67 of the 68 PPMd blocks in a solid archive of 70 small files, and the +/// difference is most of why that archive is 18% smaller than ours was. +/// +/// The model comes back out so the next block can continue it in turn. +fn encode_ppmd_block_with_model( + input: &[u8], + lz_escapes: bool, + initial_filters: &[Vec], + max_match_distance: usize, + model: Option, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result<(Vec, PpmdDecoder)> { + if progress.as_mut().is_some_and(|report| !report(0)) { + return Err(Error::Cancelled); + } + let mut out = Vec::new(); + let mut encoder = match model { + Some(model) => { + out.push(0x80 | ((PPMD_ORDER as u8) - 1)); + PpmdEncoder::continuing(model, PPMD_ESC) + } + None => { + out.push(0x80 | 0x20 | ((PPMD_ORDER as u8) - 1)); + out.push(PPMD_DICTIONARY_MB - 1); + PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB))? + } + }; + for record in initial_filters { + encoder.encode_vm_filter_record(record)?; + } + if lz_escapes { + let mut report = |position| progress.as_mut().is_none_or(|report| report(position)); + encode_ppmd_hybrid_with_progress( + input, + max_match_distance, + &mut encoder, + |_| (), + Some(&mut report), + )?; + } else { + for (position, &byte) in input.iter().enumerate() { + if position.is_multiple_of(4096) + && progress.as_mut().is_some_and(|report| !report(position)) + { + return Err(Error::Cancelled); + } + encoder.encode_literal(byte)?; + } + } + let (packed, model) = encoder.finish_keeping_model()?; + out.extend_from_slice(&packed); + if progress.as_mut().is_some_and(|report| !report(input.len())) { + return Err(Error::Cancelled); + } + Ok((out, model)) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum PpmdEncodeToken { + Literal(u8), + RepeatOffsetOne { length: usize }, + Match { offset: usize, length: usize }, +} + +/// The writer rejects these before compressing anything, so reaching this is +/// either a direct `codec` caller or a bug. Either way the codec stays total. +fn rar29_filter(kind: crate::FilterKind) -> Result { + Rar29Filter::try_from(kind) + .map_err(|_| Error::InvalidData("the RAR 2.9 family has no program for this filter")) +} + +struct FilteredMember { + data: Vec, + block_start: usize, + block_size: usize, + init_regs: Vec<(usize, u32)>, + code: &'static [u8], +} + +fn filtered_member(input: &[u8], filter: &crate::FilterSpec) -> Result { + let range = checked_filter_range(input.len(), filter)?; + let mut filtered = input.to_vec(); + let (init_regs, code): (Vec<(usize, u32)>, &'static [u8]) = match rar29_filter(filter.kind)? { + Rar29Filter::E8 => { + filters::e8e9_encode(&mut filtered[range.clone()], range.start as u32, false); + (Vec::new(), RAR3_E8_FILTER_BYTECODE) + } + Rar29Filter::E8E9 => { + filters::e8e9_encode(&mut filtered[range.clone()], range.start as u32, true); + (Vec::new(), RAR3_E8E9_FILTER_BYTECODE) + } + Rar29Filter::Delta { channels } => { + filters::encode_in_place( + FilterOp::Delta { channels }, + &mut filtered[range.clone()], + 0, + rar29_delta_messages(), + )?; + (vec![(0, channels as u32)], RAR3_DELTA_FILTER_BYTECODE) + } + Rar29Filter::Itanium => { + itanium_encode(&mut filtered[range.clone()], range.start as u32); + (Vec::new(), RAR3_ITANIUM_FILTER_BYTECODE) + } + Rar29Filter::Rgb { width, pos_r } => { + filtered[range.clone()].copy_from_slice(&rgb_encode( + &input[range.clone()], + width, + pos_r, + )?); + let init_regs = if pos_r == 0 { + vec![(0, width as u32 + 3)] + } else { + vec![(0, width as u32 + 3), (1, pos_r as u32)] + }; + (init_regs, RAR3_RGB_FILTER_BYTECODE) + } + Rar29Filter::Audio { channels } => { + filtered[range.clone()] + .copy_from_slice(&audio_encode(&input[range.clone()], channels)?); + (vec![(0, channels as u32)], RAR3_AUDIO_FILTER_BYTECODE) + } + }; + Ok(FilteredMember { + data: filtered, + block_start: range.start, + block_size: range.end - range.start, + init_regs, + code, + }) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct EncodeOptions { + pub max_match_candidates: usize, + pub lazy_matching: bool, + pub lazy_lookahead: usize, + pub max_match_distance: usize, + pub block_size: Option, +} + +impl EncodeOptions { + pub const fn new(max_match_candidates: usize) -> Self { + Self { + max_match_candidates, + lazy_matching: false, + lazy_lookahead: 1, + max_match_distance: MAX_ENCODER_MATCH_OFFSET, + block_size: None, + } + } + + pub const fn with_lazy_matching(mut self, enabled: bool) -> Self { + self.lazy_matching = enabled; + self + } + + pub const fn with_lazy_lookahead(mut self, bytes: usize) -> Self { + self.lazy_lookahead = bytes; + self + } + + pub const fn with_max_match_distance(mut self, distance: usize) -> Self { + self.max_match_distance = if distance > MAX_HISTORY { + MAX_HISTORY + } else { + distance + }; + self + } + + pub const fn with_block_size(mut self, bytes: usize) -> Self { + self.block_size = Some(bytes); + self + } + + const fn constrained(mut self) -> Self { + if self.max_match_distance > MAX_HISTORY { + self.max_match_distance = MAX_HISTORY; + } + self + } +} + +impl Default for EncodeOptions { + fn default() -> Self { + Self::new(MAX_MATCH_CANDIDATES) + } +} + +/// Which engine a member of a solid chain is coded with. +/// +/// A chain used to be LZ and nothing else. Both engines keep state that carries +/// from member to member, so this is a per-member choice inside one chain +/// rather than a property of the archive. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ChainEngine { + Lz, + Ppmd, + /// Code it both ways and keep whichever is smaller. Worth asking for when + /// the content might go either way, and not otherwise: it doubles the work + /// and copying the model to try costs more the longer the chain has run. + Smaller, +} + +/// One way of coding a member into the chain, and the state it would leave. +/// +/// The state is carried rather than committed because a candidate that loses +/// must not move the chain: the reader rebuilds its code-length table from the +/// bytes it actually reads, so committing a table the winner never wrote leaves +/// every later member coded against a table no decoder holds. +struct LzCandidate { + packed: Vec, + /// The bytes the LZ layer coded, when a filter rewrote them. `None` when + /// the candidate took no filter and coded the input as it came. + coded: Option>, + levels: [u8; TABLE_COUNT], +} + +#[derive(Debug, Clone)] +pub struct Unpack29Encoder { + history: Vec, + options: EncodeOptions, + /// The code-length table a reader holds once everything coded so far has + /// been read. A solid chain carries it from one member to the next, which + /// is what lets a member say "same table as before" instead of spelling one + /// out. A reader clears it on a member that does not continue a chain, and + /// so does a fresh encoder. + levels: [u8; TABLE_COUNT], + /// The PPMd model a reader holds, once some member in the chain has built + /// one. A reader keeps it across every block that does not ask for a reset, + /// LZ blocks included, so a member can go PPMd against everything the chain + /// has read even when the member before it went LZ. + ppmd: Option, +} + +impl Default for Unpack29Encoder { + fn default() -> Self { + Self::with_options(EncodeOptions::default()) + } +} + +impl Unpack29Encoder { + pub fn new() -> Self { + Self::default() + } + + pub fn with_options(options: EncodeOptions) -> Self { + Self { + history: Vec::new(), + options: options.constrained(), + levels: [0; TABLE_COUNT], + ppmd: None, + } + } + + pub fn encode_member(&mut self, input: &[u8]) -> Result> { + let packed = encode_member_with_options_impl( + input, + &self.history, + self.options, + &mut self.levels, + None, + )?; + self.remember(input); + Ok(packed) + } + + /// Codes one member of a solid chain with the engine the caller asked for. + /// + /// Both engines carry state across the chain and only one of them can be + /// right for a given member, so the loser's state is thrown away: an LZ + /// member must not advance the reader's PPMd model, and a PPMd member must + /// not advance its code-length table. What both advance is the window, + /// since the reader's window is fed by whichever engine wrote the bytes. + /// + /// `candidates` is the filter lists to choose between, each measured + /// against the chain as it stands. An empty slice means code it plainly, + /// which is what a caller with no search to offer passes. + pub(crate) fn encode_member_with_engine( + &mut self, + input: &[u8], + engine: ChainEngine, + candidates: &[Vec], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result> { + if engine == ChainEngine::Ppmd { + let (packed, model) = self.encode_ppmd_member(input, progress)?; + self.ppmd = Some(model); + self.remember(input); + return Ok(packed); + } + + let lz = self.best_lz_candidate(input, candidates, progress)?; + + let ppmd = match engine { + ChainEngine::Smaller => { + Some(self.encode_ppmd_member(input, &mut |_| progress(input.len()))?) + } + _ => None, + }; + + match ppmd.filter(|(packed, _)| packed.len() < lz.packed.len()) { + Some((packed, model)) => { + self.ppmd = Some(model); + self.remember(input); + Ok(packed) + } + None => { + self.levels = lz.levels; + // The LZ layer coded the filtered bytes, so those are what a + // decoder's window holds and what the next member can match + // against. A member that took no filter coded its input. + self.remember(lz.coded.as_deref().unwrap_or(input)); + Ok(lz.packed) + } + } + } + + /// Codes the member under every candidate filter list and keeps the + /// smallest, along with the chain state that candidate would leave behind. + /// + /// This is the whole reason a chain can search for a filter at all. Which + /// filter suits a member is decided elsewhere, on the member's own bytes; + /// what cannot be decided there is whether the winner still pays once the + /// history behind it is doing some of the same work, and that is what the + /// encodes here measure. They are the real thing, against the real history, + /// at the caller's real settings. + /// + /// Only the first candidate advances progress; later candidates poll at + /// the completed byte count for cancellation. Every candidate walks the + /// whole member, and the bar counts bytes coded rather than work done, so + /// reporting each one over again would run it past the end of the member + /// and back. The plain candidate comes first, so what the bar shows is one + /// member's worth of the pass that always happens. + fn best_lz_candidate( + &self, + input: &[u8], + candidates: &[Vec], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result { + let plain_only = [Vec::new()]; + let candidates = if candidates.is_empty() { + &plain_only[..] + } else { + candidates + }; + let mut best: Option = None; + for (index, filters) in candidates.iter().enumerate() { + let mut report = + |position: usize| progress(if index == 0 { position } else { input.len() }); + let mut levels = self.levels; + let candidate = if filters.is_empty() { + LzCandidate { + packed: encode_member_with_options_and_progress( + input, + &self.history, + self.options, + &mut levels, + &mut report, + )?, + coded: None, + levels, + } + } else { + let mut split = Vec::new(); + for filter in filters { + split.extend(split_large_filter(input.len(), filter.clone())?); + } + let filtered = filtered_members_with_progress(input, &split, Some(&mut report))?; + let packed = encode_filtered_member_blocks( + &filtered.data, + &self.history, + &filtered.records, + self.options, + &mut levels, + Some(&mut report), + )?; + LzCandidate { + packed, + coded: Some(filtered.data), + levels, + } + }; + if best + .as_ref() + .is_none_or(|best| candidate.packed.len() < best.packed.len()) + { + best = Some(candidate); + } + // Check again after committing the candidate, without moving the + // byte count backwards for repeated work on the same member. + if index > 0 && !progress(input.len()) { + return Err(Error::Cancelled); + } + } + Ok(best.expect("a chain always has at least the plain candidate")) + } + + /// Codes the member against a copy of the chain's model, so a trial that + /// loses leaves the reader's model where the winning member expects it. + fn encode_ppmd_member( + &self, + input: &[u8], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result<(Vec, PpmdDecoder)> { + encode_ppmd_block_with_model( + input, + true, + &[], + self.options.max_match_distance, + self.ppmd.clone(), + Some(progress), + ) + } + + pub fn encode_member_with_filter( + &mut self, + input: &[u8], + filter: crate::FilterSpec, + ) -> Result> { + let filters = split_large_filter(input.len(), filter)?; + let filtered = filtered_members(input, &filters)?; + let mut levels = self.levels; + let packed = encode_filtered_member_blocks( + &filtered.data, + &self.history, + &filtered.records, + self.options, + &mut levels, + None, + )?; + // The LZ layer coded the filtered bytes, so that is what a decoder's + // window holds and what the next member in a solid chain can match + // against. Remembering the caller's input instead leaves every member + // after this one referring to bytes no decoder ever had. + self.levels = levels; + self.remember(&filtered.data); + Ok(packed) + } + + pub fn encode_member_with_filters( + &mut self, + input: &[u8], + filters: &[crate::FilterSpec], + ) -> Result> { + self.encode_member_with_filters_and_progress(input, filters, None) + } + + pub(crate) fn encode_member_with_filters_and_progress( + &mut self, + input: &[u8], + filters: &[crate::FilterSpec], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + if progress.as_mut().is_some_and(|report| !report(0)) { + return Err(Error::Cancelled); + } + let mut split_filters = Vec::new(); + for filter in filters { + split_filters.extend(split_large_filter(input.len(), filter.clone())?); + } + let filtered = match progress.as_mut() { + Some(report) => { + filtered_members_with_progress(input, &split_filters, Some(&mut **report))? + } + None => filtered_members(input, &split_filters)?, + }; + let mut levels = self.levels; + let packed = encode_filtered_member_blocks( + &filtered.data, + &self.history, + &filtered.records, + self.options, + &mut levels, + progress, + )?; + // The LZ layer coded the filtered bytes, so that is what a decoder's + // window holds and what the next member in a solid chain can match + // against. Remembering the caller's input instead leaves every member + // after this one referring to bytes no decoder ever had. + self.levels = levels; + self.remember(&filtered.data); + Ok(packed) + } + + fn remember(&mut self, input: &[u8]) { + self.history.extend_from_slice(input); + let keep_from = self.history.len().saturating_sub(MAX_HISTORY); + if keep_from != 0 { + self.history.drain(..keep_from); + } + } +} + +fn encode_member(input: &[u8], history: &[u8]) -> Result> { + encode_member_with_options(input, history, EncodeOptions::default()) +} + +fn encode_member_with_options( + input: &[u8], + history: &[u8], + options: EncodeOptions, +) -> Result> { + encode_member_with_options_impl(input, history, options, &mut [0; TABLE_COUNT], None) +} + +fn encode_member_with_options_and_progress( + input: &[u8], + history: &[u8], + options: EncodeOptions, + levels: &mut [u8; TABLE_COUNT], + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + encode_member_with_options_impl(input, history, options, levels, Some(progress)) +} + +fn encode_member_with_options_impl( + input: &[u8], + history: &[u8], + options: EncodeOptions, + levels: &mut [u8; TABLE_COUNT], + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let options = options.constrained(); + if let Some(block_size) = options.block_size.filter(|&size| size != 0) { + if input.len() > block_size { + return encode_member_blocks(input, history, options, block_size, levels, progress); + } + } + encode_member_inner(input, history, &[], options, false, levels, progress) +} + +fn encode_member_blocks( + input: &[u8], + history: &[u8], + mut options: EncodeOptions, + block_size: usize, + levels: &mut [u8; TABLE_COUNT], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + options.block_size = None; + let mut out = Vec::new(); + let mut local_history = history[history.len().saturating_sub(MAX_HISTORY)..].to_vec(); + let mut completed = 0usize; + let block_count = input.chunks(block_size).count(); + for (index, chunk) in input.chunks(block_size).enumerate() { + let mut chunk_progress = |position: usize| { + progress + .as_deref_mut() + .is_none_or(|report| report(completed.saturating_add(position))) + }; + out.extend_from_slice(&encode_member_inner( + chunk, + &local_history, + &[], + options, + index + 1 < block_count, + levels, + Some(&mut chunk_progress), + )?); + completed = completed.saturating_add(chunk.len()); + local_history.extend_from_slice(chunk); + let keep_from = local_history.len().saturating_sub(MAX_HISTORY); + if keep_from != 0 { + local_history.drain(..keep_from); + } + } + Ok(out) +} + +/// `more_blocks_follow` is what the block's terminator says. +/// +/// The end-of-block symbol is followed by a bit meaning "another table comes +/// next". A member split across blocks needs that bit set on every block but +/// the last, and clear on the last so the member ends. Getting either one +/// wrong leaves a reader parsing whatever comes after as the wrong thing. +/// +/// `previous_levels` is the code-length table the reader holds when this block +/// starts, and is left holding this block's. A reader clears it between members +/// unless the archive is solid, so a caller that is not chaining members hands +/// over a table of zeroes and gets one block's worth of state back it can throw +/// away. +fn encode_member_inner( + input: &[u8], + history: &[u8], + initial_filters: &[Vec], + options: EncodeOptions, + more_blocks_follow: bool, + previous_levels: &mut [u8; TABLE_COUNT], + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let tokens = encode_tokens_with_progress(input, history, options, progress)?; + let mut main_frequencies = vec![0usize; MAIN_COUNT]; + let mut offset_frequencies = vec![0usize; OFFSET_COUNT]; + let mut low_offset_frequencies = vec![0usize; LOW_OFFSET_COUNT]; + let mut length_frequencies = vec![0usize; LENGTH_COUNT]; + main_frequencies[257] += initial_filters.len(); + let mut match_state = EncoderMatchState::default(); + for token in &tokens { + match *token { + EncodeToken::Literal(byte) => { + main_frequencies[byte as usize] += 1; + } + EncodeToken::Match { length, offset } => { + match match_state.encode_match(length, offset)? { + EncodedMatch::LastLengthRepeat => { + main_frequencies[258] += 1; + } + EncodedMatch::RepeatOffset { + index, length_slot, .. + } => { + main_frequencies[259 + index] += 1; + length_frequencies[length_slot] += 1; + } + EncodedMatch::Fresh { + length_slot, + offset_slot, + offset_extra, + .. + } => { + main_frequencies[271 + length_slot] += 1; + offset_frequencies[offset_slot] += 1; + if offset_slot > 9 { + low_offset_frequencies[offset_extra & 0x0f] += 1; + } + } + } + match_state.remember(length, offset); + } + } + } + main_frequencies[256] += 1; + + let mut table_lengths = [0u8; TABLE_COUNT]; + if low_offset_frequencies + .iter() + .all(|&frequency| frequency == 0) + { + low_offset_frequencies[0] = 1; + } + let main_lengths = huffman::lengths_for_frequencies(&main_frequencies, 15); + let offset_lengths = huffman::lengths_for_frequencies(&offset_frequencies, 15); + let low_offset_lengths = huffman::lengths_for_frequencies(&low_offset_frequencies, 15); + let length_lengths = huffman::lengths_for_frequencies(&length_frequencies, 15); + table_lengths[..MAIN_COUNT].copy_from_slice(&main_lengths); + table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT].copy_from_slice(&offset_lengths); + table_lengths[MAIN_COUNT + OFFSET_COUNT..MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT] + .copy_from_slice(&low_offset_lengths); + table_lengths[MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT..].copy_from_slice(&length_lengths); + + // Two ways to say the same table: outright, or as a delta against the one + // the reader already holds. Neither wins everywhere, so code both and take + // the shorter. Coding a table costs nothing next to parsing the block it + // describes, and picking by size means the keep-tables bit can only help. + let outright = encode_table_level_tokens(&table_lengths); + let against_previous = encode_level_tokens_against(&table_lengths, previous_levels); + let keep_previous_tables = + level_tokens_bit_cost(&against_previous) < level_tokens_bit_cost(&outright); + let level_tokens = match keep_previous_tables { + true => against_previous, + false => outright, + }; + *previous_levels = table_lengths; + + let level_lengths = level_code_lengths(&level_tokens); + let level_codes = canonical_codes(&level_lengths); + let main_codes = canonical_codes(&table_lengths[..MAIN_COUNT]); + + let mut bits = BitWriter::default(); + bits.write_bit(false); // LZ block. + bits.write_bit(keep_previous_tables); + for &len in &level_lengths { + bits.write_bits(len as u32, 4); + } + // Both passes replay the same tokens from the same initial match state. + // Every emitted symbol was counted, and positive frequencies receive codes. + for token in level_tokens { + let code = level_codes[token.symbol].expect("counted level Huffman code"); + bits.write_bits(code.code as u32, code.len); + if token.extra_bits != 0 { + bits.write_bits(token.extra_value as u32, token.extra_bits); + } + } + let offset_codes = canonical_codes(&table_lengths[MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT]); + let low_offset_codes = canonical_codes( + &table_lengths[MAIN_COUNT + OFFSET_COUNT..MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT], + ); + let length_codes = + canonical_codes(&table_lengths[MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT..]); + for filter in initial_filters { + let code = main_codes[257].expect("counted VM filter Huffman code"); + bits.write_bits(code.code as u32, code.len); + for &byte in filter { + bits.write_bits(u32::from(byte), 8); + } + } + let mut match_state = EncoderMatchState::default(); + for token in tokens { + match token { + EncodeToken::Literal(byte) => { + let code = main_codes[byte as usize].expect("counted literal Huffman code"); + bits.write_bits(code.code as u32, code.len); + } + EncodeToken::Match { length, offset } => { + match match_state.encode_match(length, offset)? { + EncodedMatch::LastLengthRepeat => { + let code = + main_codes[258].expect("counted last-length repeat Huffman code"); + bits.write_bits(code.code as u32, code.len); + } + EncodedMatch::RepeatOffset { + index, + length_slot, + length_extra, + } => { + let code = + main_codes[259 + index].expect("counted repeat-offset Huffman code"); + bits.write_bits(code.code as u32, code.len); + let length_code = + length_codes[length_slot].expect("counted repeat length Huffman code"); + bits.write_bits(length_code.code as u32, length_code.len); + if LENGTH_BITS[length_slot] != 0 { + bits.write_bits(length_extra as u32, LENGTH_BITS[length_slot]); + } + } + EncodedMatch::Fresh { + length_slot, + length_extra, + offset_slot, + offset_extra, + } => { + let code = + main_codes[271 + length_slot].expect("counted match Huffman code"); + bits.write_bits(code.code as u32, code.len); + if LENGTH_BITS[length_slot] != 0 { + bits.write_bits(length_extra as u32, LENGTH_BITS[length_slot]); + } + let offset = + offset_codes[offset_slot].expect("counted offset Huffman code"); + bits.write_bits(offset.code as u32, offset.len); + if offset_slot > 9 { + let offset_bits = OFFSET_BITS[offset_slot]; + if offset_bits > 4 { + bits.write_bits((offset_extra >> 4) as u32, offset_bits - 4); + } + let low_offset = low_offset_codes[offset_extra & 0x0f] + .expect("counted low-offset Huffman code"); + bits.write_bits(low_offset.code as u32, low_offset.len); + } else if OFFSET_BITS[offset_slot] != 0 { + bits.write_bits(offset_extra as u32, OFFSET_BITS[offset_slot]); + } + } + } + match_state.remember(length, offset); + } + } + } + let end = main_codes[256].expect("counted end-of-block Huffman code"); + bits.write_bits(end.code as u32, end.len); + // The end-of-block symbol on its own does not end the member: the next bit + // says whether another table follows. A block in the middle of a member + // sets it, because one does. The last block clears it and then writes a + // second bit, which is what the reader carries into a solid follower: a one + // tells it to read its own tables. + if more_blocks_follow { + bits.write_bit(true); + } else { + bits.write_bit(false); + bits.write_bit(true); + } + Ok(bits.finish()) +} + +/// Encodes the filter records for one LZ block. +/// +/// `base` is where the block starts in the member, because a record's block +/// start is read relative to the decoder's current output position, and that +/// position is the head of the block the record is declared in. Writing the +/// member-absolute offset instead makes the decoder mask it against the window +/// and apply the filter in the wrong place. +/// +/// `programs` carries across blocks so a program declared once is referenced by +/// index afterwards, which is what the decoder expects. +fn encoded_filter_records_at( + filters: &[&OwnedVmFilterRecord], + base: usize, + window: usize, + programs: &mut Vec<&'static [u8]>, +) -> Result>> { + let mut records = Vec::with_capacity(filters.len()); + for filter in filters { + let existing = (filter.code != RAR3_AUDIO_FILTER_BYTECODE) + .then(|| programs.iter().position(|&code| code == filter.code)) + .flatten(); + let (program_selector, include_code) = match existing { + Some(index) => ( + u32::try_from(index + 1) + .map_err(|_| Error::InvalidData("RAR 2.9 VM program index overflows"))?, + false, + ), + None => { + let selector = if programs.is_empty() { + 0 + } else { + u32::try_from(programs.len() + 1) + .map_err(|_| Error::InvalidData("RAR 2.9 VM program index overflows"))? + }; + programs.push(filter.code); + (selector, true) + } + }; + let block_start = filter + .block_start + .checked_sub(base) + .ok_or(Error::InvalidData( + "RAR 2.9 VM filter starts before its block", + ))?; + // The decoder masks this against its window, so a record reaching past + // one lands somewhere else entirely and the member decodes to the wrong + // bytes. Our own decoder reads it back the way it was written and so + // agrees, which is why this is checked here rather than left to a round + // trip to notice. + if block_start >= window { + return Err(Error::InvalidData( + "RAR 2.9 VM filter starts further past its block than the window can express", + )); + } + records.push(encode_vm_filter_record_inner( + VmFilterRecord { + block_start, + block_size: filter.block_size, + init_regs: &filter.init_regs, + code: filter.code, + global_data: &filter.global_data, + }, + program_selector, + include_code, + )?); + } + Ok(records) +} + +/// Codes filtered bytes a block at a time, so that no filter is declared +/// further ahead of its block than the decoder's window can express, and so a +/// large member does not need a whole LZ pass in memory at once. +fn encode_filtered_member_blocks( + data: &[u8], + history: &[u8], + filters: &[OwnedVmFilterRecord], + options: EncodeOptions, + levels: &mut [u8; TABLE_COUNT], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + // A record's offset is relative to the head of its own block, so a block no + // larger than the window keeps every offset inside it. + let block_size = options + .block_size + .filter(|&size| size != 0) + .unwrap_or(data.len().max(1)) + .min(options.max_match_distance.max(1)) + .max(1); + let window = options.max_match_distance.max(1); + let mut inner = options; + inner.block_size = None; + let mut programs: Vec<&'static [u8]> = Vec::new(); + let mut out = Vec::new(); + let mut local_history = history[history.len().saturating_sub(MAX_HISTORY)..].to_vec(); + let mut base = 0usize; + while base < data.len().max(1) { + let end = (base + block_size).min(data.len()); + let chunk = &data[base..end]; + let in_block: Vec<&OwnedVmFilterRecord> = filters + .iter() + .filter(|record| record.block_start >= base && record.block_start < end.max(base + 1)) + .collect(); + let records = encoded_filter_records_at(&in_block, base, window, &mut programs)?; + let mut chunk_progress = |position: usize| { + progress + .as_deref_mut() + .is_none_or(|report| report(base.saturating_add(position))) + }; + out.extend_from_slice(&encode_member_inner( + chunk, + &local_history, + &records, + inner, + end < data.len(), + levels, + Some(&mut chunk_progress), + )?); + local_history.extend_from_slice(chunk); + let keep_from = local_history.len().saturating_sub(MAX_HISTORY); + if keep_from != 0 { + local_history.drain(..keep_from); + } + base = end; + if chunk.is_empty() { + break; + } + } + Ok(out) +} + +#[derive(Debug, Clone, Copy)] +struct VmFilterRecord<'a> { + block_start: usize, + block_size: usize, + init_regs: &'a [(usize, u32)], + code: &'a [u8], + global_data: &'a [u8], +} + +fn encode_vm_filter_record_inner( + record: VmFilterRecord<'_>, + program_selector: u32, + include_code: bool, +) -> Result> { + if record.block_size == 0 { + return Err(Error::InvalidData("RAR 2.9 VM filter block is empty")); + } + if include_code && record.code.is_empty() { + return Err(Error::InvalidData("RAR 2.9 VM filter bytecode is empty")); + } + + let mut body = BitWriter::default(); + body.write_encoded_u32(program_selector); + body.write_encoded_u32( + u32::try_from(record.block_start) + .map_err(|_| Error::InvalidData("RAR 2.9 VM block start overflows"))?, + ); + body.write_encoded_u32( + u32::try_from(record.block_size) + .map_err(|_| Error::InvalidData("RAR 2.9 VM block size overflows"))?, + ); + if !record.init_regs.is_empty() { + let mut mask = 0u32; + for &(index, _) in record.init_regs { + if index >= 7 { + return Err(Error::InvalidData( + "RAR 2.9 VM init register index is invalid", + )); + } + mask |= 1 << index; + } + body.write_bits(mask, 7); + for index in 0..7 { + if let Some((_, value)) = record.init_regs.iter().find(|(reg, _)| *reg == index) { + body.write_encoded_u32(*value); + } + } + } + if include_code { + body.write_encoded_u32( + u32::try_from(record.code.len()) + .map_err(|_| Error::InvalidData("RAR 2.9 VM code size overflows"))?, + ); + for &byte in record.code { + body.write_bits(u32::from(byte), 8); + } + } + if !record.global_data.is_empty() { + body.write_encoded_u32( + u32::try_from(record.global_data.len()) + .map_err(|_| Error::InvalidData("RAR 2.9 VM global data size overflows"))?, + ); + for &byte in record.global_data { + body.write_bits(u32::from(byte), 8); + } + } + let body = body.finish(); + + let mut out = Vec::new(); + let mut first = 0x80 | 0x20; + if !record.init_regs.is_empty() { + first |= 0x10; + } + if !record.global_data.is_empty() { + first |= 0x08; + } + match body.len() { + 1..=6 => first |= (body.len() as u8) - 1, + 7..=262 => { + first |= 6; + out.push((body.len() - 7) as u8); + } + 263..=65535 => { + first |= 7; + out.extend_from_slice(&(body.len() as u16).to_be_bytes()); + } + _ => return Err(Error::InvalidData("RAR 2.9 VM filter record is too large")), + } + out.insert(0, first); + out.extend_from_slice(&body); + Ok(out) +} + +fn rgb_encode(data: &[u8], width: usize, pos_r: usize) -> Result> { + if data.len() < 3 || width == 0 || !width.is_multiple_of(3) || width > data.len() || pos_r > 2 { + return Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid", + )); + } + let mut work = data.to_vec(); + for i in (pos_r..work.len().saturating_sub(2)).step_by(3) { + let green = work[i + 1]; + work[i] = work[i].wrapping_sub(green); + work[i + 2] = work[i + 2].wrapping_sub(green); + } + + let mut out = Vec::with_capacity(data.len()); + for channel in 0..3 { + let mut prev = 0u8; + let mut i = channel; + while i < work.len() { + let predicted = if i >= width + 3 { + rgb_predict(prev, work[i - width], work[i - width - 3]) + } else { + prev + }; + let byte = work[i]; + out.push(predicted.wrapping_sub(byte)); + prev = byte; + i += 3; + } + } + Ok(out) +} + +fn audio_encode(data: &[u8], channels: usize) -> Result> { + if channels == 0 || channels > MAX_AUDIO_CHANNELS { + return Err(Error::InvalidData( + "RAR 2.9 AUDIO filter channel count is invalid", + )); + } + let mut out = Vec::with_capacity(data.len()); + for channel in 0..channels { + let mut prev_byte = 0u32; + let mut prev_delta = 0i32; + let mut d1 = 0i32; + let mut d2 = 0i32; + let mut k1 = 0i32; + let mut k2 = 0i32; + let mut k3 = 0i32; + let mut dif = [0u32; 7]; + let mut byte_count = 0usize; + let mut i = channel; + while i < data.len() { + let d3 = d2; + d2 = prev_delta - d1; + d1 = prev_delta; + let predicted = ((8 * prev_byte as i32 + k1 * d1 + k2 * d2 + k3 * d3) >> 3) & 0xff; + let decoded = data[i]; + let encoded = (predicted as u8).wrapping_sub(decoded); + out.push(encoded); + prev_delta = decoded.wrapping_sub(prev_byte as u8) as i8 as i32; + prev_byte = decoded as u32; + let d = (encoded as i8 as i32) << 3; + dif[0] += d.unsigned_abs(); + dif[1] += (d - d1).unsigned_abs(); + dif[2] += (d + d1).unsigned_abs(); + dif[3] += (d - d2).unsigned_abs(); + dif[4] += (d + d2).unsigned_abs(); + dif[5] += (d - d3).unsigned_abs(); + dif[6] += (d + d3).unsigned_abs(); + if byte_count & 0x1f == 0 { + let mut min = dif[0]; + let mut min_index = 0usize; + dif[0] = 0; + for (index, value) in dif.iter_mut().enumerate().skip(1) { + if *value < min { + min = *value; + min_index = index; + } + *value = 0; + } + match min_index { + 1 if k1 >= -16 => k1 -= 1, + 2 if k1 < 16 => k1 += 1, + 3 if k2 >= -16 => k2 -= 1, + 4 if k2 < 16 => k2 += 1, + 5 if k3 >= -16 => k3 -= 1, + 6 if k3 < 16 => k3 += 1, + _ => {} + } + } + byte_count += 1; + i += channels; + } + } + Ok(out) +} + +fn itanium_encode(data: &mut [u8], file_offset: u32) { + if data.len() <= 21 { + return; + } + let base_offset = file_offset >> 4; + let block_count = (data.len() - 21).div_ceil(16); + for block in 0..block_count { + let pos = block * 16; + let file_offset = base_offset.wrapping_add(block as u32); + let mut mask = (0x334b_0000u32 >> (data[pos] & 0x1e)) & 3; + if mask != 0 { + mask += 1; + while mask <= 4 { + let p = pos + (mask as usize * 5 - 8); + if ((data[p + 3] >> mask) & 15) == 5 { + let raw = u32::from_le_bytes([data[p], data[p + 1], data[p + 2], data[p + 3]]); + let mut value = raw >> mask; + value = value.wrapping_add(file_offset) & 0x000f_ffff; + let raw = (raw & !(0x000f_ffff << mask)) | (value << mask); + data[p..p + 4].copy_from_slice(&raw.to_le_bytes()); + } + mask += 1; + } + } + } +} + +#[derive(Debug, Clone, Copy)] +enum EncodeToken { + Literal(u8), + Match { length: usize, offset: usize }, +} + +#[derive(Debug, Clone, Copy, Default)] +struct EncoderMatchState { + old_offsets: [usize; 4], + last_offset: usize, + last_length: usize, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum EncodedMatch { + LastLengthRepeat, + RepeatOffset { + index: usize, + length_slot: usize, + length_extra: usize, + }, + Fresh { + length_slot: usize, + length_extra: usize, + offset_slot: usize, + offset_extra: usize, + }, +} + +impl EncoderMatchState { + fn encode_match(&self, length: usize, offset: usize) -> Result { + if self.last_length != 0 && offset == self.last_offset && length == self.last_length { + return Ok(EncodedMatch::LastLengthRepeat); + } + if let Some(index) = self + .old_offsets + .iter() + .position(|&old_offset| old_offset == offset && old_offset != 0) + { + // The repeat-distance table stops at 257 bytes, one byte before + // the fresh-match table. A 258-byte match at a remembered + // distance is still representable, just not with the shorter + // repeat token. + if let Ok((length_slot, length_extra)) = length_slot_for_repeat_match(length) { + return Ok(EncodedMatch::RepeatOffset { + index, + length_slot, + length_extra, + }); + } + } + let encoded_length = + length + .checked_sub(match_length_adjustment(offset)) + .ok_or(Error::InvalidData( + "RAR 2.9 adjusted match length underflows", + ))?; + let (length_slot, length_extra) = length_slot_for_match(encoded_length)?; + let (offset_slot, offset_extra) = offset_slot_for_match(offset)?; + Ok(EncodedMatch::Fresh { + length_slot, + length_extra, + offset_slot, + offset_extra, + }) + } + + fn remember(&mut self, length: usize, offset: usize) { + if self.last_length != 0 && offset == self.last_offset && length == self.last_length { + return; + } + if let Some(index) = self + .old_offsets + .iter() + .position(|&old_offset| old_offset == offset) + .filter(|_| length_slot_for_repeat_match(length).is_ok()) + { + self.old_offsets[..=index].rotate_right(1); + } else { + // This is a fresh token even when its distance already occurs in + // the repeat ring. The decoder shifts it in and keeps the older + // occurrence, so the encoder must retain the duplicate too. + self.old_offsets.rotate_right(1); + self.old_offsets[0] = offset; + } + self.last_offset = offset; + self.last_length = length; + } +} + +fn encode_tokens_with_progress( + input: &[u8], + history: &[u8], + options: EncodeOptions, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let mut tokens = Vec::new(); + let history = &history[history.len().saturating_sub(options.max_match_distance)..]; + let mut combined = Vec::with_capacity(history.len() + input.len()); + combined.extend_from_slice(history); + combined.extend_from_slice(input); + let mut finder = Rar29MatchFinder::new(combined.len()); + for history_pos in 0..history.len() { + finder.insert(&combined, history_pos); + } + + let mut pos = history.len(); + let end = combined.len(); + let mut state = EncoderMatchState::default(); + let mut next_report = 0usize; + let mut pending_match: Option = None; + while pos < end { + let candidate = pending_match + .take() + .or_else(|| best_match(&combined, pos, end, &finder, options, &state)); + if let Some(candidate) = candidate { + let (emit_literal, cached_next) = + lazy_match_decision(&combined, pos, &finder, options, &state, candidate); + if emit_literal { + tokens.push(EncodeToken::Literal(combined[pos])); + finder.insert(&combined, pos); + pos += 1; + pending_match = cached_next; + continue; + } + let MatchCandidate { length, offset, .. } = candidate; + tokens.push(EncodeToken::Match { length, offset }); + state.remember(length, offset); + for history_pos in pos..pos + length { + finder.insert(&combined, history_pos); + } + pos += length; + } else { + tokens.push(EncodeToken::Literal(combined[pos])); + finder.insert(&combined, pos); + pos += 1; + } + let consumed = pos.saturating_sub(history.len()); + if consumed >= next_report { + if progress + .as_deref_mut() + .is_some_and(|report| !report(consumed)) + { + return Err(Error::Cancelled); + } + next_report = consumed.saturating_add(1024 * 1024); + } + } + if progress.is_some_and(|report| !report(input.len())) { + return Err(Error::Cancelled); + } + Ok(tokens) +} + +/// Decides whether a literal should be emitted instead of `current` because a +/// better match starts within the lazy lookahead window. Also returns the +/// match found one byte ahead (when computed) so the caller can reuse it for +/// the next position instead of searching again. +fn lazy_match_decision( + input: &[u8], + pos: usize, + finder: &Rar29MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, + current: MatchCandidate, +) -> (bool, Option) { + let end = input.len(); + if !options.lazy_matching { + return (false, None); + } + let lookahead = options.lazy_lookahead.max(1); + let mut cached_next = None; + for offset in 1..=lookahead { + if pos + offset >= end { + break; + } + let next = best_match(input, pos + offset, end, finder, options, state); + if offset == 1 { + cached_next = next; + } + let skipped_literal_score = offset as isize * 8; + if next.is_some_and(|next| next.score > current.score + skipped_literal_score) { + return (true, cached_next); + } + } + (false, None) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct MatchCandidate { + length: usize, + offset: usize, + score: isize, +} + +/// The running price of each token kind, measured off the range coder as the +/// member is encoded. An escape token is far from free: a match is six model +/// symbols (escape, 4, three offset bytes, a length) and a repeat is three, +/// coded through contexts where the escape byte is rare, and the copied bytes +/// never enter the model. On text the model predicts a repeated span for a +/// fraction of a bit per byte, so a minimum-length match can cost several +/// times the literals it replaces. Emitting every legal match is what left +/// PPMd members 30-45% behind rar 3.00 on log-shaped text. +/// +/// The literal average answers "what does a byte cost as a literal right +/// now", which is the opportunity cost of a match, so it moves slowly. The +/// token averages track a near-fixed overhead, so they move fast. All three +/// are only ever compared against each other, so the model self-corrects: a +/// token kind that keeps losing keeps its measured price and stays rejected. +struct PpmdTokenCosts { + literal_bits: f64, + match_bits: f64, + repeat_bits: f64, +} + +impl PpmdTokenCosts { + fn new() -> Self { + Self { + literal_bits: PPMD_LITERAL_BITS_SEED, + match_bits: PPMD_MATCH_BITS_SEED, + repeat_bits: PPMD_REPEAT_BITS_SEED, + } + } + + fn match_pays(&self, length: usize) -> bool { + length as f64 * self.literal_bits > self.match_bits + PPMD_CONTEXT_BREAK_BITS + } + + fn repeat_pays(&self, length: usize) -> bool { + length as f64 * self.literal_bits > self.repeat_bits + PPMD_CONTEXT_BREAK_BITS + } + + fn record_literal(&mut self, bits: f64) { + ema(&mut self.literal_bits, bits, PPMD_LITERAL_EMA_WEIGHT); + } + + fn record_match(&mut self, bits: f64) { + ema(&mut self.match_bits, bits, PPMD_TOKEN_EMA_WEIGHT); + } + + fn record_repeat(&mut self, bits: f64) { + ema(&mut self.repeat_bits, bits, PPMD_TOKEN_EMA_WEIGHT); + } +} + +fn ema(slot: &mut f64, sample: f64, weight: f64) { + *slot += weight * (sample - *slot); +} + +/// Feed the member through PPMd, escaping to an LZ token only where the token +/// prices in cheaper than letting the model code the same bytes as literals. +/// Tokenising and encoding are one loop so each decision can read the cost of +/// the last one straight off the range coder; a separate tokenising pass has +/// no way to know what the model would have charged. +/// +/// `on_token` sees every emitted token, in order. Production passes a no-op; +/// the tests collect them. +#[cfg(all(test, feature = "write"))] +fn encode_ppmd_hybrid( + input: &[u8], + max_match_distance: usize, + encoder: &mut PpmdEncoder, + on_token: impl FnMut(PpmdEncodeToken), +) -> Result<()> { + encode_ppmd_hybrid_with_progress(input, max_match_distance, encoder, on_token, None) +} + +fn encode_ppmd_hybrid_with_progress( + input: &[u8], + max_match_distance: usize, + encoder: &mut PpmdEncoder, + mut on_token: impl FnMut(PpmdEncodeToken), + mut progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result<()> { + let mut costs = PpmdTokenCosts::new(); + let mut finder = Rar29MatchFinder::new(input.len()); + let mut pos = 0usize; + let mut search_from = 0usize; + let mut next_check = 0usize; + while pos < input.len() { + if pos >= next_check { + if progress.as_mut().is_some_and(|report| !report(pos)) { + return Err(Error::Cancelled); + } + next_check = pos.saturating_add(4096); + } + if let Some(length) = ppmd_offset_one_repeat(input, pos) { + if costs.repeat_pays(length) { + let before = encoder.spent_bits(); + encoder.encode_repeat_offset_one(length)?; + costs.record_repeat(encoder.spent_bits() - before); + on_token(PpmdEncodeToken::RepeatOffsetOne { length }); + for history_pos in pos..pos + length { + finder.insert(input, history_pos); + } + pos += length; + continue; + } + } + + if pos >= search_from { + if let Some((length, offset)) = best_ppmd_match(input, pos, &finder, max_match_distance) + { + if costs.match_pays(length) { + let before = encoder.spent_bits(); + encoder.encode_match(offset, length)?; + costs.record_match(encoder.spent_bits() - before); + on_token(PpmdEncodeToken::Match { offset, length }); + for history_pos in pos..pos + length { + finder.insert(input, history_pos); + } + pos += length; + continue; + } + search_from = pos + PPMD_REJECT_SEARCH_COOLDOWN; + } + } + + let before = encoder.spent_bits(); + encoder.encode_literal(input[pos])?; + costs.record_literal(encoder.spent_bits() - before); + on_token(PpmdEncodeToken::Literal(input[pos])); + finder.insert(input, pos); + pos += 1; + } + Ok(()) +} + +fn ppmd_offset_one_repeat(input: &[u8], pos: usize) -> Option { + if pos == 0 || input[pos] != input[pos - 1] { + return None; + } + let mut length = 0usize; + while pos + length < input.len() + && input[pos + length] == input[pos - 1] + && length < MAX_PPMD_REPEAT_LENGTH + { + length += 1; + } + (length >= 4).then_some(length) +} + +fn best_ppmd_match( + input: &[u8], + pos: usize, + finder: &Rar29MatchFinder, + max_match_distance: usize, +) -> Option<(usize, usize)> { + let max_offset = pos.min(0x1000001).min(MAX_HISTORY).min(max_match_distance); + let max_length = (input.len() - pos).min(MAX_PPMD_MATCH_LENGTH); + if max_offset < 2 || max_length < MIN_PPMD_MATCH_LENGTH { + return None; + } + let mut best = None; + let mut checked = 0usize; + let mut candidate = finder.first(input, pos); + while candidate != match_finder::NO_POSITION { + // MatchFinder chains contain only previously inserted positions and + // each link moves strictly backwards. + let offset = pos - candidate; + if offset > max_offset { + break; + } + if offset < 2 { + candidate = finder.previous(candidate); + continue; + } + checked += 1; + let length = match_length(input, pos, offset, max_length); + if length >= MIN_PPMD_MATCH_LENGTH + && best.is_none_or(|(best_length, best_offset)| { + length > best_length || (length == best_length && offset < best_offset) + }) + { + best = Some((length, offset)); + if length == max_length { + break; + } + } + if checked >= MAX_MATCH_CANDIDATES { + break; + } + candidate = finder.previous(candidate); + } + best +} + +fn best_match( + input: &[u8], + pos: usize, + end: usize, + finder: &Rar29MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, +) -> Option { + let max_offset = pos.min(options.max_match_distance).min(MAX_HISTORY); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_offset == 0 || max_length < 4 { + return None; + } + let mut best = None; + let mut checked = 0usize; + for offset in state.old_offsets { + if offset == 0 || offset > max_offset { + continue; + } + let length = match_length(input, pos, offset, max_length); + consider_match_candidate(&mut best, state, length, offset); + } + if let Some(best) = best { + if best.length == max_length { + return Some(best); + } + } + let mut candidate = finder.first(input, pos); + while candidate != match_finder::NO_POSITION { + // MatchFinder chains contain only previously inserted positions and + // each link moves strictly backwards. + let offset = pos - candidate; + if offset > max_offset { + break; + } + checked += 1; + // A candidate can only improve on the current best when it matches at + // least one byte past the best length, so probe that byte first. + let best_length = best.map_or(0, |best: MatchCandidate| best.length); + if best_length == 0 || input[candidate + best_length] == input[pos + best_length] { + let length = match_length(input, pos, offset, max_length); + consider_match_candidate(&mut best, state, length, offset); + } + if best.is_some_and(|candidate| candidate.length == max_length) { + break; + } + if checked >= options.max_match_candidates { + break; + } + candidate = finder.previous(candidate); + } + best +} + +fn match_length(input: &[u8], pos: usize, offset: usize, max_length: usize) -> usize { + super::super::fast::match_length(input, pos, offset, max_length) +} + +fn consider_match_candidate( + best: &mut Option, + state: &EncoderMatchState, + length: usize, + offset: usize, +) { + if length < 4 { + return; + } + let Ok(cost) = estimated_match_cost(state, length, offset) else { + return; + }; + let score = (length as isize * 8) - cost as isize; + let candidate = MatchCandidate { + length, + offset, + score, + }; + if best.is_none_or(|best| { + candidate.score > best.score + || (candidate.score == best.score + && (candidate.length > best.length + || (candidate.length == best.length && candidate.offset < best.offset))) + }) { + *best = Some(candidate); + } +} + +fn estimated_match_cost(state: &EncoderMatchState, length: usize, offset: usize) -> Result { + match state.encode_match(length, offset)? { + EncodedMatch::LastLengthRepeat => Ok(2), + EncodedMatch::RepeatOffset { length_slot, .. } => { + Ok(5 + usize::from(LENGTH_BITS[length_slot])) + } + EncodedMatch::Fresh { + length_slot, + offset_slot, + .. + } => { + let low_offset_cost = usize::from(offset_slot > 9) * 4; + Ok(8 + usize::from(LENGTH_BITS[length_slot]) + + usize::from(OFFSET_BITS[offset_slot]) + + low_offset_cost) + } + } +} + +fn match_length_adjustment(offset: usize) -> usize { + usize::from(offset >= 0x2000) + usize::from(offset >= 0x40000) +} + +fn length_slot_for_match(length: usize) -> Result<(usize, usize)> { + if length < 3 { + return Err(Error::InvalidData("RAR 2.9 match length is too short")); + } + let adjusted = length - 3; + for (slot, &base) in LENGTH_BASES.iter().enumerate() { + let extra_bits = LENGTH_BITS[slot]; + let max = base + + if extra_bits == 0 { + 0 + } else { + (1usize << extra_bits) - 1 + }; + if adjusted <= max { + return Ok((slot, adjusted - base)); + } + } + Err(Error::InvalidData("RAR 2.9 match length is too long")) +} + +fn length_slot_for_repeat_match(length: usize) -> Result<(usize, usize)> { + if length < 2 { + return Err(Error::InvalidData( + "RAR 2.9 repeat match length is too short", + )); + } + let adjusted = length - 2; + for (slot, &base) in LENGTH_BASES.iter().enumerate() { + let extra_bits = LENGTH_BITS[slot]; + let max = base + + if extra_bits == 0 { + 0 + } else { + (1usize << extra_bits) - 1 + }; + if adjusted <= max { + return Ok((slot, adjusted - base)); + } + } + Err(Error::InvalidData( + "RAR 2.9 repeat match length is too long", + )) +} + +fn offset_slot_for_match(offset: usize) -> Result<(usize, usize)> { + if offset == 0 { + return Err(Error::InvalidData("RAR 2.9 match offset is zero")); + } + let adjusted = offset - 1; + for (slot, &base) in OFFSET_BASES.iter().enumerate() { + let extra_bits = OFFSET_BITS[slot]; + let max = base + + if extra_bits == 0 { + 0 + } else { + (1usize << extra_bits) - 1 + }; + if adjusted <= max { + return Ok((slot, adjusted - base)); + } + } + Err(Error::InvalidData("RAR 2.9 match offset is too large")) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct LevelToken { + symbol: usize, + extra_bits: u8, + extra_value: u8, +} + +impl LevelToken { + const fn plain(symbol: usize) -> Self { + Self { + symbol, + extra_bits: 0, + extra_value: 0, + } + } + + const fn repeat_previous_short(count: usize) -> Self { + Self { + symbol: 16, + extra_bits: 3, + extra_value: (count - 3) as u8, + } + } + + const fn repeat_previous_long(count: usize) -> Self { + Self { + symbol: 17, + extra_bits: 7, + extra_value: (count - 11) as u8, + } + } + + const fn zero_run_short(count: usize) -> Self { + Self { + symbol: 18, + extra_bits: 3, + extra_value: (count - 3) as u8, + } + } + + const fn zero_run_long(count: usize) -> Self { + Self { + symbol: 19, + extra_bits: 7, + extra_value: (count - 11) as u8, + } + } +} + +fn encode_table_level_tokens(lengths: &[u8; TABLE_COUNT]) -> Vec { + encode_level_tokens_against(lengths, &[0; TABLE_COUNT]) +} + +/// Codes one code-length table as level tokens, against the table the reader +/// already holds. +/// +/// Symbols 0 to 15 are read as a delta: the reader adds one to what it has at +/// that position, modulo 16. So a table close to the previous one spends the +/// cheap end of the alphabet, which is what the block header's keep-tables bit +/// buys. Pass a table of zeroes to code the lengths outright, which is the same +/// arithmetic with nothing to add to. +/// +/// The run symbols do not take part. 16 and 17 repeat the length just decoded +/// and 18 and 19 write zeroes, both regardless of `base`, so runs are found in +/// the lengths themselves either way. +fn encode_level_tokens_against(lengths: &[u8], base: &[u8]) -> Vec { + let delta = |pos: usize, value: u8| (value.wrapping_sub(base[pos]) & 0x0f) as usize; + let mut tokens = Vec::new(); + let mut pos = 0usize; + let mut previous = None; + while pos < lengths.len() { + let value = lengths[pos]; + let mut run = 1usize; + while pos + run < lengths.len() && lengths[pos + run] == value { + run += 1; + } + + if value == 0 { + emit_zero_level_run(&mut tokens, pos, run, &delta); + previous = Some(0); + pos += run; + continue; + } + + if previous == Some(value) && run >= 3 { + emit_repeat_level_run(&mut tokens, run); + pos += run; + continue; + } + + tokens.push(LevelToken::plain(delta(pos, value))); + previous = Some(value); + pos += 1; + } + tokens +} + +/// What the level tokens cost, so two codings of a table can be compared. +/// +/// The 20 four-bit code lengths at the head of the table are the same either +/// way and are left out. +fn level_tokens_bit_cost(tokens: &[LevelToken]) -> usize { + let lengths = level_code_lengths(tokens); + tokens + .iter() + .map(|token| usize::from(lengths[token.symbol]) + usize::from(token.extra_bits)) + .sum() +} + +fn emit_repeat_level_run(tokens: &mut Vec, mut run: usize) { + while run >= 11 { + let mut chunk = run.min(138); + if matches!(run - chunk, 1 | 2) { + chunk -= 3; + } + tokens.push(LevelToken::repeat_previous_long(chunk)); + run -= chunk; + } + if run >= 3 { + tokens.push(LevelToken::repeat_previous_short(run)); + } +} + +fn emit_zero_level_run( + tokens: &mut Vec, + start: usize, + mut run: usize, + delta: &dyn Fn(usize, u8) -> usize, +) { + let mut pos = start; + while run != 0 { + if run >= 11 { + let mut chunk = run.min(138); + if matches!(run - chunk, 1 | 2) { + chunk -= 3; + } + tokens.push(LevelToken::zero_run_long(chunk)); + run -= chunk; + pos += chunk; + } else if run >= 3 { + let chunk = run.min(10); + tokens.push(LevelToken::zero_run_short(chunk)); + run -= chunk; + pos += chunk; + } else { + // A run too short for its own symbol is written out position by + // position, and each of those is a delta like any other. + tokens.extend((pos..pos + run).map(|pos| LevelToken::plain(delta(pos, 0)))); + break; + } + } +} + +/// Codes the level alphabet by how often each symbol is used, not by how many +/// of them appear. +/// +/// A flat code charges the same for every symbol in play, so a table whose +/// tokens are mostly one symbol pays as if they were spread evenly. That is +/// what the keep-tables bit produces, and against a flat code it saved almost +/// nothing. Weighting by frequency is what makes it pay. +/// +/// The 20 lengths are written four bits each, hence the cap of 15. +fn level_code_lengths(tokens: &[LevelToken]) -> [u8; LEVEL_COUNT] { + let mut frequencies = [0usize; LEVEL_COUNT]; + for token in tokens { + frequencies[token.symbol] += 1; + } + // One symbol in play gives a code with one branch and an empty slot beside + // it, which a strict reader rejects. Only the flat assignment pads it. + if frequencies.iter().filter(|&&count| count != 0).count() <= 1 { + let mut lengths = [0u8; LEVEL_COUNT]; + for (symbol, &count) in frequencies.iter().enumerate() { + lengths[symbol] = u8::from(count != 0); + } + huffman::assign_flat_complete_code(&mut lengths); + return lengths; + } + huffman::lengths_for_frequency_array(&frequencies, 15) +} + +#[derive(Debug, Clone, Copy)] +struct HuffmanCode { + code: u16, + len: u8, +} + +// Only encoder-generated tables reach this helper; archive tables use Huffman. +fn canonical_codes(lengths: &[u8]) -> Vec> { + debug_assert!(lengths.iter().all(|&len| len <= 15)); + let mut count = [0u16; 16]; + for &len in lengths { + if len != 0 { + count[len as usize] += 1; + } + } + debug_assert!(validate_huffman_counts(&count).is_ok()); + + let mut next_code = [0u16; 16]; + let mut code = 0u16; + for len in 1..=15 { + code = (code + count[len - 1]) << 1; + next_code[len] = code; + } + + let mut codes = vec![None; lengths.len()]; + for (symbol, &len) in lengths.iter().enumerate() { + if len == 0 { + continue; + } + let code = next_code[len as usize]; + next_code[len as usize] += 1; + codes[symbol] = Some(HuffmanCode { code, len }); + } + codes +} + +#[derive(Default)] +struct BitWriter { + bytes: Vec, + bit_pos: usize, +} + +impl BitWriter { + fn write_bits(&mut self, value: u32, count: u8) { + super::super::fast::write_msb_bits( + &mut self.bytes, + &mut self.bit_pos, + u64::from(value), + usize::from(count), + ); + } + + fn write_encoded_u32(&mut self, value: u32) { + if value < 16 { + self.write_bits(0, 2); + self.write_bits(value, 4); + } else if value < 256 { + self.write_bits(1, 2); + self.write_bits(value, 8); + } else if value <= 0xffff { + self.write_bits(2, 2); + self.write_bits(value, 16); + } else { + self.write_bits(3, 2); + self.write_bits(value >> 16, 16); + self.write_bits(value & 0xffff, 16); + } + } + + fn write_bit(&mut self, bit: bool) { + if self.bit_pos.is_multiple_of(8) { + self.bytes.push(0); + } + if bit { + let shift = 7 - (self.bit_pos % 8); + *self.bytes.last_mut().unwrap() |= 1 << shift; + } + self.bit_pos += 1; + } + + fn finish(self) -> Vec { + self.bytes + } +} + +// Round-trip and malformed-input tests use private encoder helpers and ancestor +// decoder state, without exposing those internals to sibling production code. +#[cfg(test)] +#[path = "tests.rs"] +mod tests; diff --git a/arca-rar/vendor/rars/src/codec/rar29/standard_filters.rs b/arca-rar/vendor/rars/src/codec/rar29/standard_filters.rs new file mode 100644 index 00000000..91828309 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar29/standard_filters.rs @@ -0,0 +1,302 @@ +//! RAR29 standard VM filter recognition and execution. +use super::super::filters; +#[cfg(all(test, feature = "write"))] +use super::Allowance; +use super::{ + rar29_delta_messages, Budget, Buffer, Error, Result, StandardFilter, MAX_AUDIO_CHANNELS, +}; +use crate::crc32::crc32; + +pub(super) fn identify_standard_filter(code: &[u8]) -> Option { + if code.iter().fold(0u8, |acc, &byte| acc ^ byte) != 0 { + return None; + } + match (code.len(), crc32(code)) { + (53, 0xad57_6887) => Some(StandardFilter::E8), + (57, 0x3cd7_e57e) => Some(StandardFilter::E8E9), + (120, 0x3769_893f) => Some(StandardFilter::Itanium), + (29, 0x0e06_077d) => Some(StandardFilter::Delta), + (149, 0x1c2c_5dc8) => Some(StandardFilter::Rgb), + (216, 0xbc85_e701) => Some(StandardFilter::Audio), + _ => None, + } +} + +#[cfg(all(test, feature = "write"))] +pub(super) fn apply_standard_filter_with_control( + filter: StandardFilter, + data: &mut Vec, + file_offset: u32, + regs: &[u32; 7], + control: &crate::read_control::ReadControl, +) -> Result<()> { + let mut owned = Buffer::from_vec(std::mem::take(data)); + let result = + apply_standard_filter_with_allowance(filter, &mut owned, file_offset, regs, control); + *data = owned.into_vec(); + result +} +#[cfg(all(test, feature = "write"))] +pub(super) fn apply_standard_filter( + filter: StandardFilter, + data: &mut Vec, + file_offset: u32, + regs: &[u32; 7], +) -> Result<()> { + apply_standard_filter_with_control( + filter, + data, + file_offset, + regs, + &crate::read_control::ReadControl::default(), + ) +} + +pub(super) fn apply_standard_filter_with_allowance( + filter: StandardFilter, + data: &mut Buffer, + file_offset: u32, + regs: &[u32; 7], + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + + match filter { + StandardFilter::E8 => filters::e8e9_decode_with_control(data, file_offset, false, control)?, + StandardFilter::E8E9 => { + filters::e8e9_decode_with_control(data, file_offset, true, control)? + } + StandardFilter::Itanium => itanium_decode_with_control(data, file_offset, control)?, + StandardFilter::Delta => { + let channels = regs[0] as usize; + // Validate once in the shared decoder, retaining the register + // diagnostic for zero as well as excessive channel counts. + let mut messages = rar29_delta_messages(); + messages.zero_channels = messages.invalid_channels; + *data = filters::delta_decode_with_allowance( + data, + channels, + messages, + control, + &data.allowance(), + )?; + } + StandardFilter::Rgb => { + if regs[0] < 3 || regs[1] > 2 { + return Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid", + )); + } + let width = regs[0] as usize - 3; + let pos_r = regs[1] as usize; + *data = rgb_decode_with_allowance(data, width, pos_r, control, &data.allowance())?; + } + StandardFilter::Audio => { + let channels = regs[0] as usize; + if channels == 0 || channels > MAX_AUDIO_CHANNELS { + return Err(Error::InvalidData( + "RAR 2.9 AUDIO filter channel count is invalid", + )); + } + *data = audio_decode_with_allowance(data, channels, control, &data.allowance())?; + } + } + Ok(()) +} + +#[cfg(all(test, feature = "write"))] +pub(super) fn itanium_decode(data: &mut [u8], file_offset: u32) { + itanium_decode_with_control( + data, + file_offset, + &crate::read_control::ReadControl::default(), + ) + .expect("uncancelled filter"); +} + +pub(super) fn itanium_decode_with_control( + data: &mut [u8], + file_offset: u32, + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + let mut poller = control.poller(); + if data.len() <= 21 { + return Ok(()); + } + let base_offset = file_offset >> 4; + // Each 16-byte Itanium bundle can inspect a 4-byte instruction field that + // starts up to 13 bytes into the bundle. Keeping a 21-byte tail prevents + // decoding a partial final bundle. + let block_count = (data.len() - 21).div_ceil(16); + for block in 0..block_count { + let pos = block * 16; + poller.check_codec(pos)?; + let file_offset = base_offset.wrapping_add(block as u32); + let mut mask = (0x334b_0000u32 >> (data[pos] & 0x1e)) & 3; + if mask != 0 { + mask += 1; + while mask <= 4 { + let p = pos + (mask as usize * 5 - 8); + if ((data[p + 3] >> mask) & 15) == 5 { + let raw = u32::from_le_bytes([data[p], data[p + 1], data[p + 2], data[p + 3]]); + let mut value = raw >> mask; + value = value.wrapping_sub(file_offset) & 0x000f_ffff; + let raw = (raw & !(0x000f_ffff << mask)) | (value << mask); + data[p..p + 4].copy_from_slice(&raw.to_le_bytes()); + } + mask += 1; + } + } + } + + Ok(()) +} + +#[cfg(all(test, feature = "write"))] +pub(super) fn rgb_decode_with_control( + data: &[u8], + width: usize, + pos_r: usize, + control: &crate::read_control::ReadControl, +) -> Result> { + rgb_decode_with_allowance(data, width, pos_r, control, &Allowance::default()) + .map(Buffer::into_vec) +} +fn rgb_decode_with_allowance( + data: &[u8], + width: usize, + pos_r: usize, + control: &crate::read_control::ReadControl, + allowance: &B, +) -> Result> { + control.check_codec()?; + let mut poller = control.poller(); + if data.len() < 3 || width == 0 || !width.is_multiple_of(3) || width > data.len() || pos_r > 2 { + return Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid", + )); + } + let mut out = Buffer::filled(data.len(), 0, allowance)?; + let mut src = 0usize; + for channel in 0..3 { + let mut prev = 0u8; + let mut i = channel; + while i < data.len() { + poller.check_codec(src)?; + let predicted = if i >= width + 3 { + rgb_predict(prev, out[i - width], out[i - width - 3]) + } else { + prev + }; + let encoded = *data + .get(src) + .ok_or(Error::InvalidData("RAR 2.9 RGB filter source is truncated"))?; + prev = predicted.wrapping_sub(encoded); + out[i] = prev; + src += 1; + i += 3; + } + } + for i in (pos_r..data.len().saturating_sub(2)).step_by(3) { + poller.check_codec(i)?; + let green = out[i + 1]; + out[i] = out[i].wrapping_add(green); + out[i + 2] = out[i + 2].wrapping_add(green); + } + Ok(out) +} + +pub(super) fn rgb_predict(prev: u8, upper: u8, upper_left: u8) -> u8 { + let predicted = i32::from(prev) + i32::from(upper) - i32::from(upper_left); + let pa = (predicted - i32::from(prev)).abs(); + let pb = (predicted - i32::from(upper)).abs(); + let pc = (predicted - i32::from(upper_left)).abs(); + if pa <= pb && pa <= pc { + prev + } else if pb <= pc { + upper + } else { + upper_left + } +} + +#[cfg(all(test, feature = "write"))] +pub(super) fn audio_decode_with_control( + data: &[u8], + channels: usize, + control: &crate::read_control::ReadControl, +) -> Result> { + audio_decode_with_allowance(data, channels, control, &Allowance::default()) + .map(Buffer::into_vec) +} +fn audio_decode_with_allowance( + data: &[u8], + channels: usize, + control: &crate::read_control::ReadControl, + allowance: &B, +) -> Result> { + control.check_codec()?; + let mut poller = control.poller(); + let mut out = Buffer::filled(data.len(), 0, allowance)?; + let mut src = 0usize; + for channel in 0..channels { + let mut prev_byte = 0u32; + let mut prev_delta = 0i32; + let mut d1 = 0i32; + let mut d2 = 0i32; + let mut k1 = 0i32; + let mut k2 = 0i32; + let mut k3 = 0i32; + let mut dif = [0u32; 7]; + let mut byte_count = 0usize; + let mut i = channel; + while i < data.len() { + poller.check_codec(src)?; + let d3 = d2; + d2 = prev_delta - d1; + d1 = prev_delta; + let predicted = ((8 * prev_byte as i32 + k1 * d1 + k2 * d2 + k3 * d3) >> 3) & 0xff; + let encoded = *data.get(src).ok_or(Error::InvalidData( + "RAR 2.9 AUDIO filter source is truncated", + ))?; + src += 1; + let decoded = (predicted as u8).wrapping_sub(encoded); + out[i] = decoded; + prev_delta = decoded.wrapping_sub(prev_byte as u8) as i8 as i32; + prev_byte = decoded as u32; + let d = (encoded as i8 as i32) << 3; + dif[0] += d.unsigned_abs(); + dif[1] += (d - d1).unsigned_abs(); + dif[2] += (d + d1).unsigned_abs(); + dif[3] += (d - d2).unsigned_abs(); + dif[4] += (d + d2).unsigned_abs(); + dif[5] += (d - d3).unsigned_abs(); + dif[6] += (d + d3).unsigned_abs(); + if byte_count & 0x1f == 0 { + let mut min = dif[0]; + let mut min_index = 0usize; + dif[0] = 0; + for (index, value) in dif.iter_mut().enumerate().skip(1) { + if *value < min { + min = *value; + min_index = index; + } + *value = 0; + } + match min_index { + 1 if k1 >= -16 => k1 -= 1, + 2 if k1 < 16 => k1 += 1, + 3 if k2 >= -16 => k2 -= 1, + 4 if k2 < 16 => k2 += 1, + 5 if k3 >= -16 => k3 -= 1, + 6 if k3 < 16 => k3 += 1, + _ => {} + } + } + byte_count += 1; + i += channels; + } + } + Ok(out) +} diff --git a/arca-rar/vendor/rars/src/codec/rar29/tests.rs b/arca-rar/vendor/rars/src/codec/rar29/tests.rs new file mode 100644 index 00000000..0091fcc2 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar29/tests.rs @@ -0,0 +1,4223 @@ +#[test] +fn public_decoder_clone_keeps_independent_lz_and_ppmd_solid_state() { + let first = b"RAR29 model and window history ".repeat(32); + let second = b"RAR29 model and window history ".repeat(8); + for engine in [super::ChainEngine::Lz, super::ChainEngine::Ppmd] { + let mut encoder = super::Unpack29Encoder::new(); + let packed_first = encoder + .encode_member_with_engine(&first, engine, &[], &mut |_| true) + .unwrap(); + let packed_second = encoder + .encode_member_with_engine(&second, engine, &[], &mut |_| true) + .unwrap(); + let mut original = super::Unpack29::new(); + assert_eq!( + original + .decode_non_solid_member(&packed_first, first.len()) + .unwrap(), + first + ); + let mut copied = original.clone(); + original.reset_non_solid(); + drop(original); + assert_eq!( + copied.decode_member(&packed_second, second.len()).unwrap(), + second + ); + } +} + +fn refuse_each_rar29_allocation( + mut run: impl FnMut(&crate::codec::workspace::RefusingBudget) -> Result<()>, +) { + use crate::codec::workspace::RefusingBudget; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts > 0); + assert_eq!(baseline.used(), 0); + for index in 0..attempts { + let budget = RefusingBudget::new(index); + assert!( + matches!(run(&budget), Err(Error::Cancelled)), + "allocation {index}" + ); + assert_eq!(budget.used(), 0, "allocation {index}"); + } +} + +#[test] +fn reader_rar29_refusals_release_input_huffman_history_results_and_checkpoints() { + refuse_each_rar29_allocation(|budget| { + let mut state = super::Reader29State::with_allowance(budget); + let decoded = state.decode_member_owned(COMPRESSED_TEXT, 2400)?; + assert_eq!(&decoded[..], expected_text()); + let checkpoint = state.try_clone()?; + assert_eq!(checkpoint.output, state.output); + assert_eq!(checkpoint.main.state.len(), state.main.state.len()); + let mut follower = COMPRESSED_TEXT; + let mut out = super::Buffer::new(budget); + state.decode_non_solid_member_from_reader(&mut follower, 2400, &mut out)?; + assert_eq!(&out[..], expected_text()); + Ok(()) + }); +} + +#[test] +fn reader_rar29_refusals_release_vm_code_records_globals_execution_and_filters() { + const COUNTER: &[u8] = &[ + 0x0d, 0x05, 0xc0, 0x7c, 0x00, 0x0f, 0x01, 0x01, 0xaf, 0x80, 0x01, 0xe0, 0x20, 0x01, 0xf0, + 0x00, 0x3c, 0x03, 0x00, 0x1b, 0x80, + ]; + let records = [ + OwnedVmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: Vec::new(), + code: COUNTER, + global_data: vec![b'A'], + }, + OwnedVmFilterRecord { + block_start: 1, + block_size: 1, + init_regs: Vec::new(), + code: COUNTER, + global_data: Vec::new(), + }, + ]; + let refs = records.iter().collect::>(); + let records = encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new()).unwrap(); + let packed = super::encode_member_inner( + b"xx", + &[], + &records, + EncodeOptions::default(), + false, + &mut [0; TABLE_COUNT], + None, + ) + .unwrap(); + refuse_each_rar29_allocation(|budget| { + let mut state = super::Reader29State::with_allowance(budget); + let decoded = state.decode_member_owned(&packed, 2)?; + assert_eq!(&decoded[..], b"AB"); + let checkpoint = state.try_clone()?; + assert_eq!(checkpoint.programs[0].globals, state.programs[0].globals); + Ok(()) + }); +} + +#[test] +fn reader_rar29_refusals_release_standard_filter_scratch_and_output() { + for (filter, regs) in [ + (StandardFilter::Delta, [2, 0, 0, 0, 0, 0, 0]), + (StandardFilter::Rgb, [9, 0, 0, 0, 0, 0, 0]), + (StandardFilter::Audio, [2, 0, 0, 0, 0, 0, 0]), + ] { + refuse_each_rar29_allocation(|budget| { + let mut state = super::Reader29State::with_allowance(budget); + state.output = super::Buffer::copied(&[0; 96], budget)?; + state.programs.try_push(VmProgram { + kind: VmProgramKind::Standard(filter), + block_size: 96, + exec_count: 0, + globals: super::Buffer::new(budget), + })?; + state.filters.try_push(VmFilter { + program: 0, + start: 0, + size: 96, + regs, + global_data: super::Buffer::new(budget), + })?; + let checkpoint = state.try_clone()?; + assert_eq!(checkpoint.filters.len(), 1); + let out = state.filtered_range_owned(0, 96, 0)?; + assert_eq!(&out[..], &[0; 96]); + assert!(state.filters.is_empty()); + Ok(()) + }); + } +} + +#[test] +fn reader_rar29_returned_output_keeps_reservation_after_decoder_drop() { + use crate::codec::workspace::Allowance; + let ledger = Allowance::limited(128 * 1024); + let mut reservation = ledger.reserve(120 * 1024).unwrap(); + reservation.start(); + let budget = reservation.allowance(); + let mut state = super::Reader29State::with_allowance(&budget); + let out = state.decode_member_owned(COMPRESSED_TEXT, 2400).unwrap(); + drop(state); + drop(budget); + reservation.retire(); + assert!(ledger.used() >= out.capacity() as u64); + assert_eq!(&out[..], expected_text()); + drop(out); + assert_eq!(ledger.used(), 0); +} + +type Unpack29 = super::Reader29State; +#[test] +fn ppmd_progress_preserves_bytes_and_interrupts_both_engines() { + let input = b"PPMd cooperative cancellation payload\n".repeat(400); + for escapes in [false, true] { + let expected = if escapes { + super::unpack29_encode_ppmd(&input, 1 << 20).unwrap() + } else { + super::unpack29_encode_ppmd_literals(&input).unwrap() + }; + let actual = + super::unpack29_encode_ppmd_with_progress(&input, escapes, None, 1 << 20, &mut |_| { + true + }) + .unwrap(); + assert_eq!(actual, expected); + let mut stopped_at = 0; + let result = super::unpack29_encode_ppmd_with_progress( + &input, + escapes, + None, + 1 << 20, + &mut |position| { + stopped_at = position; + position < 4096 + }, + ); + assert!(matches!(result, Err(super::Error::Cancelled))); + assert!(stopped_at >= 4096 && stopped_at < input.len()); + } +} + +#[test] +fn ppmd_progress_covers_entry_filtered_preprocessing_and_completion() { + let input = b"PPMd cancellation boundary payload\n".repeat(400); + for escapes in [false, true] { + let mut calls = Vec::new(); + assert_eq!( + super::unpack29_encode_ppmd_with_progress( + &input, + escapes, + None, + 1 << 20, + &mut |position| { + calls.push(position); + false + }, + ), + Err(super::Error::Cancelled) + ); + assert_eq!(calls, [0]); + + let mut completions = 0; + assert_eq!( + super::unpack29_encode_ppmd_with_progress( + &input, + escapes, + None, + 1 << 20, + &mut |position| { + if position == input.len() { + completions += 1; + return false; + } + true + }, + ), + Err(super::Error::Cancelled) + ); + assert_eq!(completions, 1); + } + + let mut polls = 0; + let filter = crate::FilterSpec::whole(crate::FilterKind::E8); + assert_eq!( + super::unpack29_encode_ppmd_with_progress(&input, true, Some(filter), 1 << 20, &mut |_| { + polls += 1; + polls < 3 + },), + Err(super::Error::Cancelled) + ); + // Entry, the bounded filter record, then the PPMd block itself. + assert_eq!(polls, 3); + + let mut polls = 0; + assert_eq!( + super::unpack29_encode_ppmd_with_progress( + &input, + true, + Some(crate::FilterSpec::whole(crate::FilterKind::E8)), + 1 << 20, + &mut |_| { + polls += 1; + polls < 2 + }, + ), + Err(super::Error::Cancelled) + ); + assert_eq!(polls, 2); +} + +#[test] +fn lz_progress_can_cancel_its_final_report() { + let input = b"RAR29 final LZ progress boundary\n".repeat(400); + let mut completions = 0; + let result = super::unpack29_encode_literals_with_options_and_progress( + &input, + EncodeOptions::default(), + &mut |position| { + if position == input.len() { + completions += 1; + return false; + } + true + }, + ); + + assert_eq!(result, Err(super::Error::Cancelled)); + assert_eq!(completions, 1); +} + +use super::{audio_decode_with_control, itanium_decode_with_control, rgb_decode_with_control}; + +#[test] +fn cancellation_interrupts_lz_and_ppmd_after_non_solid_reset() { + let data = b"cancellable legacy symbols ".repeat(16384); + for (ppmd, packed) in [ + (false, unpack29_encode_literals(&data).unwrap()), + (true, unpack29_encode_ppmd_literals(&data).unwrap()), + ] { + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack29::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + // PPMd checks cancellation before allocating the initial model. + decoder + .read_control + .cancel_after_checks(4 + usize::from(ppmd)); + assert_eq!( + decoder + .decode_non_solid_member(&packed, data.len()) + .unwrap_err(), + Error::Cancelled + ); + assert!(decoder.current_pos() > 0 && decoder.current_pos() < data.len()); + } +} + +#[test] +fn cancellation_interrupts_standard_filter_passes() { + for kind in 0..3 { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let mut data = vec![0; 384 * 1024]; + let result = match kind { + 0 => itanium_decode_with_control(&mut data, 0, &control), + 1 => rgb_decode_with_control(&data, 96, 0, &control).map(|_| ()), + _ => audio_decode_with_control(&data, 2, &control).map(|_| ()), + }; + assert_eq!(result.unwrap_err(), Error::Cancelled); + } +} + +#[test] +fn cancellation_propagates_from_shared_standard_filter_decoders() { + for (filter, regs) in [ + (StandardFilter::E8, [0; 7]), + (StandardFilter::E8E9, [0; 7]), + (StandardFilter::Delta, [1, 0, 0, 0, 0, 0, 0]), + ] { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let mut data = vec![0; 384 * 1024]; + assert_eq!( + super::apply_standard_filter_with_control(filter, &mut data, 0, ®s, &control,), + Err(Error::Cancelled) + ); + } +} +use super::rarvm::{Instruction, Opcode, Operand, Program}; +use std::ops::Range; + +fn encode_tokens(input: &[u8], history: &[u8], options: EncodeOptions) -> Vec { + encode_tokens_with_progress(input, history, options, None) + .expect("encoding without cancellation cannot be cancelled") +} + +fn should_lazy_emit_literal( + input: &[u8], + pos: usize, + finder: &Rar29MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, + current: MatchCandidate, +) -> bool { + lazy_match_decision(input, pos, finder, options, state, current).0 +} + +use super::{ + apply_standard_filter, audio_encode, best_match, best_ppmd_match, canonical_codes, + encode_level_tokens_against, encode_ppmd_hybrid, encode_table_level_tokens, + encode_tokens_with_progress, encoded_filter_records_at, itanium_decode, itanium_encode, + lazy_match_decision, level_code_lengths, split_large_filter, unpack29_decode, + unpack29_encode_literals, unpack29_encode_ppmd, unpack29_encode_ppmd_literals, + unpack29_encode_ppmd_with_filter, BitReader, BitWriter, ChainEngine, EncodeOptions, + EncodeToken, EncoderMatchState, Error, Huffman, LevelToken, MatchCandidate, + OwnedVmFilterRecord, PpmdEncodeToken, PpmdEncoder, Rar29MatchFinder, Result, StandardFilter, + Unpack29Encoder, VmFilter, VmProgram, VmProgramKind, LENGTH_COUNT, LOW_OFFSET_COUNT, + MAIN_COUNT, MAX_ENCODER_MATCH_LENGTH, MAX_ENCODER_MATCH_OFFSET, MAX_HISTORY, + MAX_MATCH_CANDIDATES, MAX_VM_AUDIO_FILTER_BLOCK_SIZE, MAX_VM_DELTA_FILTER_BLOCK_SIZE, + MAX_VM_FILTER_BLOCK_SIZE, OFFSET_COUNT, PPMD_DICTIONARY_MB, PPMD_ESC, PPMD_ORDER, + RAR3_AUDIO_FILTER_BYTECODE, RAR3_DELTA_FILTER_BYTECODE, RAR3_ITANIUM_FILTER_BYTECODE, + RAR3_RGB_FILTER_BYTECODE, STREAM_CHUNK, TABLE_COUNT, +}; + +/// A flat code charges the same for every symbol in play. The keep-tables +/// bit works by pushing the tokens onto one symbol, which buys nothing +/// unless the level code notices. +#[test] +fn the_level_code_spends_fewer_bits_on_the_common_symbol() { + let mut tokens = vec![LevelToken::plain(0); 200]; + tokens.push(LevelToken::plain(7)); + tokens.push(LevelToken::plain(9)); + tokens.push(LevelToken::plain(11)); + let lengths = level_code_lengths(&tokens); + assert!( + lengths[0] < lengths[7], + "the symbol used 200 times costs {} bits and the one used once costs {}", + lengths[0], + lengths[7] + ); +} + +/// Symbols 0 to 15 are read as a delta against the table the reader holds, +/// so a table that has not changed is a run of zeroes. Runs of zero-length +/// codes and repeats stay as they are, since the reader takes those without +/// reference to what it holds. +#[test] +fn a_table_matching_the_previous_one_codes_as_deltas_of_zero() { + let mut lengths = [0u8; TABLE_COUNT]; + for (position, slot) in lengths.iter_mut().enumerate().take(120) { + *slot = (position % 13 + 1) as u8; + } + let against_itself = encode_level_tokens_against(&lengths, &lengths); + assert!( + against_itself + .iter() + .all(|token| token.symbol == 0 || token.symbol >= 16), + "a table coded against itself should spend only zero deltas and runs" + ); + + let outright = encode_table_level_tokens(&lengths); + assert!( + outright.iter().any(|token| (1..16).contains(&token.symbol)), + "the same table coded outright has to name its lengths" + ); +} + +/// Members that share a shape and a vocabulary without repeating each +/// other. Every line carries a number that appears nowhere else, so there +/// is little for the chain to match and the PPMd model is what carries +/// between one member and the next. +fn related_text_member(seed: u64, lines: usize) -> Vec { + const WORDS: [&str; 12] = [ + "alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", "india", + "juliet", "kilo", "lima", + ]; + let mut state = seed | 1; + let mut next = move || { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + state + }; + let mut out = Vec::new(); + for line in 0..lines { + for _ in 0..3 { + out.extend_from_slice(WORDS[(next() % 12) as usize].as_bytes()); + out.push(b'.'); + } + out.extend_from_slice( + format!( + "{} = {}\n", + line + seed as usize * lines, + next() % 1_000_000_007 + ) + .as_bytes(), + ); + } + out +} + +/// WinRAR asks for a PPMd reset on 1 of the 68 PPMd blocks in a solid +/// archive of 70 small files and carries the model through the other 67. +/// Building a model per member instead is most of why that archive used to +/// be 18% smaller than ours. +#[test] +fn a_solid_chain_carries_one_ppmd_model_across_its_members() { + // Members small enough that a model built for one alone never warms up, + // which is the shape the win is really about: 70 manpages, not one book. + let members: Vec> = (0..12).map(|i| related_text_member(i + 1, 40)).collect(); + let mut chain = Unpack29Encoder::with_options(EncodeOptions::default()); + let packed: Vec> = members + .iter() + .map(|member| { + chain + .encode_member_with_engine(member, ChainEngine::Smaller, &[], &mut |_| true) + .unwrap() + }) + .collect(); + + // Which engine wins a given member is a size question and not the + // point here. The point is that once one member has built a model, no + // later member throws it away. + let ppmd: Vec<&Vec> = packed.iter().filter(|block| block[0] & 0x80 != 0).collect(); + assert!( + ppmd.len() > 2, + "this chain was meant to go PPMd more than twice" + ); + assert_eq!( + ppmd[0][0] & 0x20, + 0x20, + "the first PPMd member builds a model" + ); + assert!( + ppmd[1..].iter().all(|block| block[0] & 0x20 == 0), + "no member after the first should throw the model away" + ); + + // The same member, coded by a chain that has read nothing. + let alone = Unpack29Encoder::with_options(EncodeOptions::default()) + .encode_member_with_engine( + members.last().unwrap(), + ChainEngine::Smaller, + &[], + &mut |_| true, + ) + .unwrap(); + let last = ppmd.last().unwrap(); + assert!( + last.len() * 6 < alone.len() * 5, + "a member coded against the chain's model cost {} bytes against {} on its own", + last.len(), + alone.len() + ); +} + +/// Both engines carry state and only the winner's may advance, or the +/// reader is left holding something the writer never wrote. +#[test] +fn a_solid_chain_mixing_engines_round_trips() { + let mut members: Vec> = Vec::new(); + for index in 0..3u64 { + members.push(related_text_member(index + 1, 200)); + // Bytes PPMd loses on, so the chain has to switch engines and back. + let mut state = 0x9e37_79b9_7f4a_7c15u64 ^ index; + let mut noise = Vec::new(); + while noise.len() < 20_000 { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + noise.extend_from_slice(&state.to_le_bytes()); + } + members.push(noise); + } + + let mut chain = Unpack29Encoder::with_options(EncodeOptions::default()); + let mut stream = Vec::new(); + let mut engines = Vec::new(); + for member in &members { + let packed = chain + .encode_member_with_engine(member, ChainEngine::Smaller, &[], &mut |_| true) + .unwrap(); + engines.push(packed[0] & 0x80 != 0); + stream.push(packed); + } + assert!( + engines.contains(&true) && engines.contains(&false), + "this chain was meant to use both engines, got {engines:?}" + ); + + let mut decoder = Unpack29::new(); + for (packed, member) in stream.iter().zip(&members) { + assert_eq!( + decoder.decode_member(packed, member.len()).unwrap(), + *member + ); + } +} + +/// Calls to fixed addresses, which the x86 filter flattens into three +/// repeated values. See the writer's own copy of this for why the operand +/// is relative. +fn call_heavy_x86(seed: u32, calls: usize) -> Vec { + const TARGETS: [u32; 3] = [0x1000, 0x2400, 0x3800]; + let mut data = Vec::with_capacity(calls * 16); + let mut state = seed | 1; + for index in 0..calls { + let target = TARGETS[index % TARGETS.len()]; + let relative = target.wrapping_sub(data.len() as u32 + 5); + data.push(0xe8); + data.extend_from_slice(&relative.to_le_bytes()); + for _ in 0..11 { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + data.push((state >> 24) as u8 | 0x40); + } + } + data +} + +/// Only the winning candidate may move the chain. +/// +/// Every candidate codes the member for real, and each one leaves a +/// code-length table and a window behind it. A reader rebuilds both from +/// the bytes it actually reads, so committing a loser's leaves the next +/// member coded against a table and a history no decoder holds. That does +/// not show up as an error: the member after it decodes to plausible +/// rubbish, which is why this decodes the whole chain rather than checking +/// sizes. +#[test] +fn a_solid_chain_keeps_only_the_winning_candidates_state() { + // One member per outcome. The x86 member takes the x86 filter, the + // counters take the delta, and the text takes neither, so every + // candidate both wins somewhere and loses somewhere. Text is the + // member that matters: delta rewrites it into something with a very + // different table, and that table is exactly what must not survive + // losing. + let x86 = call_heavy_x86(0x1234_5678, 400); + let counters: Vec = (0..1600u32).flat_map(|n| (n * 7).to_le_bytes()).collect(); + let mut text = Vec::new(); + for index in 0..400u32 { + text.extend_from_slice(format!("field_{index:04} = value {index:04}\n").as_bytes()); + } + let members = [x86, counters, text]; + + let candidates = vec![ + Vec::new(), + vec![crate::FilterSpec::whole(crate::FilterKind::E8)], + vec![crate::FilterSpec::whole(crate::FilterKind::Delta { + channels: 4, + })], + ]; + let mut chain = Unpack29Encoder::with_options(EncodeOptions::default()); + let stream: Vec> = members + .iter() + .map(|member| { + chain + .encode_member_with_engine(member, ChainEngine::Lz, &candidates, &mut |_| true) + .unwrap() + }) + .collect(); + + // A chain offered no candidates at all, to prove the filter was + // chosen rather than never reached. Only the first member is + // comparable member-for-member: once the chains disagree about what + // they coded, they disagree about their histories too. + let unfiltered_only = { + let mut chain = Unpack29Encoder::with_options(EncodeOptions::default()); + members + .iter() + .map(|member| { + chain + .encode_member_with_engine(member, ChainEngine::Lz, &[], &mut |_| true) + .unwrap() + }) + .collect::>() + }; + assert!( + stream[0].len() < unfiltered_only[0].len(), + "the x86 member should have taken the filter, got {} bytes against {}", + stream[0].len(), + unfiltered_only[0].len() + ); + let chosen: usize = stream.iter().map(Vec::len).sum(); + let never: usize = unfiltered_only.iter().map(Vec::len).sum(); + assert!( + chosen < never, + "the chain that could choose wrote {chosen} bytes against {never}" + ); + + // Coding each member again for every candidate is only safe if the + // losers leave nothing behind, so the chain is decoded a member at a + // time and its table compared with the reader's after each one. The + // bytes alone would not catch a wrong table: a member whose deltas are + // applied to the wrong base still decodes, to rubbish, and only the + // member after it notices. + let mut decoder = Unpack29::new(); + let mut chain = Unpack29Encoder::with_options(EncodeOptions::default()); + for (index, member) in members.iter().enumerate() { + let packed = chain + .encode_member_with_engine(member, ChainEngine::Lz, &candidates, &mut |_| true) + .unwrap(); + assert_eq!(packed, stream[index]); + assert_eq!( + decoder.decode_member(&packed, member.len()).unwrap(), + *member + ); + assert_eq!( + chain.levels, decoder.levels, + "member {index} left the writer holding a table the reader does not" + ); + // The reader's window holds what the LZ layer coded, filters not + // yet applied, which is the same thing the writer remembers. + let common = chain.history.len().min(decoder.output.len()); + assert_eq!( + chain.history[chain.history.len() - common..], + decoder.output[decoder.output.len() - common..], + "member {index} left the writer remembering bytes the reader never held" + ); + } +} + +/// The reader carries its table across the members of a solid chain, so +/// members that look alike stop paying to describe the same table again. +#[test] +fn a_solid_chain_stops_repaying_for_the_same_table() { + let mut member = Vec::new(); + for index in 0..400u32 { + member.extend_from_slice(format!("field_{index:04} = value {index:04}\n").as_bytes()); + } + + let mut chained = Unpack29Encoder::with_options(EncodeOptions::default()); + let first = chained.encode_member(&member).unwrap(); + let second = chained.encode_member(&member).unwrap(); + + let mut alone = Unpack29Encoder::with_options(EncodeOptions::default()); + alone.encode_member(&member).unwrap(); + let restated = Unpack29Encoder::with_options(EncodeOptions::default()) + .encode_member(&member) + .unwrap(); + + assert_eq!(first.len(), restated.len()); + assert!( + second.len() < restated.len(), + "the second member of the chain cost {} bytes against {} on its own", + second.len(), + restated.len() + ); +} + +/// The tokens the hybrid encoder emits for `input`, decided against the +/// same live model the production path prices against. +fn hybrid_tokens(input: &[u8], max_match_distance: usize) -> Vec { + let mut encoder = + PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB)).unwrap(); + let mut tokens = Vec::new(); + encode_ppmd_hybrid(input, max_match_distance, &mut encoder, |token| { + tokens.push(token) + }) + .unwrap(); + tokens +} + +const COMPRESSED_TEXT: &[u8] = &[ + 0x09, 0x10, 0x10, 0x93, 0xe4, 0xce, 0x7f, 0xa2, 0xba, 0x80, 0x46, 0x16, 0x82, 0x63, 0xe9, 0x9a, + 0x19, 0xe4, 0x10, 0xe0, 0x41, 0x3d, 0x16, 0xfc, 0x4d, 0xfa, 0x6f, 0xf2, 0x5c, 0xae, 0x32, 0x86, + 0xc9, 0x95, 0x9d, 0xf1, 0x04, 0xa4, 0xe8, 0x92, 0x8f, 0x12, 0xd7, 0xe7, 0xba, 0xcb, 0x26, 0xf1, + 0x97, 0xac, 0x7c, 0x5f, 0xfd, 0xa0, 0x00, 0x1f, 0x77, 0x50, +]; + +#[test] +fn decodes_rar29_lz_member() { + assert_eq!( + unpack29_decode(COMPRESSED_TEXT, 2400).unwrap(), + expected_text() + ); +} + +#[test] +fn rejects_oversubscribed_rar29_huffman_tables() { + assert!(matches!( + Huffman::from_lengths(&[1, 1, 1]), + Err(Error::InvalidData("RAR 2.9 oversubscribed Huffman table")) + )); +} + +#[test] +fn codec_helpers_reject_out_of_contract_reads_and_history() { + assert_eq!( + BitReader::from_bytes(&[0; 4]).peek_bits(25), + Err(Error::InvalidData("RAR 2.9 bit read is too wide")) + ); + + let mut decoder = Unpack29::new(); + decoder.base_offset = 10; + decoder.output.extend_from_slice(b"retained").unwrap(); + assert_eq!( + decoder.raw_range(9, 10), + Err(Error::InvalidData( + "RAR 2.9 retained history is unavailable" + )) + ); + assert_eq!( + decoder.raw_range(12, 11), + Err(Error::InvalidData( + "RAR 2.9 retained history is unavailable" + )) + ); + assert_eq!( + decoder.raw_range(10, 19), + Err(Error::InvalidData( + "RAR 2.9 retained history is unavailable" + )) + ); +} + +#[test] +fn canonical_assignment_matches_pinned_codes_and_generated_alphabets() { + let pinned = canonical_codes(&[1, 2, 3, 3, 0]); + assert_eq!( + pinned + .iter() + .map(|code| code.map(|code| (code.code, code.len))) + .collect::>(), + [Some((0, 1)), Some((2, 2)), Some((6, 3)), Some((7, 3)), None] + ); + for size in [ + super::LEVEL_COUNT, + MAIN_COUNT, + OFFSET_COUNT, + LOW_OFFSET_COUNT, + LENGTH_COUNT, + ] { + let mut single = vec![0; size]; + single[size - 1] = 1; + let mut deep = vec![0; size]; + let (mut a, mut b) = (1, 1); + for frequency in deep.iter_mut().take(40) { + *frequency = a; + (a, b) = (b, a + b); + } + for frequencies in [ + vec![0; size], + single, + vec![1; size], + (0..size).map(|i| usize::from(i % 3 == 0)).collect(), + deep, + ] { + let lengths = crate::codec::huffman::lengths_for_frequencies(&frequencies, 15); + assert!(lengths.iter().all(|&length| length <= 15)); + let codes = canonical_codes(&lengths); + let table = Huffman::from_lengths(&lengths).unwrap(); + for (symbol, code) in codes.iter().enumerate() { + assert_eq!(code.is_some(), frequencies[symbol] != 0); + if let Some(code) = code { + let mut bits = BitWriter::default(); + bits.write_bits(u32::from(code.code), code.len); + assert_eq!( + table + .decode(&mut BitReader::from_bytes(&bits.finish())) + .unwrap(), + symbol + ); + } + } + } + } +} + +#[test] +fn huffman_decoding_returns_the_index_from_its_constructor_alphabet() { + for size in [20, MAIN_COUNT, OFFSET_COUNT, LOW_OFFSET_COUNT, LENGTH_COUNT] { + let lengths = crate::codec::huffman::complete_lengths_for_frequencies(&vec![1; size], 15); + let codes = canonical_codes(&lengths); + let table = Huffman::from_lengths(&lengths).unwrap(); + + for (expected, code) in codes.iter().enumerate() { + let code = code.unwrap(); + let mut bits = BitWriter::default(); + bits.write_bits(u32::from(code.code), code.len); + let mut bits = BitReader::from_bytes(&bits.finish()); + let decoded = table.decode(&mut bits).unwrap(); + assert_eq!(decoded, expected); + assert!(decoded < size); + } + } +} + +fn table_description(level_lengths: &[u8; 20], tokens: &[LevelToken]) -> Vec { + let codes = canonical_codes(level_lengths); + let mut bits = BitWriter::default(); + bits.write_bit(false); + bits.write_bit(false); + for &length in level_lengths { + bits.write_bits(u32::from(length), 4); + } + for token in tokens { + let code = codes[token.symbol].unwrap(); + bits.write_bits(u32::from(code.code), code.len); + bits.write_bits(u32::from(token.extra_value), token.extra_bits); + } + bits.finish() +} + +fn encoded_table_description(levels: &[u8; TABLE_COUNT]) -> Vec { + let tokens = encode_table_level_tokens(levels); + let level_lengths = level_code_lengths(&tokens); + table_description(&level_lengths, &tokens) +} + +#[test] +fn table_repeats_at_position_zero_are_rejected() { + for symbol in [16, 17] { + let mut level_lengths = [0; 20]; + level_lengths[0] = 1; + level_lengths[symbol] = 1; + let token = if symbol == 16 { + LevelToken::repeat_previous_short(3) + } else { + LevelToken::repeat_previous_long(11) + }; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&table_description(&level_lengths, &[token])); + + let expected = if symbol == 16 { + Error::InvalidData("RAR 2.9 table repeat at start") + } else { + Error::InvalidData("RAR 2.9 long table repeat at start") + }; + assert_eq!(decoder.read_tables(), Err(expected)); + } +} + +#[test] +fn table_run_past_the_destination_is_truncated_for_compatibility() { + let mut level_lengths = [0; 20]; + level_lengths[0] = 1; + level_lengths[19] = 1; + let tokens = [ + LevelToken::zero_run_long(138), + LevelToken::zero_run_long(138), + LevelToken::zero_run_long(138), + ]; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&table_description(&level_lengths, &tokens)); + + decoder.read_tables().unwrap(); + + assert_eq!(decoder.levels, [0; TABLE_COUNT]); +} + +#[test] +fn empty_level_and_main_tables_fail_when_used() { + let mut empty_level_decoder = Unpack29::new(); + empty_level_decoder.bits = BitReader::from_bytes(&table_description(&[0; 20], &[])); + assert_eq!( + empty_level_decoder.read_tables(), + Err(Error::InvalidData("RAR 2.9 empty Huffman table")) + ); + + let mut empty_main_decoder = Unpack29::new(); + empty_main_decoder.bits = BitReader::from_bytes(&encoded_table_description(&[0; TABLE_COUNT])); + empty_main_decoder.read_tables().unwrap(); + assert_eq!( + empty_main_decoder.main.decode(&mut empty_main_decoder.bits), + Err(Error::InvalidData("RAR 2.9 empty Huffman table")) + ); +} + +#[test] +fn incomplete_huffman_table_accepts_assigned_and_rejects_unassigned_prefixes() { + let table = Huffman::from_lengths(&[2]).unwrap(); + let mut assigned = BitReader::from_bytes(&[0]); + assert_eq!(table.decode(&mut assigned), Ok(0)); + + let mut unassigned = BitReader::from_bytes(&[0x40, 0]); + assert_eq!( + table.decode(&mut unassigned), + Err(Error::InvalidData("RAR 2.9 invalid Huffman code")) + ); +} + +#[test] +fn truncated_table_headers_and_descriptions_need_more_input() { + let mut truncated_header = BitWriter::default(); + truncated_header.write_bit(false); + truncated_header.write_bit(false); + truncated_header.write_bits(1, 4); + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&truncated_header.finish()); + assert_eq!(decoder.read_tables(), Err(Error::NeedMoreInput)); + + let mut level_lengths = [0; 20]; + level_lengths[0] = 1; + level_lengths[19] = 1; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&table_description( + &level_lengths, + &[LevelToken::zero_run_long(138)], + )); + assert_eq!(decoder.read_tables(), Err(Error::NeedMoreInput)); +} + +#[test] +fn level_and_final_tables_reject_oversubscription() { + let mut oversubscribed_level = BitWriter::default(); + oversubscribed_level.write_bit(false); + oversubscribed_level.write_bit(false); + for length in [1, 1, 1].into_iter().chain(std::iter::repeat_n(0, 17)) { + oversubscribed_level.write_bits(length, 4); + } + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&oversubscribed_level.finish()); + assert_eq!( + decoder.read_tables(), + Err(Error::InvalidData("RAR 2.9 oversubscribed Huffman table")) + ); + + let mut level_lengths = [0; 20]; + level_lengths[1] = 1; + level_lengths[19] = 1; + let tokens = [ + LevelToken::plain(1), + LevelToken::plain(1), + LevelToken::plain(1), + LevelToken::zero_run_long(138), + LevelToken::zero_run_long(138), + LevelToken::zero_run_long(125), + ]; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&table_description(&level_lengths, &tokens)); + assert_eq!( + decoder.read_tables(), + Err(Error::InvalidData("RAR 2.9 oversubscribed Huffman table")) + ); +} + +#[test] +fn every_final_table_slice_rejects_oversubscription() { + let slices = [ + MAIN_COUNT..MAIN_COUNT + OFFSET_COUNT, + MAIN_COUNT + OFFSET_COUNT..MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT, + MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT..TABLE_COUNT, + ]; + for slice in slices { + let mut levels = [0; TABLE_COUNT]; + levels[b'A' as usize] = 1; + levels[256] = 1; + levels[slice.start] = 1; + levels[slice.start + 1] = 1; + levels[slice.start + 2] = 1; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&encoded_table_description(&levels)); + + assert_eq!( + decoder.read_tables(), + Err(Error::InvalidData("RAR 2.9 oversubscribed Huffman table")) + ); + } +} + +#[test] +fn level_length_header_accepts_literal_fifteen_and_clips_zero_runs() { + let mut bits = BitWriter::default(); + bits.write_bits(15, 4); + bits.write_bits(0, 4); + bits.write_bits(15, 4); + bits.write_bits(15, 4); + bits.write_bits(15, 4); + bits.write_bits(1, 4); + let mut bits = BitReader::from_bytes(&bits.finish()); + + let lengths = Unpack29::read_level_lengths(&mut bits).unwrap(); + + assert_eq!(lengths[0], 15); + assert_eq!(lengths[1..], [0; 19]); +} + +#[test] +fn unused_auxiliary_huffman_tables_may_be_empty() { + let mut levels = [0; TABLE_COUNT]; + levels[b'A' as usize] = 1; + levels[256] = 1; + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&encoded_table_description(&levels)); + + decoder.read_tables().unwrap(); + + assert!(!decoder.main.state.is_empty()); + assert!(decoder.offsets.state.is_empty()); + assert!(decoder.low_offsets.state.is_empty()); + assert!(decoder.lengths.state.is_empty()); + assert_eq!( + decoder.main.state.len() + + decoder.offsets.state.len() + + decoder.low_offsets.state.len() + + decoder.lengths.state.len(), + 2 + ); + assert_eq!( + MAIN_COUNT + OFFSET_COUNT + LOW_OFFSET_COUNT + LENGTH_COUNT, + TABLE_COUNT + ); +} + +#[test] +fn literal_encoder_round_trips_rar29_lz_blocks() { + let input = b"literal-only RAR 2.9 baseline\nwith repeated text literal-only\n"; + let packed = unpack29_encode_literals(input).unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn an_lz_member_ends_with_a_new_file_marker() { + let input = b"RAR 2.9 terminator check, with repeated text to force a match: \ +RAR 2.9 terminator check\n"; + let packed = unpack29_encode_literals(input).unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn rejects_a_final_lz_marker_that_promises_a_missing_table() { + let input = b"RAR 2.9 missing final table check\n".repeat(8); + let mut packed = unpack29_encode_literals(&input).unwrap(); + let last_nonzero = packed.iter().rposition(|&byte| byte != 0).unwrap(); + let final_one = 1 << packed[last_nonzero].trailing_zeros(); + let preceding_bit = final_one << 1; + assert_eq!(packed[last_nonzero] & preceding_bit, 0); + packed[last_nonzero] ^= final_one | preceding_bit; + + assert!(matches!( + unpack29_decode(&packed, input.len()), + Err(Error::InvalidData("RAR 2.9 bitstream is truncated")) + )); +} + +/// A member split across LZ blocks marks every block but the last as having +/// another table after it. +#[test] +fn every_block_but_the_last_says_another_table_follows() { + let input = b"rar29 multi block terminator check with repeated filler text\n".repeat(400); + let packed = super::encode_member_with_options( + &input, + &[], + EncodeOptions::new(96).with_block_size(4096), + ) + .unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn rejects_a_new_file_marker_before_the_declared_member_size() { + let first = b"first block ends too soon\n".repeat(64); + let second = b"second block must not be decoded as the same member\n".repeat(64); + let mut levels = [0; TABLE_COUNT]; + let mut packed = super::encode_member_inner( + &first, + &[], + &[], + EncodeOptions::new(96), + false, + &mut levels, + None, + ) + .unwrap(); + packed.extend_from_slice( + &super::encode_member_inner( + &second, + &first, + &[], + EncodeOptions::new(96), + false, + &mut levels, + None, + ) + .unwrap(), + ); + + assert!(matches!( + unpack29_decode(&packed, first.len() + second.len()), + Err(Error::InvalidData( + "RAR 2.9 member ended before its declared size" + )) + )); +} + +#[test] +fn rejects_an_lz_literal_after_the_declared_member_size() { + let input = b"literal-only RAR 2.9 member"; + let packed = unpack29_encode_literals(input).unwrap(); + + assert!(matches!( + unpack29_decode(&packed, input.len() - 1), + Err(Error::InvalidData("RAR 2.9 LZ member has trailing data")) + )); +} + +#[test] +fn rejects_an_lz_match_crossing_the_declared_member_size() { + let input = b"repeated tail ".repeat(256); + let packed = Unpack29Encoder::new().encode_member(&input).unwrap(); + + assert!(matches!( + unpack29_decode(&packed, input.len() - 1), + Err(Error::InvalidData( + "RAR 2.9 member produces more output than its declared size" + )) + )); +} + +#[test] +fn multi_block_lz_encoding_round_trips_large_repeated_documents() { + let seed = b"\n\ +

RAR29 repeated document body with enough structured text to \ +exercise LZSS block table selection.

\n" + .repeat(96); + let input = seed.repeat(180); + let single = super::encode_member_with_options(&input, &[], EncodeOptions::new(96)).unwrap(); + let blocked = super::encode_member_with_options( + &input, + &[], + EncodeOptions::new(96).with_block_size(1024 * 1024), + ) + .unwrap(); + + assert_eq!(unpack29_decode(&single, input.len()).unwrap(), input); + assert_eq!(unpack29_decode(&blocked, input.len()).unwrap(), input); + assert!(blocked.len() < input.len()); +} + +#[test] +fn matched_member_streams_across_flush_and_history_boundaries() { + struct RecordingSink { + data: Vec, + writes: Vec, + } + + impl std::io::Write for RecordingSink { + fn write(&mut self, data: &[u8]) -> std::io::Result { + self.writes.push(data.len()); + self.data.extend_from_slice(data); + Ok(data.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + // After the first literal, runs are encoded as 258-byte matches. The + // match starting at 1,048,513 therefore crosses the first 1 MiB flush + // boundary and has to be resumed by the next decode batch. + let input = vec![b'Z'; MAX_HISTORY + STREAM_CHUNK + 513]; + let mut encoder = Unpack29Encoder::new(); + let packed = encoder.encode_member(&input).unwrap(); + assert_eq!(encoder.history.len(), MAX_HISTORY); + + let mut decoder = Unpack29::new(); + let mut sink = RecordingSink { + data: Vec::new(), + writes: Vec::new(), + }; + decoder + .decode_member_to(&packed, input.len(), &mut sink) + .unwrap(); + + assert_eq!(sink.data, input); + assert_eq!( + sink.writes, + [STREAM_CHUNK; 5] + .into_iter() + .chain([513]) + .collect::>() + ); + assert_eq!(decoder.base_offset, input.len() - MAX_HISTORY); + assert_eq!(decoder.output.len(), MAX_HISTORY); + assert!(decoder.pending_match.is_none()); +} + +#[test] +fn solid_follower_can_match_the_oldest_retained_history() { + let mut state = 0x6d2b_79f5u32; + let marker: Vec = (0..MAX_ENCODER_MATCH_LENGTH) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let mut first = vec![b'X'; 17]; + first.extend_from_slice(&marker); + first.resize(MAX_HISTORY + 17, b'Z'); + + let options = EncodeOptions::default().with_max_match_distance(MAX_HISTORY); + let mut encoder = Unpack29Encoder::with_options(options); + let first_packed = encoder.encode_member(&first).unwrap(); + assert_eq!(encoder.history.len(), MAX_HISTORY); + assert_eq!(&encoder.history[..marker.len()], marker); + + let follower_tokens = encode_tokens(&marker, &encoder.history, options); + assert!(follower_tokens.iter().any(|token| matches!( + token, + EncodeToken::Match { offset, .. } if *offset == MAX_HISTORY + ))); + let follower_packed = encoder.encode_member(&marker).unwrap(); + + let mut decoder = Unpack29::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!(decoder.base_offset, 17); + assert_eq!( + decoder + .decode_member(&follower_packed, marker.len()) + .unwrap(), + marker + ); + assert_eq!(decoder.output.len(), MAX_HISTORY); + assert_eq!(decoder.base_offset, 17 + marker.len()); +} + +#[test] +fn block_encoder_trims_local_history_at_the_dictionary_boundary() { + let history = vec![b'Z'; MAX_HISTORY]; + let options = EncodeOptions::new(0).with_block_size(1); + let mut encoder = Unpack29Encoder::with_options(options); + encoder.history.clone_from(&history); + let packed = encoder.encode_member(b"AB").unwrap(); + + let mut decoder = Unpack29::new(); + decoder.output = history.into(); + assert_eq!(decoder.decode_member(&packed, 2).unwrap(), b"AB"); + assert_eq!(encoder.history.len(), MAX_HISTORY); + assert_eq!(&encoder.history[MAX_HISTORY - 2..], b"AB"); + assert_eq!(&decoder.output[MAX_HISTORY - 2..], b"AB"); +} + +#[test] +fn filter_spanning_a_flush_waits_for_complete_input_and_is_retired() { + struct RecordingSink { + data: Vec, + writes: Vec, + } + + impl std::io::Write for RecordingSink { + fn write(&mut self, data: &[u8]) -> std::io::Result { + self.writes.push(data.len()); + self.data.extend_from_slice(data); + Ok(data.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let filter_range = STREAM_CHUNK - 512..STREAM_CHUNK + 512; + let mut input = vec![b'Z'; MAX_HISTORY + STREAM_CHUNK + 513]; + for position in (filter_range.start..filter_range.end - 4).step_by(16) { + input[position] = 0xe8; + input[position + 1..position + 5].copy_from_slice(&0x1234u32.to_le_bytes()); + } + // Literal coding stops exactly at the streaming target. Match coding + // can legally overshoot it and happen to complete this small filter in + // the same decode pass, which would not exercise the wait. + let packed = Unpack29Encoder::with_options(EncodeOptions::new(0)) + .encode_member_with_filter( + &input, + crate::FilterSpec::range(crate::FilterKind::E8, filter_range.clone()), + ) + .unwrap(); + + let mut decoder = Unpack29::new(); + let mut sink = RecordingSink { + data: Vec::new(), + writes: Vec::new(), + }; + decoder + .decode_member_to(&packed, input.len(), &mut sink) + .unwrap(); + + assert_eq!(sink.data, input); + assert_eq!(sink.writes[0], filter_range.start); + assert_eq!(sink.writes[1], STREAM_CHUNK + 512); + assert!(decoder.filters.is_empty()); + + let mut decoder = Unpack29::new(); + let mut prematurely_emitted = Vec::new(); + assert_eq!( + decoder + .decode_member_to(&packed, filter_range.end - 1, &mut prematurely_emitted) + .unwrap_err(), + Error::InvalidData("RAR 2.9 VM filter extends beyond output") + ); + assert!(prematurely_emitted.is_empty()); +} + +#[test] +fn a_future_filter_stays_scheduled_until_its_range_is_published() { + let mut decoder = Unpack29::new(); + decoder.output.resize(128, 0).unwrap(); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: 8, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 64, + size: 8, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + assert_eq!(decoder.safe_flush_end(0, 32, 128).unwrap(), 32); + assert_eq!(decoder.filtered_range(0, 32, 0).unwrap(), vec![0; 32]); + assert_eq!(decoder.filters.len(), 1); + + assert_eq!(decoder.filtered_range(32, 72, 0).unwrap(), vec![0; 40]); + assert!(decoder.filters.is_empty()); +} + +#[test] +fn history_trimming_discards_stale_filters_and_keeps_future_filters() { + let mut decoder = Unpack29::new(); + decoder.output.resize(MAX_HISTORY + 64, 0).unwrap(); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: 8, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 0, + size: 8, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 128, + size: 8, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + decoder.trim_history(MAX_HISTORY + 64, MAX_HISTORY + 64); + + assert_eq!(decoder.base_offset, 64); + assert_eq!(decoder.output.len(), MAX_HISTORY); + assert_eq!(decoder.filters.len(), 1); + assert_eq!(decoder.filters[0].start, 128); + assert_eq!(decoder.filtered_range(64, 136, 0).unwrap(), vec![0; 72]); + assert!(decoder.filters.is_empty()); +} + +#[test] +fn solid_ppmd_match_rejects_distance_beyond_retained_history() { + let input = vec![b'Z'; MAX_HISTORY + 64]; + let packed = unpack29_encode_literals(&input).unwrap(); + let mut decoder = Unpack29::new(); + decoder + .decode_non_solid_member_to(&packed, input.len(), &mut std::io::sink()) + .unwrap(); + assert_eq!(decoder.base_offset, 64); + + let mut encoder = PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, 1).unwrap(); + encoder.encode_match(MAX_HISTORY + 1, 32).unwrap(); + let (body, _) = encoder.finish_keeping_model().unwrap(); + let mut packed = vec![0x80 | 0x20 | (PPMD_ORDER as u8 - 1), 0]; + packed.extend_from_slice(&body); + assert_eq!( + decoder.decode_member_to(&packed, 32, &mut std::io::sink()), + Err(Error::InvalidData("RAR 2.9 match distance is out of range")) + ); +} + +#[test] +fn ppmd_member_rejects_a_vm_filter_range_beyond_native_output() { + let record = super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: u32::MAX as usize, + init_regs: &[], + code: super::RAR3_E8_FILTER_BYTECODE, + global_data: &[], + }, + 0, + true, + ) + .unwrap(); + let mut encoder = PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, 1).unwrap(); + encoder.encode_literal(b'A').unwrap(); + encoder.encode_vm_filter_record(&record).unwrap(); + encoder.encode_literal(b'B').unwrap(); + let (body, _) = encoder.finish_keeping_model().unwrap(); + let mut packed = vec![0x80 | 0x20 | (PPMD_ORDER as u8 - 1), 0]; + packed.extend_from_slice(&body); + let message = if cfg!(target_pointer_width = "32") { + "RAR 2.9 VM filter size overflows" + } else { + "RAR 2.9 VM filter extends beyond output" + }; + assert_eq!( + unpack29_decode(&packed, 2), + Err(Error::InvalidData(message)) + ); +} + +#[test] +fn stale_filter_ranges_do_not_change_later_published_bytes() { + let mut decoder = Unpack29::new(); + decoder.output.resize(32, 0x5a).unwrap(); + decoder + .filters + .push(VmFilter { + program: usize::MAX, + start: 0, + size: 8, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + assert_eq!(decoder.safe_flush_end(16, 32, 32).unwrap(), 32); + assert_eq!(decoder.filtered_range(16, 32, 0).unwrap(), vec![0x5a; 16]); +} + +#[test] +fn table_level_encoder_uses_rar29_run_symbols() { + let mut lengths = [0u8; TABLE_COUNT]; + lengths[..4].fill(5); + lengths[8..21].fill(0); + + let tokens = encode_table_level_tokens(&lengths); + + assert!(tokens.contains(&LevelToken::repeat_previous_short(3))); + assert!(tokens.iter().any(|token| token.symbol == 19)); +} + +#[test] +fn lazy_lz_parser_defers_short_match_for_longer_next_match() { + let input = b"abcdXbcdYYYYYYYYYYYYabcdYYYYYYYYYYYY"; + let greedy = encode_tokens(input, &[], EncodeOptions::new(MAX_MATCH_CANDIDATES)); + let lazy = encode_tokens( + input, + &[], + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_lazy_matching(true), + ); + let packed = Unpack29Encoder::with_options( + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_lazy_matching(true), + ) + .encode_member(input) + .unwrap(); + + assert!(greedy + .iter() + .any(|token| matches!(token, EncodeToken::Match { length: 4, .. }))); + assert!(lazy + .iter() + .any(|token| matches!(token, EncodeToken::Match { length, .. } if *length > 8))); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn lazy_lz_parser_uses_match_cost_not_only_match_length() { + let pos = 300_000usize; + let mut input = vec![0u8; pos + 16]; + input[100..106].copy_from_slice(b"BCDEFG"); + input[106] = b'!'; + input[pos - 10..pos - 5].copy_from_slice(b"ABCD!"); + input[pos..pos + 7].copy_from_slice(b"ABCDEFG"); + let mut finder = Rar29MatchFinder::new(input.len()); + finder.insert(&input, 100); + finder.insert(&input, pos - 10); + + let current = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::new(MAX_MATCH_CANDIDATES), + &EncoderMatchState::default(), + ) + .unwrap(); + let next = best_match( + &input, + pos + 1, + input.len(), + &finder, + EncodeOptions::new(MAX_MATCH_CANDIDATES), + &EncoderMatchState::default(), + ) + .unwrap(); + + assert_eq!(current.length, 4); + assert_eq!(current.offset, 10); + assert_eq!(next.length, 6); + assert!(next.offset > 0x40000); + assert!(!should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_lazy_matching(true), + &EncoderMatchState::default(), + current, + )); +} + +#[test] +fn lazy_lz_parser_uses_bounded_cost_lookahead() { + let pos = 160; + let mut input: Vec = (0..240u16) + .map(|value| value.wrapping_mul(91) as u8) + .collect(); + input[pos - 30..pos - 22].copy_from_slice(b"ABCDEFGH"); + input[pos - 80..pos - 64].copy_from_slice(b"CDEFGHIJKLMNOPQR"); + input[pos..pos + 18].copy_from_slice(b"ABCDEFGHIJKLMNOPQR"); + + let mut finder = Rar29MatchFinder::new(input.len()); + for candidate in 0..pos { + finder.insert(&input, candidate); + } + let current = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &EncoderMatchState::default(), + ) + .unwrap(); + + assert_eq!((current.length, current.offset), (8, 30)); + assert!(!should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(1), + &EncoderMatchState::default(), + current, + )); + assert!(should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(2), + &EncoderMatchState::default(), + current, + )); +} + +#[test] +fn lazy_lz_parser_stops_lookahead_at_member_end() { + let input = b"aaaaaa"; + let mut finder = Rar29MatchFinder::new(input.len()); + finder.insert(input, 0); + let state = EncoderMatchState::default(); + let options = EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(16); + let current = best_match(input, 2, input.len(), &finder, options, &state).unwrap(); + + assert_eq!((current.length, current.offset), (4, 2)); + assert!(!should_lazy_emit_literal( + input, 2, &finder, options, &state, current, + )); +} + +#[test] +fn match_state_encodes_last_length_and_repeat_offset_symbols() { + let mut state = EncoderMatchState::default(); + assert!(matches!( + state.encode_match(12, 64).unwrap(), + super::EncodedMatch::Fresh { .. } + )); + state.remember(12, 64); + + assert_eq!( + state.encode_match(12, 64).unwrap(), + super::EncodedMatch::LastLengthRepeat + ); + assert!(matches!( + state.encode_match(9, 64).unwrap(), + super::EncodedMatch::RepeatOffset { index: 0, .. } + )); + + assert!(matches!( + state.encode_match(MAX_ENCODER_MATCH_LENGTH, 64).unwrap(), + super::EncodedMatch::Fresh { .. } + )); + state.remember(MAX_ENCODER_MATCH_LENGTH, 64); + assert_eq!(state.old_offsets, [64, 64, 0, 0]); +} + +#[test] +fn match_field_encoders_reject_values_outside_the_wire_ranges() { + assert_eq!( + super::length_slot_for_match(2), + Err(Error::InvalidData("RAR 2.9 match length is too short")) + ); + assert_eq!( + super::length_slot_for_match(MAX_ENCODER_MATCH_LENGTH + 1), + Err(Error::InvalidData("RAR 2.9 match length is too long")) + ); + assert_eq!( + super::length_slot_for_repeat_match(1), + Err(Error::InvalidData( + "RAR 2.9 repeat match length is too short" + )) + ); + assert_eq!( + super::length_slot_for_repeat_match(MAX_ENCODER_MATCH_LENGTH), + Err(Error::InvalidData( + "RAR 2.9 repeat match length is too long" + )) + ); + assert_eq!( + super::offset_slot_for_match(0), + Err(Error::InvalidData("RAR 2.9 match offset is zero")) + ); + let last_slot = OFFSET_COUNT - 1; + let largest_offset = + super::OFFSET_BASES[last_slot] + (1usize << super::OFFSET_BITS[last_slot]) - 1 + 1; + assert_eq!( + super::offset_slot_for_match(largest_offset + 1), + Err(Error::InvalidData("RAR 2.9 match offset is too large")) + ); + let state = EncoderMatchState::default(); + for (length, offset, message) in [ + (0, 0x40000, "RAR 2.9 adjusted match length underflows"), + (4, 0, "RAR 2.9 match offset is zero"), + (5, largest_offset + 1, "RAR 2.9 match offset is too large"), + ] { + assert_eq!( + state.encode_match(length, offset), + Err(Error::InvalidData(message)) + ); + assert_eq!( + super::estimated_match_cost(&state, length, offset), + Err(Error::InvalidData(message)) + ); + let mut candidate = None; + super::consider_match_candidate(&mut candidate, &state, length, offset); + assert_eq!(candidate, None); + } +} + +#[test] +fn match_length_and_offset_slots_have_no_gaps() { + for (bases, bits) in [ + (&super::LENGTH_BASES[..], &super::LENGTH_BITS[..]), + (&super::OFFSET_BASES[..], &super::OFFSET_BITS[..]), + ] { + for index in 1..bases.len() { + assert_eq!(bases[index], bases[index - 1] + (1usize << bits[index - 1])); + } + } +} + +#[test] +fn match_search_respects_fresh_distance_length_adjustments() { + for distance in [0x1fff, 0x2000, 0x3ffff, 0x40000] { + let mut input = vec![0xff; distance + 4]; + input[..4].copy_from_slice(b"ABCD"); + input[distance..].copy_from_slice(b"ABCD"); + let mut finder = Rar29MatchFinder::new(input.len()); + finder.insert(&input, 0); + let options = EncodeOptions::default(); + let fresh = best_match( + &input, + distance, + input.len(), + &finder, + options, + &EncoderMatchState::default(), + ); + if distance == 0x40000 { + assert_eq!(fresh, None); + } else { + let candidate = fresh.unwrap(); + assert_eq!((candidate.length, candidate.offset), (4, distance)); + } + + // A prior legal five-byte fresh match establishes this distance. + // Repeat-distance lengths do not receive fresh-distance additions. + let mut state = EncoderMatchState::default(); + assert!(matches!( + state.encode_match(5, distance).unwrap(), + super::EncodedMatch::Fresh { .. } + )); + state.remember(5, distance); + let repeated = best_match(&input, distance, input.len(), &finder, options, &state).unwrap(); + assert_eq!((repeated.length, repeated.offset), (4, distance)); + assert!(matches!( + state + .encode_match(repeated.length, repeated.offset) + .unwrap(), + super::EncodedMatch::RepeatOffset { index: 0, .. } + )); + } +} + +#[test] +fn match_search_ignores_a_remembered_offset_outside_its_window() { + let input = b"abcdefghijklmnop"; + let finder = Rar29MatchFinder::new(input.len()); + let mut state = EncoderMatchState::default(); + state.old_offsets[0] = 9; + let options = EncodeOptions::default().with_max_match_distance(8); + + assert_eq!( + best_match(input, 8, input.len(), &finder, options, &state), + None + ); +} + +#[test] +fn cost_aware_match_selection_prefers_repeat_offset_token() { + let pos = 600usize; + let mut input: Vec = (0..pos + 16) + .map(|index| (index as u8).wrapping_mul(37)) + .collect(); + input[pos - 30..pos - 22].copy_from_slice(b"ABCDEFGH"); + input[pos - 512..pos - 503].copy_from_slice(b"ABCDEFGHI"); + input[pos..pos + 9].copy_from_slice(b"ABCDEFGHI"); + input[pos - 22] = 0x11; + input[pos - 503] = 0x22; + input[pos + 9] = 0x33; + let mut finder = Rar29MatchFinder::new(input.len()); + finder.insert(&input, pos - 30); + finder.insert(&input, pos - 512); + + let fresh = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &EncoderMatchState::default(), + ) + .unwrap(); + let repeat = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &EncoderMatchState { + old_offsets: [30, 0, 0, 0], + last_offset: 0, + last_length: 0, + }, + ) + .unwrap(); + + assert_eq!((fresh.length, fresh.offset), (9, 512)); + assert_eq!((repeat.length, repeat.offset), (8, 30)); +} + +#[test] +fn match_finder_respects_configured_maximum_distance() { + let phrase = b"rar29 bounded dictionary phrase"; + let mut input = Vec::new(); + input.extend_from_slice(phrase); + input.extend(std::iter::repeat_n(0u8, 256 * 1024)); + input.extend_from_slice(phrase); + + let bounded = encode_tokens( + &input, + &[], + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_max_match_distance(128 * 1024), + ); + let unbounded = encode_tokens( + &input, + &[], + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_max_match_distance(1024 * 1024), + ); + + assert!(!bounded + .iter() + .any(|token| matches!(token, EncodeToken::Match { offset, .. } if *offset > 128 * 1024))); + assert!(unbounded + .iter() + .any(|token| matches!(token, EncodeToken::Match { offset, .. } if *offset > 128 * 1024))); +} + +#[test] +fn encode_options_cap_match_distance_at_the_rar29_window() { + assert_eq!( + EncodeOptions::default() + .with_max_match_distance(usize::MAX) + .max_match_distance, + MAX_HISTORY + ); + + let options = EncodeOptions { + max_match_distance: usize::MAX, + ..EncodeOptions::default() + }; + assert_eq!( + Unpack29Encoder::with_options(options) + .options + .max_match_distance, + MAX_HISTORY + ); +} + +#[test] +fn public_encoders_handle_zero_match_distance_and_one_byte_blocks() { + let input = b"small RAR29 blocks"; + let options = EncodeOptions::default() + .with_max_match_distance(0) + .with_block_size(1); + let packed = Unpack29Encoder::with_options(options) + .encode_member(input) + .unwrap(); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); + + let packed = Unpack29Encoder::with_options(options) + .encode_member_with_filter(input, crate::FilterSpec::whole(crate::FilterKind::E8)) + .unwrap(); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn solid_member_rejects_declared_output_beyond_native_range() { + let mut decoder = super::Unpack29::new(); + decoder + .decode_non_solid_member(COMPRESSED_TEXT, 2400) + .unwrap(); + assert_eq!( + decoder.decode_member(&[], usize::MAX), + Err(Error::InvalidData("RAR 2.9 output size overflows")) + ); +} + +#[test] +fn ppmd_match_finder_uses_the_declared_dictionary_past_one_megabyte() { + let distance = MAX_ENCODER_MATCH_OFFSET + 4096; + let phrase = b"RAR29 PPMd match beyond the old one-megabyte ceiling"; + let mut input = vec![0u8; distance + phrase.len()]; + input[..phrase.len()].copy_from_slice(phrase); + input[distance..].copy_from_slice(phrase); + let mut finder = Rar29MatchFinder::new(input.len()); + finder.insert(&input, 0); + + assert_eq!( + best_ppmd_match(&input, distance, &finder, MAX_HISTORY), + Some((phrase.len(), distance)) + ); +} + +#[test] +fn lz_encoder_uses_weighted_rar29_huffman_tables() { + let mut input = Vec::new(); + for byte in 0u8..120 { + input.push(b'A'); + input.push(byte); + } + let packed = Unpack29Encoder::new().encode_member(&input).unwrap(); + let mut decoder = Unpack29::new(); + decoder.bits.append(&packed); + decoder.read_tables().unwrap(); + let main_lengths = &decoder.levels[..MAIN_COUNT]; + let nonzero_lengths = main_lengths + .iter() + .copied() + .filter(|&length| length != 0) + .collect::>(); + + assert!(nonzero_lengths.len() > 1); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn copy_match_zero_fills_an_offset_that_reaches_past_the_stream() { + let mut decoder = Unpack29::new(); + decoder.output.extend_from_slice(b"AB").unwrap(); + + decoder.copy_match(4, 9, 6).unwrap(); + + assert_eq!(&decoder.output[..], b"AB\0\0\0\0"); +} + +#[test] +fn an_undefined_repeat_distance_zero_fills_like_reference_readers() { + let mut decoder = Unpack29::new(); + let mut main_lengths = vec![0; MAIN_COUNT]; + main_lengths[b'Z' as usize] = 1; + main_lengths[259] = 1; + decoder.main = Huffman::from_lengths(&main_lengths).unwrap(); + let mut repeat_lengths = vec![0; LENGTH_COUNT]; + repeat_lengths[2] = 1; + decoder.lengths = Huffman::from_lengths(&repeat_lengths).unwrap(); + + let main_codes = canonical_codes(&main_lengths); + let repeat_codes = canonical_codes(&repeat_lengths); + let mut bits = BitWriter::default(); + for code in [ + main_codes[b'Z' as usize].unwrap(), + main_codes[259].unwrap(), + repeat_codes[2].unwrap(), + ] { + bits.write_bits(u32::from(code.code), code.len); + } + decoder.bits = BitReader::from_bytes(&bits.finish()); + + decoder.decode_lz(5).unwrap(); + + assert_eq!(&decoder.output[..], b"Z\0\0\0\0"); +} + +#[test] +fn an_undefined_last_match_repeat_is_a_noop_like_reference_readers() { + let mut decoder = Unpack29::new(); + let mut main_lengths = vec![0; MAIN_COUNT]; + main_lengths[258] = 1; + main_lengths[b'X' as usize] = 2; + main_lengths[b'Y' as usize] = 2; + decoder.main = Huffman::from_lengths(&main_lengths).unwrap(); + + let main_codes = canonical_codes(&main_lengths); + let mut bits = BitWriter::default(); + for symbol in [b'X' as usize, 258, b'Y' as usize] { + let code = main_codes[symbol].unwrap(); + bits.write_bits(u32::from(code.code), code.len); + } + decoder.bits = BitReader::from_bytes(&bits.finish()); + + decoder.decode_lz(2).unwrap(); + + assert_eq!(&decoder.output[..], b"XY"); + assert_eq!(decoder.last_length, 0); +} + +#[test] +fn ppmd_literal_encoder_round_trips_rar29_ppmd_blocks() { + let mut input = b"rar29 ppmd literal text payload alpha beta gamma\n".repeat(64); + input.extend_from_slice(&[2, 2, 2, b'e', b's', b'c']); + let packed = unpack29_encode_ppmd_literals(&input).unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); + assert_ne!(packed.first().copied(), Some(0)); +} + +#[test] +fn ppmd_end_block_command_reads_the_next_block() { + let first = b"first PPMd block "; + let second = b"and its continuation"; + let mut packed = vec![ + 0x80 | 0x20 | ((PPMD_ORDER as u8) - 1), + PPMD_DICTIONARY_MB - 1, + ]; + let mut encoder = + PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB)).unwrap(); + for &byte in first { + encoder.encode_literal(byte).unwrap(); + } + let (block, model) = encoder.finish_block_keeping_model().unwrap(); + packed.extend_from_slice(&block); + + packed.push(0x80 | ((PPMD_ORDER as u8) - 1)); + let mut encoder = PpmdEncoder::continuing(model, PPMD_ESC); + for &byte in second { + encoder.encode_literal(byte).unwrap(); + } + let (block, _) = encoder.finish_keeping_model().unwrap(); + packed.extend_from_slice(&block); + + let expected = [first.as_slice(), second.as_slice()].concat(); + assert_eq!(unpack29_decode(&packed, expected.len()).unwrap(), expected); +} + +#[test] +fn ppmd_member_can_end_in_an_empty_following_block() { + let input = b"PPMd output ends before its final empty block"; + let mut packed = vec![ + 0x80 | 0x20 | ((PPMD_ORDER as u8) - 1), + PPMD_DICTIONARY_MB - 1, + ]; + let mut encoder = + PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB)).unwrap(); + for &byte in input { + encoder.encode_literal(byte).unwrap(); + } + let (block, model) = encoder.finish_block_keeping_model().unwrap(); + packed.extend_from_slice(&block); + + packed.push(0x80 | ((PPMD_ORDER as u8) - 1)); + let encoder = PpmdEncoder::continuing(model, PPMD_ESC); + let (block, _) = encoder.finish_keeping_model().unwrap(); + packed.extend_from_slice(&block); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn lz_member_can_end_in_an_empty_following_block() { + let input = b"LZ output ends before its final empty block"; + let mut levels = [0; TABLE_COUNT]; + let options = EncodeOptions::default(); + let mut packed = + super::encode_member_inner(input, &[], &[], options, true, &mut levels, None).unwrap(); + packed.extend_from_slice( + &super::encode_member_inner(&[], input, &[], options, false, &mut levels, None).unwrap(), + ); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn rejects_ppmd_eof_before_the_declared_member_size() { + let input = b"PPMd member with an inflated declared size"; + let packed = unpack29_encode_ppmd_literals(input).unwrap(); + + assert!(matches!( + unpack29_decode(&packed, input.len() + 1), + Err(Error::InvalidData( + "RAR 2.9 member ended before its declared size" + )) + )); +} + +#[test] +fn rejects_ppmd_output_after_the_declared_member_size() { + let input = b"PPMd member with a shortened declared size"; + let packed = unpack29_encode_ppmd_literals(input).unwrap(); + + assert!(matches!( + unpack29_decode(&packed, input.len() - 1), + Err(Error::InvalidData("RAR 2.9 PPMd member has trailing data")) + )); +} + +#[test] +fn rejects_a_truncated_ppmd_end_marker() { + let input = b"PPMd member whose final range-coder byte is missing"; + let mut packed = unpack29_encode_ppmd_literals(input).unwrap(); + packed.pop(); + + assert!(matches!( + unpack29_decode(&packed, input.len()), + Err(Error::InvalidData("RAR 2.9 bitstream is truncated")) + )); +} + +#[test] +fn ppmd_model_exhaustion_is_corruption() { + assert!(matches!( + super::require_ppmd_symbol(None), + Err(Error::InvalidData("RAR 2.9 PPMd model is corrupt")) + )); +} + +#[test] +fn rejects_a_reserved_ppmd_command() { + let input = b"PPMd stream followed by a reserved command"; + let mut packed = vec![ + 0x80 | 0x20 | ((PPMD_ORDER as u8) - 1), + PPMD_DICTIONARY_MB - 1, + ]; + let mut encoder = + PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB)).unwrap(); + for &byte in input { + encoder.encode_literal(byte).unwrap(); + } + packed.extend_from_slice(&encoder.finish_with_command(6).unwrap()); + + assert!(matches!( + unpack29_decode(&packed, input.len()), + Err(Error::InvalidData("RAR 2.9 PPMd member has trailing data")) + )); + assert!(matches!( + unpack29_decode(&packed, input.len() + 1), + Err(Error::InvalidData("RAR 2.9 PPMd command is invalid")) + )); +} + +fn incomplete_ppmd_command(command: u8, parameters: &[u8]) -> Result> { + let mut packed = vec![ + 0x80 | 0x20 | ((PPMD_ORDER as u8) - 1), + PPMD_DICTIONARY_MB - 1, + ]; + let encoder = PpmdEncoder::new(PPMD_ORDER, PPMD_ESC, usize::from(PPMD_DICTIONARY_MB)).unwrap(); + packed.extend_from_slice( + &encoder + .finish_with_command_prefix(command, parameters) + .unwrap(), + ); + unpack29_decode(&packed, 1) +} + +#[test] +fn rejects_truncated_ppmd_match_parameters() { + let cases = [ + (&[][..], "first offset byte"), + (&[0][..], "second offset byte"), + (&[0, 0][..], "third offset byte"), + (&[0, 0, 0][..], "length byte"), + ]; + for (parameters, missing) in cases { + assert!( + incomplete_ppmd_command(4, parameters).is_err(), + "accepted a match missing its {missing}" + ); + } +} + +#[test] +fn rejects_a_truncated_ppmd_repeat_parameter() { + assert!(matches!( + incomplete_ppmd_command(5, &[]), + Err(Error::InvalidData("RAR 2.9 bitstream is truncated")) + )); +} + +#[test] +fn rejects_truncated_ppmd_vm_parameters() { + let cases = [ + (&[][..], "first record byte"), + (&[6][..], "one-byte extended length"), + (&[7][..], "two-byte length high byte"), + (&[7, 0][..], "two-byte length low byte"), + (&[0][..], "one-byte record body"), + (&[6, 0][..], "extended-length record body"), + (&[7, 0, 1][..], "two-byte-length record body"), + ]; + for (parameters, missing) in cases { + assert!( + matches!( + incomplete_ppmd_command(3, parameters), + Err(Error::InvalidData("RAR 2.9 bitstream is truncated")) + ), + "accepted a VM command missing its {missing}" + ); + } +} + +#[test] +fn ppmd_encoder_advertises_period_compatible_model_for_external_decoders() { + let packed = + unpack29_encode_ppmd(b"rar29 ppmd dictionary header", MAX_ENCODER_MATCH_OFFSET).unwrap(); + + assert_eq!(packed[0], 0xa7); + assert_eq!(packed[1], 24); +} + +#[test] +fn ppmd_encoder_emits_offset_one_repeat_escapes() { + let input = b"seed " + .iter() + .copied() + .chain(std::iter::repeat_n(b'Z', 512)) + .collect::>(); + let tokens = hybrid_tokens(&input, MAX_ENCODER_MATCH_OFFSET); + let packed = unpack29_encode_ppmd(&input, MAX_ENCODER_MATCH_OFFSET).unwrap(); + + assert!(tokens + .iter() + .any(|token| matches!(token, PpmdEncodeToken::RepeatOffsetOne { length } if *length >= 4))); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +/// PPMd's escape-4 matches copy out of the same window the LZ decoder +/// keeps, so a match reaching further back than the dictionary the file +/// header declares lands on whatever the decoder still happens to hold. +/// Nothing bounded them, so every RAR 3.0 and 4.0 PPMd member of a large +/// enough file failed its checksum in unrar; RAR 2.9 escaped only because +/// it declares a dictionary eight times larger. +#[test] +fn ppmd_matches_stay_inside_the_declared_dictionary() { + let dictionary = 16 * 1024; + // A distinctive block, repeated once inside the dictionary and once + // well outside it. The near copy is the match the encoder should still + // take, and it is what stops this passing merely because the bound + // suppressed every match there was. + let block: Vec = (0..2048u32) + .map(|index| (index.wrapping_mul(2_654_435_761) >> 24) as u8) + .collect(); + let mut input = block.clone(); + let filler = |input: &mut Vec, until: usize| { + while input.len() < until { + input.extend_from_slice( + format!("filler line {:06} for the gap\n", input.len()).as_bytes(), + ); + } + }; + filler(&mut input, dictionary / 2); + input.extend_from_slice(&block); + filler(&mut input, 3 * dictionary); + input.extend_from_slice(&block); + let tokens = hybrid_tokens(&input, dictionary); + + let furthest = tokens + .iter() + .filter_map(|token| match token { + PpmdEncodeToken::Match { offset, .. } => Some(*offset), + _ => None, + }) + .max() + .expect("the payload has to produce matches for this to mean anything"); + assert!( + furthest <= dictionary, + "a match reached {furthest} bytes back, past the {dictionary} byte dictionary" + ); +} + +#[test] +fn ppmd_encoder_emits_distance_match_escapes() { + let phrase = b"repeated phrase for rar29 ppmd distance escape 4 "; + let mut input = Vec::new(); + input.extend_from_slice(phrase); + input.extend_from_slice(b"middle bytes make the repeat distance greater than one "); + input.extend_from_slice(phrase); + input.extend_from_slice(phrase); + input.extend_from_slice(b"tail"); + let tokens = hybrid_tokens(&input, MAX_ENCODER_MATCH_OFFSET); + let packed = unpack29_encode_ppmd(&input, MAX_ENCODER_MATCH_OFFSET).unwrap(); + + assert!(tokens + .iter() + .any(|token| matches!(token, PpmdEncodeToken::Match { offset, length } if *offset > 1 && *length >= 32))); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn ppmd_distance_match_lengths_stay_period_decoder_compatible() { + let phrase = b"RAR PPMd LZSS conversion phrase\n"; + let mut input = Vec::new(); + for _ in 0..200 { + input.extend_from_slice(phrase); + } + let tokens = hybrid_tokens(&input, MAX_ENCODER_MATCH_OFFSET); + + assert!(tokens.iter().any( + |token| matches!(token, PpmdEncodeToken::Match { offset, length } if *offset > 1 && *length >= 32) + )); + assert!(!tokens + .iter() + .any(|token| matches!(token, PpmdEncodeToken::Match { length, .. } if *length > 255))); +} + +#[test] +fn ppmd_encoder_emits_embedded_vm_filter_escape() { + let input = b"\xe8\0\0\0\0rar29 ppmd embedded e8 filter payload\n".repeat(16); + let packed = unpack29_encode_ppmd_with_filter( + &input, + crate::FilterSpec::whole(crate::FilterKind::E8), + MAX_ENCODER_MATCH_OFFSET, + ) + .unwrap(); + let plain_ppmd = unpack29_encode_ppmd(&input, MAX_ENCODER_MATCH_OFFSET).unwrap(); + let filtered_lz = Unpack29Encoder::new() + .encode_member_with_filter(&input, crate::FilterSpec::whole(crate::FilterKind::E8)) + .unwrap(); + + assert!(packed.len() != plain_ppmd.len() || packed.len() != filtered_lz.len()); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn same_block_filters_chain_in_wire_order() { + let mut input = Vec::new(); + for index in 0..256u32 { + input.push(0xe8); + input.extend_from_slice(&index.wrapping_mul(97).to_le_bytes()); + input.extend_from_slice(b"chained-filter-payload"); + } + let filters = [ + crate::FilterSpec::whole(crate::FilterKind::Delta { channels: 1 }), + crate::FilterSpec::whole(crate::FilterKind::E8), + ]; + let packed = Unpack29Encoder::new() + .encode_member_with_filters(&input, &filters) + .unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn archive_decoder_rejects_partially_overlapping_filters() { + let input = vec![b'Z'; 96]; + for (second_start, second_size) in [(32, 64), (0, 63)] { + let filters = [ + OwnedVmFilterRecord { + block_start: 0, + block_size: 64, + init_regs: vec![(0, 1)], + code: RAR3_DELTA_FILTER_BYTECODE, + global_data: Vec::new(), + }, + OwnedVmFilterRecord { + block_start: second_start, + block_size: second_size, + init_regs: Vec::new(), + code: super::RAR3_E8_FILTER_BYTECODE, + global_data: Vec::new(), + }, + ]; + let refs = filters.iter().collect::>(); + let records = encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new()).unwrap(); + let packed = super::encode_member_inner( + &input, + &[], + &records, + EncodeOptions::default(), + false, + &mut [0; TABLE_COUNT], + None, + ) + .unwrap(); + + assert_eq!( + unpack29_decode(&packed, input.len()).unwrap_err(), + Error::InvalidData("RAR 2.9 VM filters partially overlap") + ); + } +} + +#[test] +fn writer_rejects_partially_overlapping_filters() { + let input = vec![b'Z'; 96]; + for second_range in [32..96, 0..63] { + let filters = [ + crate::FilterSpec::range(crate::FilterKind::Delta { channels: 1 }, 0..64), + crate::FilterSpec::range(crate::FilterKind::E8, second_range), + ]; + + assert_eq!( + Unpack29Encoder::new() + .encode_member_with_filters(&input, &filters) + .unwrap_err(), + Error::InvalidData("RAR 2.9 VM filters partially overlap") + ); + } +} + +#[test] +fn public_encoders_reject_invalid_filter_ranges() { + let input = vec![b'Z'; 96]; + for (start, end) in [(32, 32), (64, 32), (0, 97)] { + let range = start..end; + let filter = crate::FilterSpec::range(crate::FilterKind::E8, range); + + assert_eq!( + Unpack29Encoder::new() + .encode_member_with_filter(&input, filter.clone()) + .unwrap_err(), + Error::InvalidData("RAR 2.9 VM filter range is invalid") + ); + assert_eq!( + unpack29_encode_ppmd_with_filter(&input, filter, MAX_ENCODER_MATCH_OFFSET).unwrap_err(), + Error::InvalidData("RAR 2.9 VM filter range is invalid") + ); + } +} + +#[test] +fn public_encoder_rejects_invalid_filter_parameters() { + let input = vec![b'Z'; 96]; + let cases = [ + ( + crate::FilterKind::Delta { channels: 0 }, + Error::InvalidData("RAR 2.9 VM filter channel count is invalid"), + ), + ( + crate::FilterKind::Delta { + channels: MAX_VM_DELTA_FILTER_BLOCK_SIZE + 1, + }, + Error::InvalidData("RAR 2.9 VM filter channel count is invalid"), + ), + ( + crate::FilterKind::Audio { channels: 0 }, + Error::InvalidData("RAR 2.9 VM filter channel count is invalid"), + ), + ( + crate::FilterKind::Audio { + channels: super::MAX_AUDIO_CHANNELS + 1, + }, + Error::InvalidData("RAR 2.9 VM filter channel count is invalid"), + ), + ( + crate::FilterKind::Rgb { width: 0, pos_r: 0 }, + Error::InvalidData("RAR 2.9 RGB filter scanline width is invalid"), + ), + ( + crate::FilterKind::Rgb { + width: MAX_VM_FILTER_BLOCK_SIZE + 1, + pos_r: 0, + }, + Error::InvalidData("RAR 2.9 RGB filter scanline width is invalid"), + ), + ( + crate::FilterKind::Rgb { width: 8, pos_r: 0 }, + Error::InvalidData("RAR 2.9 RGB filter parameters are invalid"), + ), + ( + crate::FilterKind::Rgb { + width: 12, + pos_r: 3, + }, + Error::InvalidData("RAR 2.9 RGB filter parameters are invalid"), + ), + ]; + + for (kind, expected) in cases { + assert_eq!( + Unpack29Encoder::new() + .encode_member_with_filter(&input, crate::FilterSpec::whole(kind)) + .unwrap_err(), + expected, + "accepted {kind:?}" + ); + } + + assert_eq!( + Unpack29Encoder::new() + .encode_member_with_filter( + &input, + crate::FilterSpec::whole(crate::FilterKind::Delta { channels: 33 }), + ) + .unwrap_err(), + Error::InvalidData("RAR 2.9 DELTA filter channel count is invalid") + ); +} + +#[test] +fn filtered_entry_point_accepts_empty_input_without_filters() { + let packed = Unpack29Encoder::new() + .encode_member_with_filters(b"", &[]) + .unwrap(); + + assert!(unpack29_decode(&packed, 0).unwrap().is_empty()); +} + +#[test] +fn filtered_progress_polls_preprocessing_and_keeps_cancelled_state_transactional() { + let input = vec![b'Z'; MAX_VM_FILTER_BLOCK_SIZE * 2 + 16]; + let filter = crate::FilterSpec::whole(crate::FilterKind::E8); + let mut at_entry = Unpack29Encoder::new(); + assert_eq!( + at_entry.encode_member_with_filters_and_progress( + &input, + std::slice::from_ref(&filter), + Some(&mut |_| false), + ), + Err(Error::Cancelled) + ); + assert!(at_entry.history.is_empty()); + assert_eq!(at_entry.levels, [0; TABLE_COUNT]); + + let mut preprocessing = Unpack29Encoder::new(); + let mut polls = 0; + let result = preprocessing.encode_member_with_filters_and_progress( + &input, + std::slice::from_ref(&filter), + Some(&mut |_| { + polls += 1; + polls < 3 + }), + ); + assert_eq!(result.unwrap_err(), Error::Cancelled); + assert_eq!(polls, 3); + assert!(preprocessing.history.is_empty()); + assert_eq!(preprocessing.levels, [0; TABLE_COUNT]); + + let options = EncodeOptions::default().with_block_size(4096); + let mut between_blocks = Unpack29Encoder::with_options(options); + between_blocks.levels[0] = 7; + let original_levels = between_blocks.levels; + let result = between_blocks.encode_member_with_filters_and_progress( + &input[..8192], + &[filter], + Some(&mut |position| position <= 4096), + ); + assert_eq!(result.unwrap_err(), Error::Cancelled); + assert!(between_blocks.history.is_empty()); + assert_eq!(between_blocks.levels, original_levels); +} + +#[test] +fn solid_candidate_transitions_are_cancellable_without_committing_state() { + let seed = b"solid seed history and table state\n".repeat(200); + let input = b"candidate transition payload with repeated text\n".repeat(300); + let mut encoder = Unpack29Encoder::new(); + encoder.encode_member(&seed).unwrap(); + let original_history = encoder.history.clone(); + let original_levels = encoder.levels; + let filter = crate::FilterSpec::whole(crate::FilterKind::E8); + let candidates = [Vec::new(), vec![filter]]; + + let mut completions = 0; + let result = + encoder.encode_member_with_engine(&input, ChainEngine::Lz, &candidates, &mut |position| { + if position == input.len() { + completions += 1; + return completions < 3; + } + true + }); + assert_eq!(result.unwrap_err(), Error::Cancelled); + assert_eq!(completions, 3); + assert_eq!(encoder.history, original_history); + assert_eq!(encoder.levels, original_levels); + assert!(encoder.ppmd.is_none()); + + // Candidate encodes can themselves poll at the completed member byte + // count. Measure a successful two-candidate pass, then refuse its last + // poll: that last poll is the explicit boundary after the candidate + // has been evaluated and before its state can be committed. + let candidates = [Vec::new(), Vec::new()]; + let mut successful_polls = 0; + let mut probe = encoder.clone(); + probe + .encode_member_with_engine(&input, ChainEngine::Lz, &candidates, &mut |position| { + if position == input.len() { + successful_polls += 1; + } + true + }) + .unwrap(); + let mut polls = 0; + let result = + encoder.encode_member_with_engine(&input, ChainEngine::Lz, &candidates, &mut |position| { + if position == input.len() { + polls += 1; + return polls < successful_polls; + } + true + }); + assert_eq!(result, Err(Error::Cancelled)); + assert_eq!(polls, successful_polls); + assert_eq!(encoder.history, original_history); + assert_eq!(encoder.levels, original_levels); + + completions = 0; + let result = + encoder.encode_member_with_engine(&input, ChainEngine::Smaller, &[], &mut |position| { + if position == input.len() { + completions += 1; + return completions < 3; + } + true + }); + assert_eq!(result.unwrap_err(), Error::Cancelled); + assert_eq!(completions, 3); + assert_eq!(encoder.history, original_history); + assert_eq!(encoder.levels, original_levels); + assert!(encoder.ppmd.is_none()); +} + +#[test] +fn plain_solid_candidate_propagates_encoder_cancellation() { + let mut encoder = Unpack29Encoder::new(); + let input = b"plain candidate cancellation"; + let result = encoder.encode_member_with_engine(input, ChainEngine::Lz, &[], &mut |_| false); + + assert_eq!(result, Err(Error::Cancelled)); + assert!(encoder.history.is_empty()); + assert_eq!(encoder.levels, [0; TABLE_COUNT]); +} + +fn encode_with_filter(input: &[u8], kind: crate::FilterKind) -> Result> { + Unpack29Encoder::new().encode_member_with_filter(input, crate::FilterSpec::whole(kind)) +} + +fn encode_with_filter_range( + input: &[u8], + kind: crate::FilterKind, + range: Range, +) -> Result> { + Unpack29Encoder::new().encode_member_with_filter(input, crate::FilterSpec::range(kind, range)) +} + +fn encode_with_filter_ranges( + input: &[u8], + kind: crate::FilterKind, + ranges: Vec>, +) -> Result> { + let filters: Vec<_> = ranges + .into_iter() + .map(|range| crate::FilterSpec::range(kind, range)) + .collect(); + Unpack29Encoder::new().encode_member_with_filters(input, &filters) +} + +fn decode_with_raw_standard_filter( + data: &[u8], + code: &'static [u8], + init_regs: Vec<(usize, u32)>, +) -> Result> { + let filter = OwnedVmFilterRecord { + block_start: 0, + block_size: data.len(), + init_regs, + code, + global_data: Vec::new(), + }; + let mut levels = [0; TABLE_COUNT]; + let packed = super::encode_filtered_member_blocks( + data, + &[], + &[filter], + EncodeOptions::default(), + &mut levels, + None, + )?; + unpack29_decode(&packed, data.len()) +} + +#[test] +fn encoder_emits_rar29_offset_one_matches_for_repeated_bytes() { + let input = b"Z".repeat(1024); + let packed = unpack29_encode_literals(&input).unwrap(); + + assert!(packed.len() < input.len() / 4); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar29_dictionary_matches_for_repeated_sequences() { + let input = b"abc123xyz-".repeat(128); + let packed = unpack29_encode_literals(&input).unwrap(); + + assert!(packed.len() < input.len() / 2); + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_finds_rar29_matches_beyond_near_offsets() { + let phrase = b"long-distance repeated phrase for rar29 low-offset coding."; + let mut input = Vec::new(); + input.extend_from_slice(phrase); + input.extend(std::iter::repeat_n(0, 300 * 1024)); + input.extend_from_slice(phrase); + input.extend_from_slice(phrase); + let tokens = encode_tokens(&input, &[], EncodeOptions::default()); + let packed = unpack29_encode_literals(&input).unwrap(); + + assert!(tokens.iter().any(|token| matches!( + token, + EncodeToken::Match { offset, .. } if *offset > 0x40000 + ))); + assert!(packed.len() < input.len()); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + assert!( + decoded == input, + "RAR 2.9 long-distance match round-trip failed" + ); +} + +#[test] +fn encoder_emits_rar29_e8_vm_filter_record() { + let input = b"\xe8\0\0\0\0rar29 e8 filter writer payload\n".repeat(8); + let packed = encode_with_filter(&input, crate::FilterKind::E8).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert!( + decoded == input, + "RAR 2.9 multi-filter E8 round-trip failed" + ); +} + +#[test] +fn encoder_emits_rar29_e8e9_vm_filter_record() { + let input = b"\xe9\0\0\0\0rar29 e8e9 filter writer payload\n".repeat(8); + let packed = encode_with_filter(&input, crate::FilterKind::E8E9).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_segmented_e8_vm_filter_record() { + let mut input = b"prefix data that should not be x86 filtered ".to_vec(); + let start = input.len(); + input.extend_from_slice(b"\xe8\0\0\0\0segmented e8 filtered payload\n"); + let end = input.len(); + input.extend_from_slice(b" suffix data that should also remain raw"); + let packed = encode_with_filter_range(&input, crate::FilterKind::E8, start..end).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_multiple_e8_vm_filter_records() { + let mut input = vec![0x41u8; 80_000]; + for cluster_start in [8_000, 60_000] { + for index in 0..8 { + let pos = cluster_start + index * 64; + input[pos] = 0xe8; + input[pos + 1..pos + 5].copy_from_slice(&(0x2000u32 + index as u32).to_le_bytes()); + } + } + + let packed = encode_with_filter_ranges( + &input, + crate::FilterKind::E8, + vec![8_000..8_512, 60_000..60_512], + ) + .unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_segmented_e8e9_vm_filter_record() { + let mut input = b"prefix data that should not be x86 filtered ".to_vec(); + let start = input.len(); + input.extend_from_slice(b"\xe9\0\0\0\0segmented e8e9 filtered payload\n"); + let end = input.len(); + input.extend_from_slice(b" suffix data that should also remain raw"); + let packed = encode_with_filter_range(&input, crate::FilterKind::E8E9, start..end).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_delta_vm_filter_record() { + let input: Vec = (0..192).map(|index| (index * 13 + 7) as u8).collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Delta { channels: 3 }).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_segmented_delta_vm_filter_record() { + let mut input = b"prefix bytes before delta segment ".to_vec(); + let start = input.len(); + input.extend((0..192).map(|index| (index * 13 + 7) as u8)); + let end = input.len(); + input.extend_from_slice(b" suffix bytes after delta segment"); + let packed = + encode_with_filter_range(&input, crate::FilterKind::Delta { channels: 3 }, start..end) + .unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_itanium_vm_filter_record() { + let mut input = vec![0u8; 48]; + input[16] = 22; + input[21] = 20; + input.extend_from_slice(b"rar29 itanium filter writer payload\n"); + let packed = encode_with_filter(&input, crate::FilterKind::Itanium).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_segmented_itanium_vm_filter_record() { + let mut input = b"prefix bytes before itanium segment ".to_vec(); + let start = input.len(); + input.extend_from_slice(&[0; 48]); + input[start + 16] = 22; + input[start + 21] = 20; + input.extend_from_slice(b"rar29 segmented itanium filter writer payload\n"); + let end = input.len(); + input.extend_from_slice(b" suffix bytes after itanium segment"); + let packed = encode_with_filter_range(&input, crate::FilterKind::Itanium, start..end).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_rgb_vm_filter_record() { + let width = 12; + let input: Vec = (0..96).map(|index| (index * 29 + 11) as u8).collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Rgb { width, pos_r: 0 }).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_rar29_rgb_filter_with_nonzero_red_position() { + let width = 12; + let input: Vec = (0..96).map(|index| (index * 29 + 11) as u8).collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Rgb { width, pos_r: 2 }).unwrap(); + + assert_eq!(unpack29_decode(&packed, input.len()).unwrap(), input); +} + +#[test] +fn encoder_emits_rar29_segmented_rgb_vm_filter_record() { + let width = 12; + let mut input = b"prefix bytes before rgb segment ".to_vec(); + let start = input.len(); + input.extend((0..96).map(|index| (index * 29 + 11) as u8)); + let end = input.len(); + input.extend_from_slice(b" suffix bytes after rgb segment"); + let packed = encode_with_filter_range( + &input, + crate::FilterKind::Rgb { width, pos_r: 0 }, + start..end, + ) + .unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_rejects_rar29_rgb_filter_with_unaligned_scanline_width() { + let input: Vec = (0..96).map(|index| (index * 29 + 11) as u8).collect(); + assert!(encode_with_filter(&input, crate::FilterKind::Rgb { width: 8, pos_r: 0 }).is_err()); +} + +#[test] +fn encoder_rejects_rgb_ranges_shorter_than_a_pixel_or_scanline() { + for (input, width) in [(b"ab".as_slice(), 3), (b"abc".as_slice(), 6)] { + assert_eq!( + Unpack29Encoder::new().encode_member_with_filter( + input, + crate::FilterSpec::whole(crate::FilterKind::Rgb { width, pos_r: 0 }), + ), + Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid" + )), + ); + } +} + +#[test] +fn rgb_helpers_reject_invalid_parameters_even_without_caller_prechecks() { + let expected = Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid", + )); + assert_eq!(super::rgb_encode(&[0; 6], 0, 0), expected); + assert_eq!( + super::rgb_decode_with_control(&[0; 6], 3, 3, &crate::read_control::ReadControl::default(),), + expected, + ); +} + +#[test] +fn encoder_emits_rar29_audio_vm_filter_record() { + let input: Vec = (0..160) + .map(|index| (index * 7 + index / 3) as u8) + .collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Audio { channels: 2 }).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn rar29_audio_channel_bounds_match_period_decoders() { + let input: Vec = (0..256).map(|index| (index * 37 + 11) as u8).collect(); + for channels in [1, 32, 33, 128] { + let encoded = audio_encode(&input, channels).unwrap(); + let mut decoded = encoded; + let mut regs = [0; 7]; + regs[0] = channels as u32; + apply_standard_filter(StandardFilter::Audio, &mut decoded, 0, ®s).unwrap(); + assert_eq!(decoded, input, "failed with {channels} channels"); + } + + for channels in [0, 129] { + assert!(matches!( + audio_encode(&input, channels), + Err(Error::InvalidData( + "RAR 2.9 AUDIO filter channel count is invalid" + )) + )); + let mut data = input.clone(); + let mut regs = [0; 7]; + regs[0] = channels as u32; + assert!(matches!( + apply_standard_filter(StandardFilter::Audio, &mut data, 0, ®s), + Err(Error::InvalidData( + "RAR 2.9 AUDIO filter channel count is invalid" + )) + )); + } +} + +#[test] +fn audio_filter_bytecode_matches_builtin_transform() { + let channels = 2; + let input: Vec = (0..MAX_VM_AUDIO_FILTER_BLOCK_SIZE) + .map(|index| (index * 7 + index / channels + index / 257) as u8) + .collect(); + let encoded = audio_encode(&input, channels).unwrap(); + let program = Program::parse(RAR3_AUDIO_FILTER_BYTECODE).unwrap(); + let result = program + .execute(super::rarvm::Invocation { + input: &encoded, + regs: [channels as u32, 0, 0, 0, 0, 0, 0], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, input); +} + +#[test] +fn rgb_filter_matches_the_captured_winrar_bytecode() { + let program = Program::parse(RAR3_RGB_FILTER_BYTECODE).unwrap(); + for (width, pos_r) in [(3, 0), (12, 2), (63, 1)] { + let input: Vec = (0..189) + .map(|index| (index * 43 + index / 7 + 19) as u8) + .collect(); + let encoded = super::rgb_encode(&input, width, pos_r).unwrap(); + let result = program + .execute(super::rarvm::Invocation { + input: &encoded, + regs: [width as u32 + 3, pos_r as u32, 0, 0, 0, 0, 0], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, input, "width {width}, red position {pos_r}"); + } +} + +#[test] +fn itanium_filter_matches_the_captured_winrar_bytecode() { + let mut input = vec![0u8; 96]; + for bundle in 0..5 { + input[bundle * 16] = 0x16; + input[bundle * 16 + 5] = 0x50; + input[bundle * 16 + 8] = (bundle * 29 + 7) as u8; + } + let file_offset = 0x12340; + let mut encoded = input.clone(); + itanium_encode(&mut encoded, file_offset); + let program = Program::parse(RAR3_ITANIUM_FILTER_BYTECODE).unwrap(); + let result = program + .execute(super::rarvm::Invocation { + input: &encoded, + regs: [0; 7], + global_data: &[], + file_offset: u64::from(file_offset), + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, input); +} + +#[test] +fn audio_predictor_extremes_match_the_captured_winrar_bytecode() { + let program = Program::parse(RAR3_AUDIO_FILTER_BYTECODE).unwrap(); + // These xorshift streams independently drive all six coefficient + // choices and both sides of every +/-16 saturation guard. + for seed in [2u32, 3, 4, 17] { + let mut state = seed; + let input: Vec = (0..16_384) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let encoded = audio_encode(&input, 1).unwrap(); + assert_eq!( + audio_decode_with_control(&encoded, 1, &crate::read_control::ReadControl::default(),) + .unwrap(), + input, + "native predictor diverged for seed {seed}" + ); + let result = program + .execute(super::rarvm::Invocation { + input: &encoded, + regs: [1, 0, 0, 0, 0, 0, 0], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, input, "predictor diverged for seed {seed}"); + } +} + +#[test] +fn large_audio_filters_are_split_into_rarvm_safe_blocks() { + let filters = split_large_filter( + MAX_VM_FILTER_BLOCK_SIZE * 2 + 123, + crate::FilterSpec::whole(crate::FilterKind::Audio { channels: 4 }), + ) + .unwrap(); + + assert_eq!(filters.len(), 3); + assert_eq!(filters[0].range, Some(0..MAX_VM_AUDIO_FILTER_BLOCK_SIZE)); + assert_eq!( + filters[1].range, + Some(MAX_VM_AUDIO_FILTER_BLOCK_SIZE..MAX_VM_AUDIO_FILTER_BLOCK_SIZE * 2) + ); + assert_eq!( + filters[2].range, + Some(MAX_VM_AUDIO_FILTER_BLOCK_SIZE * 2..MAX_VM_FILTER_BLOCK_SIZE * 2 + 123) + ); +} + +#[test] +fn large_delta_filters_are_split_into_rarvm_safe_blocks() { + let filters = split_large_filter( + MAX_VM_FILTER_BLOCK_SIZE * 2 + 123, + crate::FilterSpec::whole(crate::FilterKind::Delta { channels: 4 }), + ) + .unwrap(); + + assert_eq!(filters.len(), 3); + assert_eq!(filters[0].range, Some(0..MAX_VM_DELTA_FILTER_BLOCK_SIZE)); + assert_eq!( + filters[1].range, + Some(MAX_VM_DELTA_FILTER_BLOCK_SIZE..MAX_VM_DELTA_FILTER_BLOCK_SIZE * 2) + ); + assert_eq!( + filters[2].range, + Some(MAX_VM_DELTA_FILTER_BLOCK_SIZE * 2..MAX_VM_FILTER_BLOCK_SIZE * 2 + 123) + ); +} + +#[test] +fn segmented_audio_filters_redeclare_program_state() { + let filters = [ + OwnedVmFilterRecord { + block_start: 0, + block_size: MAX_VM_AUDIO_FILTER_BLOCK_SIZE, + init_regs: vec![(0, 4)], + code: RAR3_AUDIO_FILTER_BYTECODE, + global_data: Vec::new(), + }, + OwnedVmFilterRecord { + block_start: MAX_VM_AUDIO_FILTER_BLOCK_SIZE, + block_size: 4096, + init_regs: vec![(0, 4)], + code: RAR3_AUDIO_FILTER_BYTECODE, + global_data: Vec::new(), + }, + ]; + let refs: Vec<&OwnedVmFilterRecord> = filters.iter().collect(); + let records = encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new()).unwrap(); + + assert_vm_filter_declares_program(&records[0], 0); + assert_vm_filter_declares_program(&records[1], 2); +} + +#[test] +fn encoder_emits_rar29_segmented_audio_vm_filter_record() { + let mut input = b"prefix bytes before audio segment ".to_vec(); + let start = input.len(); + input.extend((0..160).map(|index| (index * 7 + index / 3) as u8)); + let end = input.len(); + input.extend_from_slice(b" suffix bytes after audio segment"); + let packed = + encode_with_filter_range(&input, crate::FilterKind::Audio { channels: 2 }, start..end) + .unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_multiple_rar29_audio_vm_filter_records_for_large_ranges() { + let input: Vec = (0..(MAX_VM_AUDIO_FILTER_BLOCK_SIZE * 2 + 64)) + .map(|index| (index * 7 + index / 3 + index / 257) as u8) + .collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Audio { channels: 4 }).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +#[test] +fn encoder_emits_multiple_rar29_delta_vm_filter_records_for_large_ranges() { + let input: Vec = (0..(MAX_VM_DELTA_FILTER_BLOCK_SIZE * 2 + 64)) + .map(|index| (index * 11 + index / 5 + index / 251) as u8) + .collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Delta { channels: 4 }).unwrap(); + let decoded = unpack29_decode(&packed, input.len()).unwrap(); + + assert_eq!(decoded, input); +} + +fn assert_vm_filter_declares_program(record: &[u8], expected_selector: u32) { + let first = record[0]; + assert_ne!(first & 0x80, 0); + assert_ne!(first & 0x20, 0); + assert_ne!(first & 0x10, 0); + let inline_len = match first & 7 { + len @ 0..=5 => len as usize + 1, + 6 => usize::from(record[1]) + 7, + _ => u16::from_be_bytes([record[1], record[2]]) as usize, + }; + let body_start = match first & 7 { + 0..=5 => 1, + 6 => 2, + _ => 3, + }; + let body = &record[body_start..body_start + inline_len]; + let mut bits = BitReader::from_bytes(body); + assert_eq!(bits.read_encoded_u32().unwrap(), expected_selector); + let _block_start = bits.read_encoded_u32().unwrap(); + let _block_size = bits.read_encoded_u32().unwrap(); + let mask = bits.read_bits(7).unwrap(); + for index in 0..7 { + if mask & (1 << index) != 0 { + let _ = bits.read_encoded_u32().unwrap(); + } + } + assert_eq!( + bits.read_encoded_u32().unwrap() as usize, + RAR3_AUDIO_FILTER_BYTECODE.len() + ); +} + +#[test] +fn solid_encoder_emits_rar29_matches_against_previous_member_history() { + let first = b"solid rar29 shared phrase alpha beta gamma ".repeat(4); + let second = b"solid rar29 shared phrase alpha beta gamma ".repeat(2); + let independent = unpack29_encode_literals(&second).unwrap(); + let mut encoder = Unpack29Encoder::new(); + let first_packed = encoder.encode_member(&first).unwrap(); + let second_packed = encoder.encode_member(&second).unwrap(); + + assert!(second_packed.len() < independent.len()); + let mut decoder = Unpack29::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert_eq!( + decoder.decode_member(&second_packed, second.len()).unwrap(), + second + ); +} + +#[test] +fn decode_member_from_reader_accepts_incremental_input() { + struct TinyReader<'a> { + input: &'a [u8], + } + + impl std::io::Read for TinyReader<'_> { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if self.input.is_empty() { + return Ok(0); + } + let len = self.input.len().min(out.len()).min(3); + out[..len].copy_from_slice(&self.input[..len]); + self.input = &self.input[len..]; + Ok(len) + } + } + + let mut decoder = Unpack29::new(); + let mut reader = TinyReader { + input: COMPRESSED_TEXT, + }; + let mut output = Vec::new(); + decoder + .decode_member_from_reader(&mut reader, 2400, &mut output) + .unwrap(); + + assert_eq!(output, expected_text()); +} + +#[test] +fn member_output_entry_points_share_one_decode_contract() { + let expected = expected_text(); + + let mut decoder = Unpack29::new(); + let returned = decoder + .decode_member(COMPRESSED_TEXT, expected.len()) + .unwrap(); + + let mut decoder = Unpack29::new(); + let mut written = Vec::new(); + decoder + .decode_member_to(COMPRESSED_TEXT, expected.len(), &mut written) + .unwrap(); + + let mut decoder = Unpack29::new(); + let mut reader = COMPRESSED_TEXT; + let mut read_then_written = Vec::new(); + decoder + .decode_member_from_reader(&mut reader, expected.len(), &mut read_then_written) + .unwrap(); + + assert_eq!(returned, expected); + assert_eq!(written, expected); + assert_eq!(read_then_written, expected); +} + +#[test] +fn member_output_entry_points_report_the_same_truncation() { + let truncated = &COMPRESSED_TEXT[..COMPRESSED_TEXT.len() / 2]; + let expected = Error::InvalidData("RAR 2.9 bitstream is truncated"); + + let returned = Unpack29::new().decode_member(truncated, 2400).unwrap_err(); + + let mut decoder = Unpack29::new(); + let mut written = Vec::new(); + let write_error = decoder + .decode_member_to(truncated, 2400, &mut written) + .unwrap_err(); + + let mut decoder = Unpack29::new(); + let mut reader = truncated; + let mut read_then_written = Vec::new(); + let reader_error = decoder + .decode_member_from_reader(&mut reader, 2400, &mut read_then_written) + .unwrap_err(); + + assert_eq!(returned, expected); + assert_eq!(write_error, expected); + assert_eq!(reader_error, expected); +} + +#[test] +fn member_output_entry_points_share_empty_member_handling() { + let packed = unpack29_encode_literals(b"").unwrap(); + + assert!(Unpack29::new() + .decode_member(&packed, 0) + .unwrap() + .is_empty()); + + let mut decoder = Unpack29::new(); + let mut written = Vec::new(); + decoder.decode_member_to(&packed, 0, &mut written).unwrap(); + assert!(written.is_empty()); + + let mut decoder = Unpack29::new(); + let mut reader = packed.as_slice(); + decoder + .decode_member_from_reader(&mut reader, 0, &mut written) + .unwrap(); + assert!(written.is_empty()); +} + +#[test] +fn direct_codec_accepts_an_empty_stream_for_an_empty_member() { + assert!(Unpack29::new().decode_member(&[], 0).unwrap().is_empty()); +} + +#[test] +fn empty_members_still_validate_a_supplied_table_header() { + assert_eq!( + Unpack29::new().decode_member(&[0], 0), + Err(Error::InvalidData("RAR 2.9 bitstream is truncated")) + ); + + let invalid = table_description(&[0; 20], &[]); + assert_eq!( + Unpack29::new().decode_member(&invalid, 0), + Err(Error::InvalidData("RAR 2.9 empty Huffman table")) + ); +} + +#[test] +fn empty_solid_member_can_use_the_previous_members_huffman_tables() { + let first = b"solid member with a retained Huffman table"; + let mut encoder = Unpack29Encoder::new(); + let mut first_packed = encoder.encode_member(first).unwrap(); + + // Locate the last bit of the first member's end marker, then change + // NewFileNewTables (0, 1) to NewFileKeepTables (0, 0). The latter is + // valid legacy wire syntax even though our writer does not emit it. + let mut probe = Unpack29::new(); + assert_eq!( + probe.decode_member(&first_packed, first.len()).unwrap(), + first + ); + let keep_tables_bit = probe.bits.bit_pos - 1; + let mask = 1 << (7 - keep_tables_bit % 8); + assert_ne!(first_packed[keep_tables_bit / 8] & mask, 0); + first_packed[keep_tables_bit / 8] &= !mask; + + let codes = canonical_codes(&encoder.levels[..MAIN_COUNT]); + let end = codes[256].unwrap(); + let mut bits = BitWriter::default(); + bits.write_bits(u32::from(end.code), end.len); + bits.write_bit(false); // new file + bits.write_bit(true); // next member reads new tables + let empty_packed = bits.finish(); + + let mut decoder = Unpack29::new(); + assert_eq!( + decoder.decode_member(&first_packed, first.len()).unwrap(), + first + ); + assert!(decoder.in_lz_block); + assert!(decoder.decode_member(&empty_packed, 0).unwrap().is_empty()); + assert!(!decoder.in_lz_block); +} + +#[test] +fn oversized_untrusted_filter_waits_across_a_streaming_batch() { + let expected = vec![0; STREAM_CHUNK + 1]; + let packed = Unpack29Encoder::with_options(EncodeOptions::new(0)) + .encode_member(&expected) + .unwrap(); + let mut decoder = Unpack29::new(); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: expected.len(), + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 0, + size: expected.len(), + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + assert_eq!( + decoder.decode_member(&packed, expected.len()).unwrap(), + expected + ); + assert!(decoder.filters.is_empty()); +} + +#[test] +fn slice_and_reader_entry_points_share_output_failures() { + struct FailingWriter; + impl std::io::Write for FailingWriter { + fn write(&mut self, _buf: &[u8]) -> std::io::Result { + Err(std::io::Error::other("deliberate failure")) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let expected = Error::from(std::io::Error::other("deliberate failure")); + let mut decoder = Unpack29::new(); + assert_eq!( + decoder + .decode_member_to(COMPRESSED_TEXT, 2400, &mut FailingWriter) + .unwrap_err(), + expected + ); + + let mut decoder = Unpack29::new(); + let mut reader = COMPRESSED_TEXT; + assert_eq!( + decoder + .decode_member_from_reader(&mut reader, 2400, &mut FailingWriter) + .unwrap_err(), + expected + ); + + let mut decoder = Unpack29::new(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 0, + size: 1, + regs: [0; 7], + global_data: vec![1].into(), + }) + .unwrap(); + assert_eq!( + decoder + .decode_non_solid_member_to(COMPRESSED_TEXT, 2400, &mut FailingWriter) + .unwrap_err(), + expected + ); + assert!(decoder.filters.is_empty()); +} + +#[test] +fn decode_non_solid_member_resets_reusable_decoder_state() { + let mut decoder = Unpack29::new(); + decoder.output.extend_from_slice(b"stale history").unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 0, + size: 1, + regs: [0; 7], + global_data: vec![1, 2, 3].into(), + }) + .unwrap(); + + let mut output = Vec::new(); + decoder + .decode_non_solid_member_to(COMPRESSED_TEXT, 2400, &mut output) + .unwrap(); + + assert_eq!(output, expected_text()); + assert!(decoder.filters.is_empty()); +} + +#[test] +fn e8_filter_uses_member_relative_offset_in_solid_stream() { + let mut decoder = Unpack29::new(); + let member_start = 1000usize; + let filter_start = member_start + 100; + decoder.output.resize(filter_start + 8, 0).unwrap(); + decoder.output[filter_start] = 0xe8; + + let call_operand_pos = 1u32; + let member_relative_filter_start = (filter_start - member_start) as u32; + let decoded_addr = 0x2000u32; + let encoded_addr = decoded_addr + .wrapping_add(member_relative_filter_start) + .wrapping_add(call_operand_pos); + decoder.output[filter_start + 1..filter_start + 5].copy_from_slice(&encoded_addr.to_le_bytes()); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: 5, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: filter_start, + size: 5, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + let filtered = decoder + .filtered_range(member_start, filter_start + 5, member_start) + .unwrap(); + let operand = u32::from_le_bytes([filtered[101], filtered[102], filtered[103], filtered[104]]); + + assert_eq!(operand, decoded_addr); +} + +#[test] +fn generic_vm_filter_executes_from_filtered_range() { + let mut decoder = Unpack29::new(); + decoder + .output + .extend_from_slice(&[0x11, 0x22, 0x33]) + .unwrap(); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Generic( + Program { + static_data: Vec::new(), + instructions: vec![ + Instruction { + opcode: Opcode::Mov, + byte_mode: true, + operands: vec![Operand::Absolute(0), Operand::Immediate(0x44)], + }, + Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }, + ], + } + .into(), + ), + block_size: 3, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + decoder + .filters + .push(VmFilter { + program: 0, + start: 0, + size: 3, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + + let filtered = decoder.filtered_range(0, 3, 0).unwrap(); + + assert_eq!(filtered, [0x44, 0x22, 0x33]); +} + +#[test] +fn generic_vm_filter_uses_explicit_then_retained_user_globals() { + // Copies user-global byte 0 to the output, increments it, records one + // retained user byte at global offset 0x30, then returns. + const GLOBAL_COUNTER_PROGRAM: &[u8] = &[ + 0x0d, 0x05, 0xc0, 0x7c, 0x00, 0x0f, 0x01, 0x01, 0xaf, 0x80, 0x01, 0xe0, 0x20, 0x01, 0xf0, + 0x00, 0x3c, 0x03, 0x00, 0x1b, 0x80, + ]; + let filters = [ + OwnedVmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: Vec::new(), + code: GLOBAL_COUNTER_PROGRAM, + global_data: vec![b'A'], + }, + OwnedVmFilterRecord { + block_start: 1, + block_size: 1, + init_regs: Vec::new(), + code: GLOBAL_COUNTER_PROGRAM, + global_data: Vec::new(), + }, + ]; + let refs = filters.iter().collect::>(); + let records = encoded_filter_records_at(&refs, 0, usize::MAX, &mut Vec::new()).unwrap(); + let packed = super::encode_member_inner( + &[0, 0], + &[], + &records, + EncodeOptions::default(), + false, + &mut [0; TABLE_COUNT], + None, + ) + .unwrap(); + + assert_eq!(unpack29_decode(&packed, 2).unwrap(), b"AB"); +} + +#[test] +fn standard_filters_reject_malformed_delta_and_rgb_registers() { + let mut delta = vec![0; 32]; + let mut delta_regs = [0; 7]; + // 33 channels is legal here: the count comes from R[0], not from a + // five-bit field, and the reference decoder allows up to 1024. + delta_regs[0] = 33; + assert_eq!( + apply_standard_filter(StandardFilter::Delta, &mut delta, 0, &delta_regs), + Ok(()) + ); + delta_regs[0] = super::MAX_DELTA_CHANNELS as u32 + 1; + assert_eq!( + apply_standard_filter(StandardFilter::Delta, &mut delta, 0, &delta_regs), + Err(Error::InvalidData( + "RAR 2.9 DELTA filter channel count is invalid" + )) + ); + delta_regs[0] = 0; + assert_eq!( + apply_standard_filter(StandardFilter::Delta, &mut delta, 0, &delta_regs), + Err(Error::InvalidData( + "RAR 2.9 DELTA filter channel count is invalid" + )) + ); + + let mut rgb = vec![0; 32]; + let mut rgb_regs = [0; 7]; + rgb_regs[0] = 2; + assert_eq!( + apply_standard_filter(StandardFilter::Rgb, &mut rgb, 0, &rgb_regs), + Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid" + )) + ); + rgb_regs[0] = 15; + rgb_regs[1] = 3; + assert_eq!( + apply_standard_filter(StandardFilter::Rgb, &mut rgb, 0, &rgb_regs), + Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid" + )) + ); +} + +#[test] +fn standard_filter_records_enforce_delta_and_audio_channel_bounds() { + let input = vec![0; 1024]; + assert_eq!( + decode_with_raw_standard_filter(&input, RAR3_DELTA_FILTER_BYTECODE, vec![(0, 0)]), + Err(Error::InvalidData( + "RAR 2.9 DELTA filter channel count is invalid" + )) + ); + assert_eq!( + decode_with_raw_standard_filter( + &input, + RAR3_DELTA_FILTER_BYTECODE, + vec![(0, (super::MAX_DELTA_CHANNELS + 1) as u32)], + ), + Err(Error::InvalidData( + "RAR 2.9 DELTA filter channel count is invalid" + )) + ); + assert_eq!( + decode_with_raw_standard_filter( + &input, + RAR3_DELTA_FILTER_BYTECODE, + vec![(0, super::MAX_DELTA_CHANNELS as u32)], + ) + .unwrap(), + input + ); + + for channels in [0, super::MAX_AUDIO_CHANNELS + 1] { + assert_eq!( + decode_with_raw_standard_filter( + &input, + RAR3_AUDIO_FILTER_BYTECODE, + vec![(0, channels as u32)], + ), + Err(Error::InvalidData( + "RAR 2.9 AUDIO filter channel count is invalid" + )) + ); + } +} + +#[test] +fn standard_rgb_filter_records_reject_nonportable_parameters() { + let cases = [ + (vec![0; 2], 3, 0, "short input"), + (vec![0; 12], 3, 0, "zero width"), + (vec![0; 12], 11, 0, "unaligned width"), + (vec![0; 12], 18, 0, "width beyond the block"), + (vec![0; 12], 15, 3, "red channel beyond RGB"), + ]; + for (input, encoded_width, pos_r, description) in cases { + assert_eq!( + decode_with_raw_standard_filter( + &input, + RAR3_RGB_FILTER_BYTECODE, + vec![(0, encoded_width), (1, pos_r)], + ), + Err(Error::InvalidData( + "RAR 2.9 RGB filter parameters are invalid" + )), + "accepted {description}" + ); + } +} + +#[test] +fn short_itanium_filter_records_are_defined_noops() { + let mut empty = Vec::new(); + itanium_decode(&mut empty, 0); + assert!(empty.is_empty()); + + for len in [1, 20, 21, 22] { + let input: Vec = (0..len).map(|index| (index * 17 + 3) as u8).collect(); + assert_eq!( + decode_with_raw_standard_filter(&input, RAR3_ITANIUM_FILTER_BYTECODE, vec![]).unwrap(), + input, + "changed a {len}-byte non-branching block" + ); + } +} + +#[test] +fn short_itanium_filter_encoding_is_a_defined_noop() { + for len in 4..=21 { + let input: Vec = (0..len).map(|index| (index * 17 + 3) as u8).collect(); + let packed = encode_with_filter(&input, crate::FilterKind::Itanium).unwrap(); + assert_eq!( + unpack29_decode(&packed, input.len()).unwrap(), + input, + "changed a {len}-byte block" + ); + } +} + +#[test] +fn vm_encoded_u32_accepts_32_bit_form() { + let mut bits = super::BitReader::from_bytes(&[0xff; 5]); + + assert_eq!(bits.read_encoded_u32().unwrap(), 0xffff_ffff); +} + +#[test] +fn vm_encoded_u32_accepts_the_signed_constant_form() { + let mut encoded = BitWriter::default(); + encoded.write_bits(1, 2); + encoded.write_bits(0x0a, 8); + encoded.write_bits(0x05, 4); + let mut bits = BitReader::from_bytes(&encoded.finish()); + + assert_eq!(bits.read_encoded_u32().unwrap(), 0xffff_ffa5); +} + +#[test] +fn vm_filter_record_serializer_uses_every_specified_length_form() { + fn declared_payload(record: &[u8]) -> (usize, usize) { + match record[0] & 7 { + len @ 0..=5 => (1, usize::from(len) + 1), + 6 => (2, usize::from(record[1]) + 7), + _ => (3, usize::from(u16::from_be_bytes([record[1], record[2]]))), + } + } + + let medium_code = vec![0; 53]; + let long_code = vec![0; 300]; + let records = [ + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[], + global_data: &[], + }, + 1, + false, + ) + .unwrap(), + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &medium_code, + global_data: &[], + }, + 0, + true, + ) + .unwrap(), + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &long_code, + global_data: &[], + }, + 0, + true, + ) + .unwrap(), + ]; + + assert!(matches!(records[0][0] & 7, 0..=5)); + assert_eq!(records[1][0] & 7, 6); + assert_eq!(records[2][0] & 7, 7); + for record in records { + let (header_len, payload_len) = declared_payload(&record); + assert_eq!(record.len(), header_len + payload_len); + } +} + +#[test] +fn decoder_reads_a_vm_filter_with_a_16_bit_payload_length() { + let globals = vec![0x5a; 300]; + let record = super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 3, + block_size: 16, + init_regs: &[], + code: super::RAR3_E8_FILTER_BYTECODE, + global_data: &globals, + }, + 0, + true, + ) + .unwrap(); + assert_eq!(record[0] & 7, 7); + + let mut decoder = Unpack29::new(); + decoder.bits = BitReader::from_bytes(&record); + decoder.read_vm_code().unwrap(); + + assert_eq!(decoder.programs.len(), 1); + assert_eq!(decoder.filters.len(), 1); + assert_eq!(decoder.filters[0].start, 3); + assert_eq!(decoder.filters[0].size, 16); + assert_eq!( + &decoder.filters[0].global_data[super::VM_SYSTEM_GLOBAL_SIZE..], + globals + ); +} + +#[test] +fn vm_filter_record_serializer_rejects_invalid_fields() { + assert_eq!( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 0, + init_regs: &[], + code: &[1], + global_data: &[], + }, + 0, + true, + ), + Err(Error::InvalidData("RAR 2.9 VM filter block is empty")) + ); + assert_eq!( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[], + global_data: &[], + }, + 0, + true, + ), + Err(Error::InvalidData("RAR 2.9 VM filter bytecode is empty")) + ); + assert_eq!( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[(7, 0)], + code: &[1], + global_data: &[], + }, + 0, + true, + ), + Err(Error::InvalidData( + "RAR 2.9 VM init register index is invalid" + )) + ); + + let oversized_global = vec![0; 65_536]; + assert_eq!( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[], + global_data: &oversized_global, + }, + 1, + false, + ), + Err(Error::InvalidData("RAR 2.9 VM filter record is too large")) + ); +} + +#[cfg(target_pointer_width = "64")] +#[test] +fn vm_filter_record_serializer_rejects_fields_wider_than_the_wire() { + for (block_start, block_size, expected) in [ + ( + usize::MAX, + 1, + Error::InvalidData("RAR 2.9 VM block start overflows"), + ), + ( + 0, + usize::MAX, + Error::InvalidData("RAR 2.9 VM block size overflows"), + ), + ] { + assert_eq!( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start, + block_size, + init_regs: &[], + code: &[], + global_data: &[], + }, + 1, + false, + ), + Err(expected) + ); + } +} + +#[test] +fn vm_filter_records_must_belong_to_their_encoding_block() { + let filter = OwnedVmFilterRecord { + block_start: 10, + block_size: 1, + init_regs: Vec::new(), + code: super::RAR3_E8_FILTER_BYTECODE, + global_data: Vec::new(), + }; + + assert_eq!( + encoded_filter_records_at(&[&filter], 11, 32, &mut Vec::new()), + Err(Error::InvalidData( + "RAR 2.9 VM filter starts before its block" + )) + ); + assert_eq!( + encoded_filter_records_at(&[&filter], 0, 10, &mut Vec::new()), + Err(Error::InvalidData( + "RAR 2.9 VM filter starts further past its block than the window can express" + )) + ); +} + +#[cfg(target_pointer_width = "64")] +#[test] +fn member_relative_vm_filter_offsets_obey_the_u32_wire_boundary() { + // PPMd callers declare filters relative to the whole member (base 0), + // unlike LZ callers, which rebase them into dictionary-sized blocks. + let mut filter = OwnedVmFilterRecord { + block_start: u32::MAX as usize, + block_size: 4, + init_regs: Vec::new(), + code: super::RAR3_E8_FILTER_BYTECODE, + global_data: Vec::new(), + }; + let records = encoded_filter_records_at(&[&filter], 0, usize::MAX, &mut Vec::new()).unwrap(); + assert_eq!(records.len(), 1); + let record = &records[0]; + let header_len = match record[0] & 7 { + 0..=5 => 1, + 6 => 2, + _ => 3, + }; + let mut body = BitReader::from_bytes(&record[header_len..]); + assert_eq!(body.read_encoded_u32().unwrap(), 0); + assert_eq!(body.read_encoded_u32().unwrap(), u32::MAX); + assert_eq!(body.read_encoded_u32().unwrap(), 4); + + filter.block_start += 1; + assert_eq!( + encoded_filter_records_at(&[&filter], 0, usize::MAX, &mut Vec::new()), + Err(Error::InvalidData("RAR 2.9 VM block start overflows")) + ); + // The same absolute position is representable after an LZ block rebase. + assert!(encoded_filter_records_at(&[&filter], filter.block_start, 4, &mut Vec::new(),).is_ok()); +} + +#[test] +fn archive_decoder_rejects_invalid_vm_program_records() { + let cases = [ + ( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[], + global_data: &[], + }, + 2, + false, + ) + .unwrap(), + Error::InvalidData("RAR 2.9 VM program index is invalid"), + ), + ( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[], + global_data: &[], + }, + 0, + false, + ) + .unwrap(), + Error::InvalidData("RAR 2.9 VM code is empty"), + ), + ( + super::encode_vm_filter_record_inner( + super::VmFilterRecord { + block_start: 0, + block_size: 1, + init_regs: &[], + code: &[1, 0], + global_data: &[], + }, + 0, + true, + ) + .unwrap(), + Error::InvalidData("RARVM program checksum mismatch"), + ), + ]; + + for (record, expected) in cases { + let packed = super::encode_member_inner( + &[0], + &[], + &[record], + EncodeOptions::default(), + false, + &mut [0; TABLE_COUNT], + None, + ) + .unwrap(); + assert_eq!(unpack29_decode(&packed, 1), Err(expected)); + } +} + +#[test] +fn archive_decoder_rejects_generic_vm_block_larger_than_work_memory() { + // A checksum-valid nonstandard program with an implicit RET. + const GENERIC_RET: &[u8] = &[0x5c, 0x5c]; + const TOO_LARGE: usize = 0x3c001; + let filter = OwnedVmFilterRecord { + block_start: 0, + block_size: TOO_LARGE, + init_regs: Vec::new(), + code: GENERIC_RET, + global_data: Vec::new(), + }; + let records = encoded_filter_records_at(&[&filter], 0, usize::MAX, &mut Vec::new()).unwrap(); + let packed = super::encode_member_inner( + &vec![0; TOO_LARGE], + &[], + &records, + EncodeOptions::default(), + false, + &mut [0; TABLE_COUNT], + None, + ) + .unwrap(); + + assert_eq!( + unpack29_decode(&packed, TOO_LARGE), + Err(Error::InvalidData("RARVM filter input is too large")) + ); +} + +#[test] +fn vm_global_data_size_is_capped_before_reading_or_allocation() { + let mut decoder = Unpack29::new(); + decoder + .programs + .push(VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: 1, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + + let mut data = BitWriter::default(); + data.write_encoded_u32(1); + data.write_encoded_u32(0); + data.write_encoded_u32(u32::MAX); + + assert_eq!( + decoder.parse_vm_code(0x80 | 0x08, data.finish()), + Err(Error::InvalidData("RAR 2.9 VM global data is too large")) + ); +} + +#[test] +fn vm_code_size_is_capped_before_allocation() { + let mut decoder = Unpack29::new(); + let mut data = BitWriter::default(); + data.write_encoded_u32(0); + data.write_encoded_u32(1); + data.write_encoded_u32(super::MAX_VM_CODE_SIZE as u32); + + assert_eq!( + decoder.parse_vm_code(0x80, data.finish()), + Err(Error::InvalidData("RAR 2.9 VM code is too large")) + ); +} + +#[test] +fn vm_program_and_filter_counts_are_capped() { + let mut decoder = Unpack29::new(); + decoder + .programs + .resize_with(super::MAX_VM_PROGRAMS, || VmProgram { + kind: VmProgramKind::Standard(StandardFilter::E8), + block_size: 1, + exec_count: 0, + globals: Vec::new().into(), + }) + .unwrap(); + + let mut new_program = BitWriter::default(); + new_program.write_encoded_u32((super::MAX_VM_PROGRAMS + 1) as u32); + new_program.write_encoded_u32(1); + new_program.write_encoded_u32(1); + new_program.write_bits(0, 8); + assert_eq!( + decoder.parse_vm_code(0x80, new_program.finish()), + Err(Error::InvalidData("RAR 2.9 VM program limit exceeded")) + ); + + decoder.programs.truncate(1); + decoder.last_filter = 0; + decoder + .filters + .resize_with(super::MAX_VM_FILTERS, || VmFilter { + program: 0, + start: 0, + size: 1, + regs: [0; 7], + global_data: Vec::new().into(), + }) + .unwrap(); + let mut reused_program = BitWriter::default(); + reused_program.write_encoded_u32(0); + assert_eq!( + decoder.parse_vm_code(0, reused_program.finish()), + Err(Error::InvalidData("RAR 2.9 VM filter limit exceeded")) + ); +} + +#[test] +fn itanium_filter_round_trips_with_high_file_offset() { + let mut data = vec![0u8; 64]; + for (index, byte) in data.iter_mut().enumerate() { + *byte = index as u8; + } + data[0] = 0; + data[7] = 5 << 3; + let original = data.clone(); + + itanium_encode(&mut data, u32::MAX); + itanium_decode(&mut data, u32::MAX); + + assert_eq!(data, original); +} + +fn expected_text() -> Vec { + "Hello, RAR 3.x fixture world.\n".repeat(80).into_bytes() +} diff --git a/arca-rar/vendor/rars/src/codec/rar50.rs b/arca-rar/vendor/rars/src/codec/rar50.rs new file mode 100644 index 00000000..a74d1457 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50.rs @@ -0,0 +1,1927 @@ +#[cfg(feature = "write")] +mod encoder; +#[cfg(feature = "write")] +pub use encoder::{ + encode_compressed_block, encode_literal_only, encode_lz_member, encode_lz_member_with_history, + encode_lz_member_with_history_and_options, encode_lz_member_with_options, encode_table_lengths, + encode_table_lengths_with_bit_count, EncodeOptions, Unpack50Encoder, +}; +#[cfg(all(test, feature = "write"))] +pub(crate) use encoder::{ + encode_lz_member_with_options_and_progress, encode_lz_reader_to, filtered_lz_member, +}; +#[cfg(feature = "write")] +pub(crate) use encoder::{ + encode_owned_member, filtered_owned_member, streaming_blocks_with_allowance, BlockSplitter, + LZ_BLOCK_SIZE, MAX_DELTA_CHANNELS, MAX_LZ_BLOCK_SIZE, +}; + +use super::filters::{self, DeltaErrorMessages}; +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; +use std::io::Read; +use std::ops::Range; + +pub const LEVEL_TABLE_SIZE: usize = 20; +pub const MAIN_TABLE_SIZE: usize = 306; +pub const DISTANCE_TABLE_SIZE_50: usize = 64; +pub const DISTANCE_TABLE_SIZE_70: usize = 80; +pub const ALIGN_TABLE_SIZE: usize = 16; +pub const LENGTH_TABLE_SIZE: usize = 44; +const DEFAULT_DICTIONARY_SIZE: usize = 4 * 1024 * 1024; +const MAX_INITIAL_OUTPUT_CAPACITY: usize = 1024 * 1024; +const STREAM_FLUSH_THRESHOLD: usize = 64 * 1024; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CompressedBlock { + pub header: CompressedBlockHeader, + pub header_len: usize, + pub payload: Range, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct CompressedBlockHeader { + pub flags: u8, + pub is_last: bool, + pub has_tables: bool, + pub final_byte_bits: u8, + pub payload_size: usize, + pub payload_bits: usize, +} + +struct OwnedCompressedBlock { + header: CompressedBlockHeader, + payload: Buffer, +} + +#[derive(Debug)] +#[doc(hidden)] +pub enum StreamDecodeError { + Decode(Error), + FilteredMember, + Sink(E), +} + +impl From for StreamDecodeError { + fn from(error: Error) -> Self { + Self::Decode(error) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[doc(hidden)] +pub enum DecodedChunk<'a> { + Bytes(&'a [u8]), + Repeated { byte: u8, len: usize }, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TableLengths { + pub main: Vec, + pub distance: Vec, + pub align: Vec, + pub length: Vec, +} + +struct OwnedLengths { + main: Buffer, + distance: Buffer, + align: Buffer, + length: Buffer, +} + +#[derive(Debug, Clone)] +pub struct DecodeTables { + pub main: HuffmanTable, + pub distance: HuffmanTable, + pub align: HuffmanTable, + pub length: HuffmanTable, + pub align_mode: bool, +} + +impl DecodeTables { + pub fn from_lengths(lengths: &TableLengths) -> Result { + let align_mode = lengths + .align + .iter() + .any(|&length| length != 0 && length != 4); + Ok(Self { + main: HuffmanTable::from_lengths(&lengths.main)?, + distance: HuffmanTable::from_lengths(&lengths.distance)?, + align: HuffmanTable::from_lengths(&lengths.align)?, + length: HuffmanTable::from_lengths(&lengths.length)?, + align_mode, + }) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DecodeMode { + LiteralOnly, + Lz, + LzNoFilters, +} + +impl DecodeMode { + fn uses_lz(self) -> bool { + matches!(self, Self::Lz | Self::LzNoFilters) + } + + fn applies_filters(self) -> bool { + matches!(self, Self::Lz) + } +} + +pub fn parse_compressed_block(input: &[u8]) -> Result { + if input.len() < 3 { + return Err(Error::NeedMoreInput); + } + + let flags = input[0]; + let checksum = input[1]; + let size_bytes = match (flags >> 3) & 0x03 { + 0 => 1, + 1 => 2, + 2 => 3, + _ => return Err(Error::InvalidData("RAR 5 block size length is invalid")), + }; + let header_len = 2 + size_bytes; + if input.len() < header_len { + return Err(Error::NeedMoreInput); + } + + let size_data = &input[2..header_len]; + let actual = size_data + .iter() + .fold(checksum ^ flags, |acc, &byte| acc ^ byte); + if actual != 0x5a { + return Err(Error::InvalidData("RAR 5 block header checksum mismatch")); + } + + let payload_size = size_data + .iter() + .enumerate() + .fold(0usize, |acc, (index, &byte)| { + acc | (usize::from(byte) << (index * 8)) + }); + // The size field is at most three bytes and the header at most five, so + // this sum fits even on a 32-bit target. + let payload_end = header_len + payload_size; + if input.len() < payload_end { + return Err(Error::NeedMoreInput); + } + + let final_byte_bits = ((flags & 0x07) + 1).min(8); + let payload_bits = if payload_size == 0 { + 0 + } else { + (payload_size - 1) * 8 + usize::from(final_byte_bits) + }; + + Ok(CompressedBlock { + header: CompressedBlockHeader { + flags, + is_last: flags & 0x40 != 0, + has_tables: flags & 0x80 != 0, + final_byte_bits, + payload_size, + payload_bits, + }, + header_len, + payload: header_len..payload_end, + }) +} + +pub fn read_level_lengths(input: &[u8]) -> Result<([u8; LEVEL_TABLE_SIZE], usize)> { + let mut bits = BitReader::new(input); + let mut lengths = [0; LEVEL_TABLE_SIZE]; + let mut pos = 0; + while pos < LEVEL_TABLE_SIZE { + let length = bits.read_bits(4)? as u8; + if length == 15 { + let zero_count = bits.read_bits(4)? as usize; + if zero_count == 0 { + lengths[pos] = 15; + pos += 1; + } else { + let count = zero_count + 2; + for _ in 0..count { + if pos >= LEVEL_TABLE_SIZE { + break; + } + lengths[pos] = 0; + pos += 1; + } + } + } else { + lengths[pos] = length; + pos += 1; + } + } + Ok((lengths, bits.bit_pos)) +} + +#[derive(Debug)] +struct ReaderTables { + main: HuffmanState, + distance: HuffmanState, + align: HuffmanState, + length: HuffmanState, + align_mode: bool, +} +impl ReaderTables { + fn from_lengths(lengths: &OwnedLengths, allowance: &B) -> Result { + Ok(Self { + main: HuffmanState::from_lengths(&lengths.main, allowance)?, + distance: HuffmanState::from_lengths(&lengths.distance, allowance)?, + align: HuffmanState::from_lengths(&lengths.align, allowance)?, + length: HuffmanState::from_lengths(&lengths.length, allowance)?, + align_mode: lengths + .align + .iter() + .any(|&length| length != 0 && length != 4), + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + main: self.main.try_clone()?, + distance: self.distance.try_clone()?, + align: self.align.try_clone()?, + length: self.length.try_clone()?, + align_mode: self.align_mode, + }) + } +} + +pub fn table_length_count(algorithm_version: u8) -> Result { + match algorithm_version { + 0 => Ok(MAIN_TABLE_SIZE + DISTANCE_TABLE_SIZE_50 + ALIGN_TABLE_SIZE + LENGTH_TABLE_SIZE), + 1 => Ok(MAIN_TABLE_SIZE + DISTANCE_TABLE_SIZE_70 + ALIGN_TABLE_SIZE + LENGTH_TABLE_SIZE), + _ => Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version", + )), + } +} + +pub fn read_table_lengths(input: &[u8], algorithm_version: u8) -> Result<(TableLengths, usize)> { + read_table_lengths_with_allowance(input, algorithm_version, &Allowance::default()).map( + |(lengths, bits)| { + ( + TableLengths { + main: lengths.main.into_vec(), + distance: lengths.distance.into_vec(), + align: lengths.align.into_vec(), + length: lengths.length.into_vec(), + }, + bits, + ) + }, + ) +} + +fn read_table_lengths_with_allowance( + input: &[u8], + algorithm_version: u8, + allowance: &B, +) -> Result<(OwnedLengths, usize)> { + let table_size = table_length_count(algorithm_version)?; + let (level_lengths, level_bits) = read_level_lengths(input)?; + let level_decoder = HuffmanState::from_lengths(&level_lengths, allowance)?; + let mut bits = BitReader::new(input); + bits.bit_pos = level_bits; + + let mut lengths = Buffer::with_capacity(table_size, allowance)?; + while lengths.len() < table_size { + let number = level_decoder.decode(&mut bits)?; + match number { + 0..=15 => lengths.push_admitted(number as u8), + 16 | 17 => { + if lengths.is_empty() { + return Err(Error::InvalidData( + "RAR 5 table repeats missing previous length", + )); + } + let count = if number == 16 { + 3 + bits.read_bits(3)? as usize + } else { + 11 + bits.read_bits(7)? as usize + }; + let previous = *lengths.last().unwrap(); + for _ in 0..count { + if lengths.len() >= table_size { + break; + } + lengths.push_admitted(previous); + } + } + _ => { + // The level table has exactly 20 symbols, so these are 18/19. + let count = if number == 18 { + 3 + bits.read_bits(3)? as usize + } else { + 11 + bits.read_bits(7)? as usize + }; + for _ in 0..count { + if lengths.len() >= table_size { + break; + } + lengths.push_admitted(0); + } + } + } + } + + // table_length_count above rejects every version other than 0 and 1. + let distance_size = if algorithm_version == 0 { + DISTANCE_TABLE_SIZE_50 + } else { + DISTANCE_TABLE_SIZE_70 + }; + let distance_start = MAIN_TABLE_SIZE; + let align_start = distance_start + distance_size; + let length_start = align_start + ALIGN_TABLE_SIZE; + + Ok(( + OwnedLengths { + main: Buffer::copied(&lengths[..distance_start], allowance)?, + distance: Buffer::copied(&lengths[distance_start..align_start], allowance)?, + align: Buffer::copied(&lengths[align_start..length_start], allowance)?, + length: Buffer::copied(&lengths[length_start..], allowance)?, + }, + bits.bit_pos, + )) +} + +pub fn decode_literal_only( + input: &[u8], + algorithm_version: u8, + output_size: usize, +) -> Result> { + let mut decoder = Unpack50Decoder::new(); + decoder.decode_member( + input, + algorithm_version, + output_size, + false, + DecodeMode::LiteralOnly, + ) +} + +pub fn decode_lz(input: &[u8], algorithm_version: u8, output_size: usize) -> Result> { + let mut decoder = Unpack50Decoder::new(); + decoder.decode_member(input, algorithm_version, output_size, false, DecodeMode::Lz) +} + +/// The filters RAR 5 has a builtin type for. +/// +/// Narrower than [`crate::FilterKind`], which names every filter any format +/// can apply. The conversion below is where a filter RAR 5 cannot encode is +/// turned away. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum Rar50Filter { + Delta { channels: usize }, + E8, + E8E9, + Arm, +} + +impl TryFrom for Rar50Filter { + type Error = crate::UnsupportedFilterKind; + + fn try_from(kind: crate::FilterKind) -> std::result::Result { + use crate::FilterKind as Kind; + match kind { + Kind::Delta { channels } => Ok(Self::Delta { channels }), + Kind::E8 => Ok(Self::E8), + Kind::E8E9 => Ok(Self::E8E9), + Kind::Arm => Ok(Self::Arm), + // No wildcard arm: an eighth filter has to be decided about here. + kind @ (Kind::Itanium | Kind::Rgb { .. } | Kind::Audio { .. }) => { + Err(crate::UnsupportedFilterKind(kind)) + } + } + } +} + +#[derive(Debug)] +pub struct Unpack50Decoder { + pub(crate) read_control: crate::read_control::ReadControl, + state: ReaderState, +} +impl Clone for Unpack50Decoder { + fn clone(&self) -> Self { + Self { + read_control: self.read_control.clone(), + state: self.state.try_clone().expect("unlimited decoder copy"), + } + } +} +impl Unpack50Decoder { + pub fn new() -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + state: ReaderState::new(&Allowance::default()), + } + } + #[cfg(all(test, feature = "write"))] + fn copy_match( + &self, + output: &mut Vec, + distance: usize, + length: usize, + output_limit: usize, + dictionary_size: usize, + ) -> Result<()> { + let mut owned = Buffer::from_vec(std::mem::take(output)); + let result = + self.state + .copy_match(&mut owned, distance, length, output_limit, dictionary_size); + *output = owned.into_vec(); + result + } + pub fn decode_member( + &mut self, + input: &[u8], + algorithm_version: u8, + output_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member(input, algorithm_version, output_size, solid, mode) + .map(Buffer::into_vec) + } + pub fn decode_member_with_dictionary( + &mut self, + input: &[u8], + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_with_dictionary( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + mode, + ) + .map(Buffer::into_vec) + } + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader(input, algorithm_version, output_size, solid, mode) + .map(Buffer::into_vec) + } + pub fn decode_member_from_reader_with_dictionary( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader_with_dictionary( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + mode, + ) + .map(Buffer::into_vec) + } + pub fn decode_member_from_reader_with_dictionary_to_sink( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + sink: impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + self.state.read_control = self.read_control.clone(); + self.state + .decode_member_from_reader_with_dictionary_to_sink( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + sink, + ) + } + #[cfg(all(test, feature = "write"))] + #[allow(clippy::too_many_arguments)] + pub(crate) fn decode_to_sink_with_filters( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + sink: impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + filters: Option<&mut dyn FnMut(PendingFilter) -> std::result::Result<(), E>>, + ) -> std::result::Result<(), StreamDecodeError> { + self.state.read_control = self.read_control.clone(); + self.state.decode_to_sink_with_filters( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + sink, + filters, + ) + } +} + +/// Buffered workers may discard state they will never use. Public and stateful +/// decoding retains history; solid and limited decoding always overrides this. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum HistoryRetention { + Retain, + DiscardIndependent, +} + +#[derive(Debug)] +pub(crate) struct ReaderState { + pub(crate) read_control: crate::read_control::ReadControl, + tables: Option>, + reps: [usize; 4], + last_length: usize, + history: Buffer, +} + +impl ReaderState { + pub(crate) fn allowance(&self) -> B { + self.history.allowance() + } + pub(crate) fn new(allowance: &B) -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + tables: None, + reps: [0; 4], + last_length: 0, + history: Buffer::new(allowance), + } + } + + pub(crate) fn try_clone(&self) -> Result { + self.try_clone_with_spare_capacity(false) + } + + pub(crate) fn try_clone_for_stream(&self) -> Result { + self.try_clone_with_spare_capacity(!B::LIMITED) + } + + fn try_clone_with_spare_capacity(&self, preserve_capacity: bool) -> Result { + Ok(Self { + read_control: self.read_control.clone(), + tables: self + .tables + .as_ref() + .map(ReaderTables::try_clone) + .transpose()?, + reps: self.reps, + last_length: self.last_length, + history: if preserve_capacity { + // Solid streaming checkpoints otherwise discard geometric spare + // capacity and grow again after each member. Keep the capacity + // so a run of small members reuses a few allocation sizes. + let mut history = + Buffer::with_capacity(self.history.capacity(), &self.history.allowance())?; + history + .extend_from_slice(&self.history) + .map_err(Into::into)?; + history + } else { + // Public clones and bounded streaming checkpoints retain their + // existing allocation charge and refusal boundary. + Buffer::copied(&self.history, &self.history.allowance())? + }, + }) + } + pub fn decode_member( + &mut self, + input: &[u8], + algorithm_version: u8, + output_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.read_control.check_codec()?; + self.decode_member_with_dictionary( + input, + algorithm_version, + output_size, + DEFAULT_DICTIONARY_SIZE, + solid, + mode, + ) + } + + pub fn decode_member_with_dictionary( + &mut self, + input: &[u8], + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.decode_member_with_dictionary_and_history( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + mode, + HistoryRetention::Retain, + ) + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn decode_member_with_dictionary_and_history( + &mut self, + input: &[u8], + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + history: HistoryRetention, + ) -> Result> { + self.read_control.check_codec()?; + let mut input = std::io::Cursor::new(input); + self.decode_member_from_reader_with_dictionary_and_history( + &mut input, + algorithm_version, + output_size, + dictionary_size, + solid, + mode, + history, + ) + } + + pub fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + self.decode_member_from_reader_with_dictionary( + input, + algorithm_version, + output_size, + DEFAULT_DICTIONARY_SIZE, + solid, + mode, + ) + } + + pub fn decode_member_from_reader_with_dictionary( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + ) -> Result> { + self.decode_member_from_reader_with_dictionary_and_history( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + mode, + HistoryRetention::Retain, + ) + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn decode_member_from_reader_with_dictionary_and_history( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, + history: HistoryRetention, + ) -> Result> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + if dictionary_size == 0 { + return Err(Error::InvalidData("RAR 5 dictionary size is zero")); + } + if !solid { + self.reset(); + } + + let allowance = self.history.allowance(); + let mut output = + Buffer::with_capacity(output_size.min(MAX_INITIAL_OUTPUT_CAPACITY), &allowance)?; + let mut filters = Buffer::new(&allowance); + + loop { + let block = read_compressed_block_with_allowance(input, &self.history.allowance())?; + let payload = &*block.payload; + let mut payload_bit_pos = 0; + if block.header.has_tables { + let (lengths, table_bits) = read_table_lengths_with_allowance( + payload, + algorithm_version, + &block.payload.allowance(), + )?; + self.tables = Some(ReaderTables::from_lengths( + &lengths, + &block.payload.allowance(), + )?); + payload_bit_pos = table_bits; + } + let tables = self + .tables + .take() + .ok_or(Error::InvalidData("RAR 5 block reuses missing tables"))?; + let mut bits = BitReader::new(payload); + bits.bit_pos = payload_bit_pos; + + let mut poller = self.read_control.poller(); + while bits.bit_pos < block.header.payload_bits && output.len() < output_size { + poller.check_codec(output.len())?; + let symbol = tables.main.decode(&mut bits)?; + match symbol { + 0..=255 => output.try_push(symbol as u8)?, + 256 if mode.uses_lz() => { + filters.try_push(read_filter(&mut bits, output.len())?)?; + } + 257 if mode.uses_lz() => { + if self.last_length != 0 { + self.copy_match( + &mut output, + self.reps[0], + self.last_length, + output_size, + dictionary_size, + )?; + } + } + 258..=261 if mode.uses_lz() => { + let rep_index = symbol - 258; + let distance = self.reps[rep_index]; + if distance == 0 { + return Err(Error::InvalidData( + "RAR 5 repeat distance is not initialized", + )); + } + let length_slot = tables.length.decode(&mut bits)?; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // The length table has 44 symbols and read_bits limits + // the extra value to this slot's declared width. + let length = length_from_slot_parts(length_slot, length_extra); + self.reps[..=rep_index].rotate_right(1); + self.reps[0] = distance; + self.last_length = length; + self.copy_match( + &mut output, + distance, + length, + output_size, + dictionary_size, + )?; + } + 262.. if mode.uses_lz() => { + let length_slot = symbol - 262; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // Main symbols end at slot 43 and read_bits limits the + // extra value to this slot's declared width. + let mut length = length_from_slot_parts(length_slot, length_extra); + let distance_slot = tables.distance.decode(&mut bits)?; + let distance_bit_count = distance_slot_bit_count(distance_slot)?; + let distance_extra = if distance_bit_count >= 4 && tables.align_mode { + let high = bits.read_bits((distance_bit_count - 4) as u8)?; + let low = tables.align.decode(&mut bits)? as u32; + (high << 4) | low + } else { + bits.read_bits(distance_bit_count as u8)? + }; + // distance_slot_bit_count rejected slots above 65 and + // the extra value was read at exactly that width. + let distance = distance_from_slot_parts( + distance_slot, + distance_bit_count, + distance_extra, + ); + length += length_bonus(distance); + self.reps.rotate_right(1); + self.reps[0] = distance; + self.last_length = length; + self.copy_match( + &mut output, + distance, + length, + output_size, + dictionary_size, + )?; + } + _ => { + return Err(Error::InvalidData( + "RAR 5 literal-only decoder encountered non-literal symbol", + )); + } + } + } + + self.tables = Some(tables); + if block.header.is_last || output.len() >= output_size { + break; + } + } + + if output.len() == output_size { + let retain_history = B::LIMITED || solid || history == HistoryRetention::Retain; + let history_output = if retain_history && mode.applies_filters() && !filters.is_empty() + { + Some(Buffer::copied( + &output[output.len().saturating_sub(dictionary_size)..], + &allowance, + )?) + } else { + None + }; + if mode.applies_filters() { + self.read_control.check_codec()?; + apply_filters_with_allowance( + &mut output, + &filters, + &self.read_control, + &allowance, + )?; + } + if retain_history { + self.remember_history( + history_output.as_deref().unwrap_or(&output), + dictionary_size, + )?; + } + Ok(output) + } else { + Err(Error::NeedMoreInput) + } + } + + pub fn decode_member_from_reader_with_dictionary_to_sink( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + sink: impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + self.decode_to_sink_with_filters( + input, + algorithm_version, + output_size, + dictionary_size, + solid, + sink, + None, + ) + } + + // Mirrors the public streaming entry point, adding a filter-record destination. + #[allow(clippy::too_many_arguments)] + pub(crate) fn decode_to_sink_with_filters( + &mut self, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mut sink: impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + mut filters: Option<&mut dyn FnMut(PendingFilter) -> std::result::Result<(), E>>, + ) -> std::result::Result<(), StreamDecodeError> { + self.read_control.check_codec()?; + let control = self.read_control.clone(); + let input = &mut control.reader(input); + if dictionary_size == 0 { + return Err(Error::InvalidData("RAR 5 dictionary size is zero").into()); + } + if !solid { + self.reset(); + } + + // VecDeque grows as decoded bytes arrive, so using the declared + // dictionary here does not allocate a potentially huge RAR 7 window + // up front. It does, however, retain every byte that a legal match may + // reference instead of silently truncating the window at 64 MiB. + let history_limit = dictionary_size; + if self.history.len() > history_limit { + let discard = self.history.len() - history_limit; + self.history.discard_prefix(discard); + } + let mut output = StreamingOutput::new( + { + let allowance = self.history.allowance(); + std::mem::replace(&mut self.history, Buffer::new(&allowance)) + }, + output_size, + dictionary_size, + history_limit, + )?; + + loop { + let block = read_compressed_block_with_allowance(input, &output.history.allowance())?; + let payload = &*block.payload; + let mut payload_bit_pos = 0; + if block.header.has_tables { + let (lengths, table_bits) = read_table_lengths_with_allowance( + payload, + algorithm_version, + &block.payload.allowance(), + )?; + self.tables = Some(ReaderTables::from_lengths( + &lengths, + &block.payload.allowance(), + )?); + payload_bit_pos = table_bits; + } + let tables = self + .tables + .take() + .ok_or(Error::InvalidData("RAR 5 block reuses missing tables"))?; + let mut bits = BitReader::new(payload); + bits.bit_pos = payload_bit_pos; + + let mut poller = self.read_control.poller(); + while bits.bit_pos < block.header.payload_bits && output.written() < output_size { + poller.check_codec(output.written())?; + let symbol = tables.main.decode(&mut bits)?; + match symbol { + 0..=255 => output.push(symbol as u8, &mut sink)?, + 256 => { + let Some(filters) = filters.as_mut() else { + return Err(StreamDecodeError::FilteredMember); + }; + let filter = read_filter(&mut bits, output.written())?; + if filter + .start + .checked_add(filter.length) + .is_none_or(|end| end > output_size) + { + return Err( + Error::InvalidData("RAR 5 filter range exceeds output").into() + ); + } + filters(filter).map_err(StreamDecodeError::Sink)?; + } + 257 => { + if self.last_length != 0 { + output.copy_match(self.reps[0], self.last_length, &mut sink)?; + } + } + 258..=261 => { + let rep_index = symbol - 258; + let distance = self.reps[rep_index]; + if distance == 0 { + return Err(Error::InvalidData( + "RAR 5 repeat distance is not initialized", + ) + .into()); + } + let length_slot = tables.length.decode(&mut bits)?; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // The length table has 44 symbols and read_bits limits + // the extra value to this slot's declared width. + let length = length_from_slot_parts(length_slot, length_extra); + self.reps[..=rep_index].rotate_right(1); + self.reps[0] = distance; + self.last_length = length; + output.copy_match(distance, length, &mut sink)?; + } + 262.. => { + let length_slot = symbol - 262; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // Main symbols end at slot 43 and read_bits limits the + // extra value to this slot's declared width. + let mut length = length_from_slot_parts(length_slot, length_extra); + let distance_slot = tables.distance.decode(&mut bits)?; + let distance_bit_count = distance_slot_bit_count(distance_slot)?; + let distance_extra = if distance_bit_count >= 4 && tables.align_mode { + let high = bits.read_bits((distance_bit_count - 4) as u8)?; + let low = tables.align.decode(&mut bits)? as u32; + (high << 4) | low + } else { + bits.read_bits(distance_bit_count as u8)? + }; + // distance_slot_bit_count rejected slots above 65 and + // the extra value was read at exactly that width. + let distance = distance_from_slot_parts( + distance_slot, + distance_bit_count, + distance_extra, + ); + length += length_bonus(distance); + self.reps.rotate_right(1); + self.reps[0] = distance; + self.last_length = length; + output.copy_match(distance, length, &mut sink)?; + } + } + } + + self.tables = Some(tables); + if block.header.is_last || output.written() >= output_size { + break; + } + } + + if output.written() == output_size { + output.finish(&mut sink)?; + self.history = output.into_history(); + Ok(()) + } else { + Err(Error::NeedMoreInput.into()) + } + } + + fn remember_history(&mut self, output: &[u8], dictionary_size: usize) -> Result<()> { + let incoming = &output[output.len().saturating_sub(dictionary_size)..]; + let keep = self.history.len().min(dictionary_size - incoming.len()); + let required = keep + incoming.len(); + if self.history.capacity() > dictionary_size || self.history.capacity() < required { + // Allocate only the retained tail, never the whole member. Replace + // oversized storage when the active dictionary shrinks as well. + let capacity = + reader_history_capacity(self.history.capacity(), required, dictionary_size); + let mut history = Buffer::with_capacity(capacity, &self.history.allowance())?; + history + .extend_from_slice(&self.history[self.history.len() - keep..]) + .map_err(Into::into)?; + history.extend_from_slice(incoming).map_err(Into::into)?; + self.history = history; + } else { + self.history.discard_prefix(self.history.len() - keep); + self.history + .extend_from_slice(incoming) + .map_err(Into::into)?; + } + Ok(()) + } + + fn reset(&mut self) { + self.tables = None; + self.reps = [0; 4]; + self.last_length = 0; + self.history.clear(); + } + + fn copy_match( + &self, + output: &mut Buffer, + distance: usize, + length: usize, + output_limit: usize, + dictionary_size: usize, + ) -> Result<()> { + if output + .len() + .checked_add(length) + .is_none_or(|end| end > output_limit) + { + return Err(Error::InvalidData("RAR 5 match exceeds output limit")); + } + // A match reaching past the start of the window writes zeroes rather + // than failing. WinRAR never clears its window and guards the copy + // with a first-wrap flag instead, so those bytes read as zero there, + // and an archive that leans on it stays readable here. Nothing is + // swallowed: a stream that is damaged rather than merely odd still + // fails its file hash. + if distance == 0 + || distance > dictionary_size + || distance > self.history.len() + output.len() + { + output.resize(output.len() + length, 0)?; + return Ok(()); + } + let mut remaining = length; + while remaining > 0 { + if distance <= output.len() { + // The match lies entirely in already-decoded output: copy in + // runs rather than one byte at a time. + if distance == 1 { + // A one-byte repeat is a fill, not a copy. + let b = output[output.len() - 1]; + output.resize(output.len() + remaining, b)?; + remaining = 0; + } else { + let start = output.len() - distance; + if remaining <= distance { + return output.extend_from_within(start..start + remaining); + } + // Newly appended bytes are initialized repetitions of + // the same period. Reuse that growing run so short + // overlapping matches take logarithmically many copies. + while remaining > 0 { + let take = remaining.min(output.len() - start); + output.extend_from_within(start..start + take)?; + remaining -= take; + } + return Ok(()); + } + } else { + let history_distance = distance - output.len(); + let index = self.history.len() - history_distance; + let take = remaining.min(history_distance); + output + .extend_from_slice(&self.history[index..index + take]) + .map_err(Into::into)?; + remaining -= take; + } + } + Ok(()) + } +} + +// Preserve amortized growth without letting a retained dictionary allocation +// grow to the member size or keep a previous, larger dictionary alive. +fn reader_history_capacity(current: usize, required: usize, limit: usize) -> usize { + if current > limit { + required + } else { + required.max(current.saturating_mul(2)).max(8).min(limit) + } +} + +struct StreamingOutput { + history: super::workspace::Deque, + pending: Buffer, + written: usize, + output_limit: usize, + dictionary_size: usize, + history_limit: usize, + all_zero: bool, +} + +impl StreamingOutput { + fn new( + mut history: Buffer, + output_limit: usize, + dictionary_size: usize, + history_limit: usize, + ) -> Result { + if history.capacity() > history_limit { + history = Buffer::copied(&history, &history.allowance())?; + } + let allowance = history.allowance(); + Ok(Self { + all_zero: history.iter().all(|&byte| byte == 0), + history: super::workspace::Deque::from_buffer(history), + pending: Buffer::with_capacity(STREAM_FLUSH_THRESHOLD, &allowance)?, + written: 0, + output_limit, + dictionary_size, + history_limit, + }) + } + + fn written(&self) -> usize { + self.written + } + + fn push( + &mut self, + byte: u8, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + if self.written >= self.output_limit { + return Err(Error::InvalidData("RAR 5 match exceeds output limit").into()); + } + if byte != 0 { + self.all_zero = false; + } + self.pending.try_push(byte)?; + self.written += 1; + if self.pending.len() >= STREAM_FLUSH_THRESHOLD { + self.flush(sink)?; + } + Ok(()) + } + + fn push_repeated( + &mut self, + byte: u8, + mut count: usize, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + if self + .written + .checked_add(count) + .is_none_or(|end| end > self.output_limit) + { + return Err(Error::InvalidData("RAR 5 match exceeds output limit").into()); + } + if byte != 0 { + self.all_zero = false; + } + while count > 0 { + let available = STREAM_FLUSH_THRESHOLD - self.pending.len(); + let take = count.min(available.max(1)); + let old_len = self.pending.len(); + self.pending.resize(old_len + take, byte)?; + self.written += take; + count -= take; + if self.pending.len() >= STREAM_FLUSH_THRESHOLD { + self.flush(sink)?; + } + } + Ok(()) + } + + fn push_zeroes( + &mut self, + count: usize, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + if self + .written + .checked_add(count) + .is_none_or(|end| end > self.output_limit) + { + return Err(Error::InvalidData("RAR 5 match exceeds output limit").into()); + } + self.flush(sink)?; + // copy_match only reaches this path with an initialized positive + // distance. Either retained history exists, or flushing the pending + // zero literals retains at least one byte (the dictionary is nonzero). + debug_assert!(!self.history.is_empty()); + sink(DecodedChunk::Repeated { + byte: 0, + len: count, + }) + .map_err(StreamDecodeError::Sink)?; + self.written += count; + Ok(()) + } + + fn copy_match( + &mut self, + distance: usize, + length: usize, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + if self.all_zero && distance <= self.written + self.history.len() { + return self.push_zeroes(length, sink); + } + // Zero-fill out-of-window matches, as the buffered decoder does. + if distance == 0 + || distance > self.dictionary_size + || distance > self.history.len() + self.pending.len() + { + return self.push_repeated(0, length, sink); + } + if self + .written + .checked_add(length) + .is_none_or(|end| end > self.output_limit) + { + return Err(Error::InvalidData("RAR 5 match exceeds output limit").into()); + } + if distance == 1 { + let byte = self.byte_at_distance(1); + return self.push_repeated(byte, length, sink); + } + let mut remaining = length; + while remaining != 0 { + let available = STREAM_FLUSH_THRESHOLD - self.pending.len(); + if distance <= self.pending.len() { + // Seed the repeated run from the preceding distance bytes. + // Each append makes a larger initialized run available, so + // overlapping short-distance matches double instead of + // copying one period (or one byte) at a time. + let start = self.pending.len() - distance; + let mut run = remaining.min(available); + while run != 0 { + let take = run.min(self.pending.len() - start); + self.pending.extend_from_within(start..start + take)?; + self.written += take; + remaining -= take; + run -= take; + } + } else { + // VecDeque history can wrap into two slices. Copy only the + // current contiguous part; once the source reaches pending, + // the initialized-run path above handles the overlap. + let history_distance = distance - self.pending.len(); + let start = self.history.len() - history_distance; + let (first, second) = self.history.as_slices(); + let source = if start < first.len() { + &first[start..] + } else { + &second[start - first.len()..] + }; + let take = remaining.min(available).min(source.len()); + self.pending + .extend_from_slice(&source[..take]) + .map_err(|error| StreamDecodeError::Decode(error.into()))?; + self.written += take; + remaining -= take; + } + if self.pending.len() == STREAM_FLUSH_THRESHOLD { + self.flush(sink)?; + } + } + Ok(()) + } + + fn byte_at_distance(&self, distance: usize) -> u8 { + // copy_match admits only distances inside the current window. Every + // copied byte extends that window; flush retains at least distance + // bytes because distance is bounded by dictionary_size. + if distance <= self.pending.len() { + self.pending[self.pending.len() - distance] + } else { + let history_distance = distance - self.pending.len(); + self.history[self.history.len() - history_distance] + } + } + + fn flush( + &mut self, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + if self.pending.is_empty() { + return Ok(()); + } + sink(DecodedChunk::Bytes(&self.pending)).map_err(StreamDecodeError::Sink)?; + let incoming = &self.pending[self.pending.len().saturating_sub(self.history_limit)..]; + let keep = self.history.len().min(self.history_limit - incoming.len()); + let required = keep + incoming.len(); + if self.history.capacity() > self.history_limit || self.history.capacity() < required { + let capacity = + reader_history_capacity(self.history.capacity(), required, self.history_limit); + let mut history = + super::workspace::Deque::with_capacity(capacity, &self.history.allowance())?; + history.extend_admitted(self.history.iter().skip(self.history.len() - keep).copied()); + history.extend_admitted(incoming.iter().copied()); + self.history = history; + } else { + self.history.discard_prefix(self.history.len() - keep); + self.history.extend_admitted(incoming.iter().copied()); + } + self.pending.clear(); + Ok(()) + } + + fn finish( + &mut self, + sink: &mut impl FnMut(DecodedChunk<'_>) -> std::result::Result<(), E>, + ) -> std::result::Result<(), StreamDecodeError> { + self.flush(sink) + } + + fn into_history(self) -> Buffer { + self.history.into_buffer() + } +} + +#[cfg(all(test, feature = "write"))] +fn read_compressed_block(input: &mut impl Read) -> Result { + read_compressed_block_with_allowance(input, &Allowance::default()) +} + +fn read_compressed_block_with_allowance( + input: &mut impl Read, + allowance: &B, +) -> Result> { + let mut fixed = [0u8; 2]; + input + .read_exact(&mut fixed) + .map_err(Error::from_read_error)?; + let flags = fixed[0]; + let checksum = fixed[1]; + let size_bytes_len = match (flags >> 3) & 0x03 { + 0 => 1, + 1 => 2, + 2 => 3, + _ => return Err(Error::InvalidData("RAR 5 block size length is invalid")), + }; + let mut size_bytes = [0u8; 3]; + input + .read_exact(&mut size_bytes[..size_bytes_len]) + .map_err(Error::from_read_error)?; + + let actual = size_bytes[..size_bytes_len] + .iter() + .fold(checksum ^ flags, |acc, &byte| acc ^ byte); + if actual != 0x5a { + return Err(Error::InvalidData("RAR 5 block header checksum mismatch")); + } + + let payload_size = size_bytes[..size_bytes_len] + .iter() + .enumerate() + .fold(0usize, |acc, (index, &byte)| { + acc | (usize::from(byte) << (index * 8)) + }); + let mut payload = Buffer::filled(payload_size, 0, allowance)?; + input + .read_exact(&mut payload) + .map_err(Error::from_read_error)?; + let final_byte_bits = ((flags & 0x07) + 1).min(8); + let payload_bits = if payload_size == 0 { + 0 + } else { + (payload_size - 1) * 8 + usize::from(final_byte_bits) + }; + + Ok(OwnedCompressedBlock { + header: CompressedBlockHeader { + flags, + is_last: flags & 0x40 != 0, + has_tables: flags & 0x80 != 0, + final_byte_bits, + payload_size, + payload_bits, + }, + payload, + }) +} + +impl Default for Unpack50Decoder { + fn default() -> Self { + Self::new() + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct PendingFilter { + pub(crate) start: usize, + pub(crate) length: usize, + pub(crate) filter_type: FilterType, + pub(crate) channels: usize, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum FilterType { + Delta, + E8, + E8E9, + Arm, +} + +fn read_filter(bits: &mut BitReader<'_>, current_pos: usize) -> Result { + let offset = read_filter_data(bits)? as usize; + let length = read_filter_data(bits)? as usize; + let filter_type = match bits.read_bits(3)? { + 0 => FilterType::Delta, + 1 => FilterType::E8, + 2 => FilterType::E8E9, + 3 => FilterType::Arm, + _ => return Err(Error::InvalidData("RAR 5 filter type is unsupported")), + }; + let channels = if filter_type == FilterType::Delta { + bits.read_bits(5)? as usize + 1 + } else { + 0 + }; + Ok(PendingFilter { + start: current_pos + .checked_add(offset) + .ok_or(Error::InvalidData("RAR 5 filter start overflows"))?, + length, + filter_type, + channels, + }) +} + +fn read_filter_data(bits: &mut BitReader<'_>) -> Result { + let byte_count = bits.read_bits(2)? as usize + 1; + let mut data = 0; + for index in 0..byte_count { + data |= bits.read_bits(8)? << (index * 8); + } + Ok(data) +} + +#[cfg(all(test, feature = "write"))] +fn apply_filters_with_control( + output: &mut [u8], + filters: &[PendingFilter], + control: &crate::read_control::ReadControl, +) -> Result<()> { + apply_filters_with_allowance(output, filters, control, &Allowance::default()) +} +fn apply_filters_with_allowance( + output: &mut [u8], + filters: &[PendingFilter], + control: &crate::read_control::ReadControl, + allowance: &B, +) -> Result<()> { + control.check_codec()?; + for filter in filters { + control.check_codec()?; + let end = filter + .start + .checked_add(filter.length) + .ok_or(Error::InvalidData("RAR 5 filter range overflows"))?; + let data = output + .get_mut(filter.start..end) + .ok_or(Error::InvalidData("RAR 5 filter range exceeds output"))?; + apply_filter_data_with_allowance(data, filter, control, allowance)?; + } + Ok(()) +} + +#[cfg(all(test, feature = "write"))] +pub(crate) fn apply_filter_data( + data: &mut [u8], + filter: &PendingFilter, + control: &crate::read_control::ReadControl, +) -> Result<()> { + apply_filter_data_with_allowance(data, filter, control, &Allowance::default()) +} +pub(crate) fn apply_filter_data_with_allowance( + data: &mut [u8], + filter: &PendingFilter, + control: &crate::read_control::ReadControl, + allowance: &B, +) -> Result<()> { + match filter.filter_type { + FilterType::Delta => { + let decoded = filters::delta_decode_with_allowance( + data, + filter.channels, + rar50_delta_messages(), + control, + allowance, + )?; + data.copy_from_slice(&decoded); + } + FilterType::E8 => e8e9_decode_with_control(data, filter.start as u32, false, control)?, + FilterType::E8E9 => e8e9_decode_with_control(data, filter.start as u32, true, control)?, + FilterType::Arm => arm_decode_with_control(data, filter.start as u32, control)?, + } + Ok(()) +} + +fn rar50_delta_messages() -> DeltaErrorMessages { + DeltaErrorMessages { + invalid_channels: "RAR 5 DELTA filter channel count is invalid", + zero_channels: "RAR 5 DELTA filter has zero channels", + truncated_source: "RAR 5 DELTA filter source is truncated", + } +} + +#[cfg(all(test, feature = "write"))] +fn e8e9_decode(data: &mut [u8], file_offset: u32, include_e9: bool) { + e8e9_decode_with_control( + data, + file_offset, + include_e9, + &crate::read_control::ReadControl::default(), + ) + .expect("uncancelled filter"); +} + +fn e8e9_decode_with_control( + data: &mut [u8], + file_offset: u32, + include_e9: bool, + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + let mut poller = control.poller(); + if data.len() <= 4 { + return Ok(()); + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let opcode_limit = data.len() - 4; + let mut opcode_pos = 0usize; + while opcode_pos < opcode_limit { + poller.check_codec(opcode_pos)?; + let scan_end = if control.is_enabled() { + opcode_limit.min(opcode_pos.saturating_add(64 * 1024)) + } else { + opcode_limit + }; + let Some(pos) = super::fast::next_x86_opcode(data, opcode_pos, scan_end, cmp_mask) else { + opcode_pos = scan_end; + continue; + }; + let cur_pos = pos + 1; + let offset = file_offset.wrapping_add(cur_pos as u32) % X86_FILTER_FILE_SIZE; + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let new_addr = if addr & 0x8000_0000 != 0 { + (addr.wrapping_add(offset) & 0x8000_0000 == 0) + .then(|| addr.wrapping_add(X86_FILTER_FILE_SIZE)) + } else { + (addr.wrapping_sub(X86_FILTER_FILE_SIZE) & 0x8000_0000 != 0) + .then(|| addr.wrapping_sub(offset)) + }; + if let Some(value) = new_addr { + data[cur_pos..cur_pos + 4].copy_from_slice(&value.to_le_bytes()); + } + opcode_pos = pos + 5; + } + + Ok(()) +} + +const X86_FILTER_FILE_SIZE: u32 = 0x0100_0000; + +#[cfg(all(test, feature = "write"))] +fn arm_decode(data: &mut [u8], file_offset: u32) { + arm_decode_with_control( + data, + file_offset, + &crate::read_control::ReadControl::default(), + ) + .expect("uncancelled filter"); +} + +fn arm_decode_with_control( + data: &mut [u8], + file_offset: u32, + control: &crate::read_control::ReadControl, +) -> Result<()> { + control.check_codec()?; + let mut poller = control.poller(); + let mut pos = 0usize; + while pos + 3 < data.len() { + poller.check_codec(pos)?; + if data[pos + 3] == 0xeb { + let mut offset = u32::from(data[pos]) + | (u32::from(data[pos + 1]) << 8) + | (u32::from(data[pos + 2]) << 16); + offset = offset.wrapping_sub(file_offset.wrapping_add(pos as u32) / 4); + data[pos] = offset as u8; + data[pos + 1] = (offset >> 8) as u8; + data[pos + 2] = (offset >> 16) as u8; + } + pos += 4; + } + + Ok(()) +} + +fn length_slot_extra_bits(slot: usize) -> u8 { + if slot < 8 { + 0 + } else { + ((slot >> 2) - 1) as u8 + } +} + +fn length_bonus(distance: usize) -> usize { + usize::from(distance > 0x100) + usize::from(distance > 0x2000) + usize::from(distance > 0x40000) +} + +pub fn slot_to_length(slot: usize, extra_bits: u32) -> Result { + if slot < 8 { + return Ok(slot + 2); + } + let bit_count = (slot >> 2) - 1; + if bit_count > 24 { + return Err(Error::InvalidData("RAR 5 length slot is too large")); + } + let max_extra = (1u32 << bit_count) - 1; + if extra_bits > max_extra { + return Err(Error::InvalidData("RAR 5 length extra bits exceed slot")); + } + Ok(length_from_slot_parts(slot, extra_bits)) +} + +fn length_from_slot_parts(slot: usize, extra_bits: u32) -> usize { + if slot < 8 { + slot + 2 + } else { + let bit_count = (slot >> 2) - 1; + debug_assert!(bit_count <= 24); + debug_assert!(extra_bits < 1u32 << bit_count); + (((4 | (slot & 3)) << bit_count) | extra_bits as usize) + 2 + } +} + +pub fn distance_slot_bit_count(slot: usize) -> Result { + if slot < 4 { + Ok(0) + } else { + let bit_count = (slot - 2) >> 1; + if bit_count > 31 { + Err(Error::InvalidData("RAR 5 distance slot is too large")) + } else { + Ok(bit_count) + } + } +} + +pub fn slot_to_distance(slot: usize, extra_bits: u32) -> Result { + if slot < 4 { + return Ok(slot + 1); + } + let bit_count = distance_slot_bit_count(slot)?; + let max_extra = (1u32 << bit_count) - 1; + if extra_bits > max_extra { + return Err(Error::InvalidData("RAR 5 distance extra bits exceed slot")); + } + Ok(distance_from_slot_parts(slot, bit_count, extra_bits)) +} + +fn distance_from_slot_parts(slot: usize, bit_count: usize, extra_bits: u32) -> usize { + if slot < 4 { + return slot + 1; + } + debug_assert!(bit_count <= 31); + debug_assert!(extra_bits < 1u32 << bit_count); + let distance = (((2u64 | (slot & 1) as u64) << bit_count) | u64::from(extra_bits)) + 1; + // RAR 5 slots can name more than a 32-bit host can address. Preserve the + // decoder's out-of-window zero-fill behavior instead of wrapping to a + // plausible distance (or panicking on arithmetic overflow). + usize::try_from(distance).unwrap_or(usize::MAX) +} + +#[derive(Debug)] +pub struct HuffmanTable { + state: HuffmanState, +} +impl Clone for HuffmanTable { + fn clone(&self) -> Self { + Self { + state: self.state.try_clone().expect("unlimited table copy"), + } + } +} +impl HuffmanTable { + pub fn from_lengths(lengths: &[u8]) -> Result { + Ok(Self { + state: HuffmanState::from_lengths(lengths, &Allowance::default())?, + }) + } + pub fn is_empty(&self) -> bool { + self.state.is_empty() + } + #[cfg(all(test, feature = "write"))] + fn decode(&self, bits: &mut BitReader<'_>) -> Result { + self.state.decode(bits) + } +} +#[derive(Debug)] +struct HuffmanState { + state: super::canonical::Huffman, +} + +impl HuffmanState { + pub fn is_empty(&self) -> bool { + self.state.is_empty() + } + fn from_lengths(lengths: &[u8], allowance: &B) -> Result { + let mut count = [0u16; 16]; + for &length in lengths { + if length > 15 { + return Err(Error::InvalidData("RAR 5 Huffman length is too large")); + } + if length != 0 { + count[length as usize] = count[length as usize] + .checked_add(1) + .ok_or(Error::InvalidData("RAR 5 oversubscribed Huffman table"))?; + } + } + validate_huffman_counts(&count)?; + + Ok(Self { + state: super::canonical::Huffman::from_counts(lengths, count, allowance)?, + }) + } + fn try_clone(&self) -> Result { + Ok(Self { + state: self.state.try_clone()?, + }) + } + fn decode(&self, bits: &mut BitReader<'_>) -> Result { + self.state.decode( + || bits.read_bits(1).map(|bit| bit as u16), + "RAR 5 empty Huffman table", + "RAR 5 invalid Huffman code", + ) + } +} + +struct BitReader<'a> { + input: &'a [u8], + bit_pos: usize, +} + +impl<'a> BitReader<'a> { + fn new(input: &'a [u8]) -> Self { + Self { input, bit_pos: 0 } + } + + #[inline] + fn read_bits(&mut self, count: u8) -> Result { + let count = usize::from(count); + let byte_pos = self.bit_pos / 8; + let bit_offset = self.bit_pos % 8; + // Compare the local byte span instead of multiplying the entire input + // length by eight, which can overflow for a huge slice. + let bytes_needed = (bit_offset + count).div_ceil(8); + if bytes_needed > self.input.len().saturating_sub(byte_pos) { + return Err(Error::NeedMoreInput); + } + + if count == 0 { + return Ok(0); + } + if count <= 32 { + // Read the at-most-five physical bytes once, then discard the + // leading and trailing bits. No speculative padding is read, and + // input refusal leaves the cursor at its original position. + let bytes = &self.input[byte_pos..byte_pos + bytes_needed]; + let word = match bytes { + [a] => u64::from(*a), + [a, b] => u64::from(u16::from_be_bytes([*a, *b])), + [a, b, c] => u64::from(u32::from_be_bytes([0, *a, *b, *c])), + [a, b, c, d] => u64::from(u32::from_be_bytes([*a, *b, *c, *d])), + [a, b, c, d, e] => u64::from_be_bytes([0, 0, 0, *a, *b, *c, *d, *e]), + _ => unreachable!("a nonempty 32-bit read spans at most five bytes"), + }; + let shift = bytes_needed * 8 - bit_offset - count; + let value = ((word >> shift) & ((1u64 << count) - 1)) as u32; + self.bit_pos += count; + return Ok(value); + } + + // Preserve the existing low-32-bit result for larger internal reads. + let mut value = 0u32; + let mut remaining = count; + while remaining != 0 { + let byte = self.input[self.bit_pos / 8]; + let bit_offset = self.bit_pos % 8; + let available = 8 - bit_offset; + let take = available.min(remaining); + let shift = available - take; + let mask = ((1u16 << take) - 1) as u8; + let chunk = (byte >> shift) & mask; + value = (value << take) | u32::from(chunk); + self.bit_pos += take; + remaining -= take; + } + + Ok(value) + } +} + +fn validate_huffman_counts(count: &[u16; 16]) -> Result<()> { + super::canonical::validate_counts(count, "RAR 5 oversubscribed Huffman table") +} + +#[cfg(test)] +#[path = "rar50/streaming_copy_tests.rs"] +mod streaming_copy_tests; + +#[cfg(test)] +#[path = "rar50/huffman_tests.rs"] +mod huffman_tests; + +#[cfg(test)] +#[path = "rar50/bit_reader_tests.rs"] +mod bit_reader_tests; + +#[cfg(test)] +#[path = "rar50/checkpoint_tests.rs"] +mod checkpoint_tests; + +#[cfg(all(test, feature = "write"))] +#[path = "rar50/history_retention_tests.rs"] +mod history_retention_tests; diff --git a/arca-rar/vendor/rars/src/codec/rar50/bit_reader_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/bit_reader_tests.rs new file mode 100644 index 00000000..3cfd622a --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/bit_reader_tests.rs @@ -0,0 +1,78 @@ +use super::{BitReader, Error, Result}; + +fn bitwise_read(input: &[u8], cursor: &mut usize, count: u8) -> Result { + let count = usize::from(count); + let byte = *cursor / 8; + let span = (*cursor % 8 + count).div_ceil(8); + if span > input.len().saturating_sub(byte) { + return Err(Error::NeedMoreInput); + } + let mut value = 0u32; + for _ in 0..count { + value = (value << 1) | u32::from((input[*cursor / 8] >> (7 - *cursor % 8)) & 1); + *cursor += 1; + } + Ok(value) +} + +#[test] +fn word_reads_match_independent_bits_at_every_alignment_and_physical_tail() { + for input in [ + [0; 40], + [0xff; 40], + std::array::from_fn(|index| (index as u8).wrapping_mul(37).wrapping_add(11)), + ] { + for size in 0..=input.len() { + for start in 0..=size * 8 + 16 { + for count in 0..=40 { + let mut expected_cursor = start; + let expected = bitwise_read(&input[..size], &mut expected_cursor, count); + let mut actual = BitReader { + input: &input[..size], + bit_pos: start, + }; + assert_eq!( + actual.read_bits(count), + expected, + "size={size}, start={start}, count={count}" + ); + assert_eq!(actual.bit_pos, expected_cursor); + } + } + } + } +} + +#[test] +fn word_reads_preserve_mixed_sequences_and_wider_low_word_results() { + let input: Vec<_> = (0..4096usize) + .map(|index| (index as u8).wrapping_mul(71).wrapping_add(29)) + .collect(); + let mut actual = BitReader::new(&input); + let mut expected_cursor = 0; + for count in [1, 4, 0, 8, 15, 26, 32, 33, 64, 127, 255] + .into_iter() + .cycle() + .take(500) + { + let expected = bitwise_read(&input, &mut expected_cursor, count); + assert_eq!(actual.read_bits(count), expected); + assert_eq!(actual.bit_pos, expected_cursor); + } +} + +#[test] +fn word_read_refusal_retains_cursor_near_maximum_usize() { + for start in [usize::MAX, usize::MAX - 7, usize::MAX - 15] { + for count in [0, 1, 15, 32, 255] { + let mut expected_cursor = start; + let expected = bitwise_read(&[], &mut expected_cursor, count); + let mut actual = BitReader { + input: &[], + bit_pos: start, + }; + assert_eq!(actual.read_bits(count), expected); + assert_eq!(actual.bit_pos, start); + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/checkpoint_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/checkpoint_tests.rs new file mode 100644 index 00000000..9fce61c6 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/checkpoint_tests.rs @@ -0,0 +1,118 @@ +use super::*; + +#[test] +fn unlimited_checkpoint_retains_capacity_and_independent_history() { + let mut original = ReaderState::new(&Allowance::default()); + original.history = Buffer::with_capacity(16, &Allowance::default()).unwrap(); + original.history.extend_from_slice(b"ABCDE").unwrap(); + original.reps = [1, 2, 3, 4]; + original.last_length = 7; + let public_copy = original.try_clone().unwrap(); + assert_eq!(public_copy.history.capacity(), 5); + assert_eq!(&*public_copy.history, b"ABCDE"); + let mut copied = original.try_clone_for_stream().unwrap(); + assert_eq!(copied.history.capacity(), 16); + assert_eq!(&*copied.history, b"ABCDE"); + assert_ne!(copied.history.as_ptr(), original.history.as_ptr()); + assert_eq!(copied.reps, original.reps); + assert_eq!(copied.last_length, original.last_length); + copied.history[0] = b'X'; + assert_eq!(&*original.history, b"ABCDE"); + drop(original); + assert_eq!(&*copied.history, b"XBCDE"); +} + +#[test] +fn limited_checkpoint_keeps_its_existing_length_charge_and_refusal() { + for limit in [20, 21] { + let budget = Allowance::limited(limit); + let mut original = ReaderState::new(&budget); + original.history = Buffer::with_capacity(16, &budget).unwrap(); + original.history.extend_from_slice(b"ABCDE").unwrap(); + assert_eq!(budget.used(), 16); + match original.try_clone_for_stream() { + Ok(copied) => { + assert_eq!(limit, 21); + assert_eq!(copied.history.capacity(), 5); + assert_eq!(&*copied.history, b"ABCDE"); + assert_ne!(copied.history.as_ptr(), original.history.as_ptr()); + assert_eq!(budget.used(), 21); + drop(copied); + } + Err(error) => { + assert_eq!(limit, 20); + assert!(matches!(error, Error::WorkspaceLimitExceeded(_))); + } + } + assert_eq!(budget.used(), 16); + assert_eq!(&*original.history, b"ABCDE"); + assert_eq!(original.history.capacity(), 16); + drop(original); + assert_eq!(budget.used(), 0); + } +} + +#[test] +fn refused_checkpoint_preserves_the_previous_history_owner() { + let budget = super::super::workspace::RefusingBudget::new(1); + let mut original = ReaderState::new(&budget); + original.history = Buffer::with_capacity(16, &budget).unwrap(); + original.history.extend_from_slice(b"ABCDE").unwrap(); + let address = original.history.as_ptr(); + assert!(matches!( + original.try_clone_for_stream(), + Err(Error::Cancelled) + )); + assert_eq!(original.history.as_ptr(), address); + assert_eq!(original.history.capacity(), 16); + assert_eq!(&*original.history, b"ABCDE"); + assert_eq!(budget.used(), 16); + drop(original); + assert_eq!(budget.used(), 0); +} + +#[cfg(feature = "write")] +#[test] +fn solid_streaming_checkpoints_keep_geometric_capacity_between_small_members() { + use std::collections::BTreeSet; + let dictionary = 16 * 1024; + let data = b"solid checkpoint history and repeated match bytes\n".repeat(20); + let mut expected_history = Vec::new(); + let mut capacities = BTreeSet::new(); + let mut decoder = ReaderState::new(&Allowance::default()); + for member in 0..40 { + let packed = encode_lz_member_with_history(&data, &expected_history, 0).unwrap(); + let mut checkpoint = decoder.try_clone_for_stream().unwrap(); + assert_eq!(checkpoint.history.capacity(), decoder.history.capacity()); + let mut decoded = Vec::new(); + checkpoint + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + data.len(), + dictionary, + member != 0, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(decoded, data); + expected_history.extend_from_slice(&data); + let discard = expected_history.len().saturating_sub(dictionary); + expected_history.drain(..discard); + assert_eq!(&*checkpoint.history, &expected_history); + assert!(checkpoint.history.capacity() <= dictionary); + capacities.insert(checkpoint.history.capacity()); + decoder = checkpoint; + } + // Each checkpoint retains the preceding geometric capacity. Copying only + // the length creates a fresh capacity on almost every small solid member. + assert!(capacities.len() <= 6, "capacities: {capacities:?}"); +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/convergence_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/convergence_tests.rs new file mode 100644 index 00000000..8dd07495 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/convergence_tests.rs @@ -0,0 +1,328 @@ +use super::*; +use std::cell::Cell; + +thread_local! { + static PRICING_PASSES: Cell = const { Cell::new(0) }; +} + +pub(super) fn record_pricing_pass() { + PRICING_PASSES.with(|count| count.set(count.get() + 1)); +} + +fn count_passes(run: impl FnOnce() -> T) -> (T, usize) { + PRICING_PASSES.with(|count| count.set(0)); + let result = run(); + (result, PRICING_PASSES.with(Cell::get)) +} + +#[derive(Debug)] +struct Reprice { + changed: bool, + tables_converged: bool, + bits: usize, + best_bits_before: usize, +} + +struct Reference { + selected: Vec, + passes: usize, + reprices: Vec, + selected_pass: usize, +} + +// Independent original three-pass pipeline, including its strict winner and +// earlier-winner-on-tie behavior. It deliberately does not stop on equal tables. +fn reference_pipeline( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + filters: &[EncodeFilter], +) -> Reference { + let allowance = Allowance::default(); + let mut collector = OptimalCollector::new(combined, block.start, options); + let matches = collector.collect(combined, block.clone(), options).unwrap(); + let mut workspace = OptimalWorkspace::new(&allowance); + let mut tokens = optimal_tokens_in_workspace( + combined, + block.clone(), + options, + distance_size, + None, + &matches, + &mut workspace, + ) + .unwrap(); + let mut passes = 1; + let mut lengths = + table_lengths_with_allowance(&tokens, filters, distance_size, &allowance).unwrap(); + let mut best_bits = token_stream_bits(&tokens, filters, &lengths, distance_size).unwrap(); + let mut best = None; + let mut selected_pass = 0; + let mut reprices = Vec::new(); + for _ in 1..OPTIMAL_PARSE_PASSES { + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let next = optimal_tokens_in_workspace( + combined, + block.clone(), + options, + distance_size, + Some(&prices), + &matches, + &mut workspace, + ) + .unwrap(); + passes += 1; + if next == tokens { + reprices.push(Reprice { + changed: false, + tables_converged: true, + bits: best_bits, + best_bits_before: best_bits, + }); + break; + } + let next_lengths = + table_lengths_with_allowance(&next, filters, distance_size, &allowance).unwrap(); + let tables_converged = lengths.slices() == next_lengths.slices(); + lengths = next_lengths; + let bits = token_stream_bits(&next, filters, &lengths, distance_size).unwrap(); + reprices.push(Reprice { + changed: true, + tables_converged, + bits, + best_bits_before: best_bits, + }); + if bits < best_bits { + best_bits = bits; + best = None; + selected_pass = passes - 1; + } else if best.is_none() { + best = Some(std::mem::replace(&mut tokens, Buffer::new(&allowance))); + } + tokens = next; + } + Reference { + selected: best.unwrap_or(tokens).into_vec(), + passes, + reprices, + selected_pass, + } +} + +fn generated_noise(seed: u32, size: usize, alphabet: u8) -> Vec { + let mut state = seed; + (0..size) + .map(|_| { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + ((state >> 24) as u8) % alphabet + }) + .collect() +} + +fn compare_pipeline( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + algorithm_version: u8, + filters: &[EncodeFilter], +) -> (Reference, usize) { + assert!(filters + .iter() + .all(|filter| filter.offset + filter.length <= block.len())); + let distance_size = if algorithm_version == 0 { + DISTANCE_TABLE_SIZE_50 + } else { + DISTANCE_TABLE_SIZE_70 + }; + let (reference, reference_passes) = count_passes(|| { + reference_pipeline(combined, block.clone(), options, distance_size, filters) + }); + assert_eq!(reference.passes, reference_passes); + let (actual, actual_passes) = count_passes(|| { + encode_tokens_with_allowance( + combined, + block.clone(), + MemberSearch::Fresh, + options, + distance_size, + filters, + None, + &Allowance::default(), + ) + .unwrap() + }); + assert_eq!( + &*actual, + reference.selected, + "start={}, candidates={}, version={algorithm_version}, filters={}", + block.start, + options.max_match_candidates, + filters.len() + ); + assert!(actual_passes <= reference.passes); + let expected_full: Vec<_> = filters + .iter() + .copied() + .map(EncodeToken::Filter) + .chain(reference.selected.iter().copied()) + .collect(); + let actual_full: Vec<_> = filters + .iter() + .copied() + .map(EncodeToken::Filter) + .chain(actual.iter().copied()) + .collect(); + assert_eq!( + encode_token_block(&actual_full, algorithm_version, distance_size, true).unwrap(), + encode_token_block(&expected_full, algorithm_version, distance_size, true).unwrap(), + ); + (reference, actual_passes) +} + +#[test] +fn equal_tables_with_changed_tokens_skip_a_real_pricing_pass() { + // The first Huffman-priced pass chooses a different token sequence, but + // generates exactly the same four tables. The old third pass recreates + // that sequence and stops; the new pipeline avoids that work entirely. + let input = generated_noise(92, 256, 2); + let options = EncodeOptions::new(16).with_optimal_parse(true); + for version in [0, 1] { + let (reference, actual_passes) = + compare_pipeline(&input, 0..input.len(), options, version, &[]); + assert_eq!(reference.passes, 3); + assert_eq!(actual_passes, 2); + assert!(reference.reprices[0].changed); + assert!(reference.reprices[0].tables_converged); + assert!(!reference.reprices[1].changed); + assert_eq!( + reference.reprices[0].bits + 3, + reference.reprices[0].best_bits_before + ); + if version == 0 { + assert_eq!(reference.reprices[0].best_bits_before, 575); + assert_eq!(reference.reprices[0].bits, 572); + } + assert_eq!(reference.selected_pass, 1); + } +} + +#[test] +fn convergence_preserves_the_earlier_winner_on_ties_and_losses() { + let options = EncodeOptions::new(16).with_optimal_parse(true); + let mut saw_final_tie = false; + let mut saw_final_loss = false; + for version in [0, 1] { + for seed in 0..128 { + let input = generated_noise(seed, 256, 2); + let (reference, _) = compare_pipeline(&input, 0..input.len(), options, version, &[]); + let last = reference.reprices.last().unwrap(); + if last.changed && reference.selected_pass < reference.passes - 1 { + saw_final_tie |= last.bits == last.best_bits_before; + saw_final_loss |= last.bits > last.best_bits_before; + } + // A first-pass tie must not displace the earlier winner, while + // the later strict improvement must still be selected. + if version == 0 && seed == 3 { + assert!(reference.reprices[0].changed); + assert_eq!( + reference.reprices[0].bits, + reference.reprices[0].best_bits_before + ); + assert_eq!(reference.selected_pass, 2); + } + // A losing reprice followed by an improvement must not leave the + // earlier retained stream in place after that improvement. + if version == 0 && seed == 1 { + assert!(reference.reprices[0].bits > reference.reprices[0].best_bits_before); + assert!(reference.reprices[1].bits < reference.reprices[1].best_bits_before); + assert_eq!(reference.selected_pass, 2); + } + } + } + assert!( + saw_final_tie, + "corpus must retain an earlier winner on a final tie" + ); + assert!( + saw_final_loss, + "corpus must retain an earlier winner on a final loss" + ); +} + +#[test] +fn convergence_matches_the_original_pipeline_with_filters_and_history() { + let filters = [ + EncodeFilter { + offset: 0, + length: 64, + filter_type: FilterType::Delta, + channels: 4, + }, + EncodeFilter { + offset: 64, + length: 64, + filter_type: FilterType::Arm, + channels: 0, + }, + ]; + let mut text = Vec::new(); + for i in 0..80 { + text.extend_from_slice(b"repeated text with changing tails exposes shorter continuations "); + text.push(i); + } + let corpus = [ + vec![0; 4096], + b"abc".repeat(1366), + text, + generated_noise(92, 256, 2), + generated_noise(23, 4096, 2), + generated_noise(17, 4096, 255), + (0..1024u32) + .flat_map(|word| (word * 71).to_le_bytes()) + .collect(), + ]; + for data in corpus { + for start in [0, 128] { + for candidates in [0, 16, 128] { + let options = EncodeOptions::new(candidates).with_optimal_parse(true); + for version in [0, 1] { + for records in [&[][..], &filters[..]] { + compare_pipeline(&data, start..data.len(), options, version, records); + } + } + } + } + } +} + +#[test] +fn converged_pricing_keeps_the_final_progress_and_cancellation_boundary() { + let input = generated_noise(92, 256, 2); + let options = EncodeOptions::new(16).with_optimal_parse(true); + for continue_work in [true, false] { + let mut reports = Vec::new(); + let mut report = |amount| { + reports.push(amount); + continue_work + }; + let result = encode_tokens_with_allowance( + &input, + 0..input.len(), + MemberSearch::Fresh, + options, + DISTANCE_TABLE_SIZE_50, + &[], + Some(&mut report), + &Allowance::default(), + ); + assert_eq!(reports, [input.len()]); + if continue_work { + assert!(result.is_ok()); + } else { + assert!(matches!(result, Err(Error::Cancelled))); + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/encoder.rs b/arca-rar/vendor/rars/src/codec/rar50/encoder.rs new file mode 100644 index 00000000..7446c3e0 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/encoder.rs @@ -0,0 +1,3464 @@ +//! RAR5/7 LZ encoding, block selection, token pricing and table emission. +use super::super::{huffman, match_finder}; +use super::*; +#[cfg(test)] +use std::io::Write; + +/// Matches shorter than 4 bytes are never emitted, so candidate positions are +/// chained by a hash of their first 4 bytes. +type Rar50MatchFinder = match_finder::MatchFinder<4, B>; + +const MAX_ENCODER_MATCH_OFFSET: usize = DEFAULT_DICTIONARY_SIZE; + +const MAX_ENCODER_MATCH_LENGTH: usize = 4096; + +/// The largest block the format allows a writer to emit. +const MAX_COMPRESSED_BLOCK_OUTPUT: usize = 4 * 1024 * 1024; + +/// How much input goes into one compressed block. +/// +/// Every block carries its own Huffman tables, so smaller blocks pay for the +/// extra tables and win back more by fitting each stretch of the data. Matches +/// still reach back across boundaries into the history, so shortening a block +/// costs no match range. Measured over the corpus, 64 KiB packs 6.4% smaller +/// than a mebibyte and within 0.2% of the best size tried at any point between +/// 16 KiB and 256 KiB. The streaming writer reads in the same units, so both +/// paths produce the same blocks for the same input. +pub(crate) const LZ_BLOCK_SIZE: usize = 64 * 1024; + +const _: () = assert!(LZ_BLOCK_SIZE <= MAX_COMPRESSED_BLOCK_OUTPUT); + +/// The most input one block may cover once blocks are being extended. +/// +/// A block only grows over data whose byte distribution is not moving, so the +/// bytes it covers compress to very little and the output stays far inside +/// [`MAX_COMPRESSED_BLOCK_OUTPUT`]. The cap is what the writer charges its +/// workspace for, so it is a memory decision as much as a size one: the +/// optimal parse prices every position in a block and its arrays scale with +/// the block, so a mebibyte is the point where the extra table sets saved stop +/// being worth the pages. +pub(crate) const MAX_LZ_BLOCK_SIZE: usize = 1024 * 1024; + +const _: () = assert!(MAX_LZ_BLOCK_SIZE <= MAX_COMPRESSED_BLOCK_OUTPUT); + +/// How far a chunk's byte distribution may sit from the open block's before +/// the block is closed, as a fraction of the chunk. +/// +/// The statistic is how many of the chunk's bytes the open block's model puts +/// in the wrong place, so the limit reads as "extend while under one in a +/// hundred and twenty-eight of the next chunk's bytes are distributed +/// differently". Measured over the bench corpus, per 64 KiB chunk: +/// +/// ```text +/// class min median max +/// large-compressible 0 0 0 +/// large-incompressible 3,243 3,751 5,133 +/// large-source-tree 6,274 16,972 54,003 +/// large-text 2,319 30,598 90,929 +/// large-bin-unstripped 18,298 38,875 110,933 +/// large-bin-stripped 13,982 60,996 113,086 +/// ``` +/// +/// Only data that does not move at all falls under 512, and the nearest class +/// that does move sits four and a half times above it. That gap is the whole +/// design: a block grows over data a fresh table set could not describe any +/// better, and over nothing else. +const BLOCK_DRIFT_DIVISOR: u64 = 128; + +/// Decides where one block ends, from the raw bytes alone. +/// +/// Both writers have to cut a member the same way or the same input packs to +/// different archives, and they see it differently: the buffered path holds +/// the whole member while the streaming path reads it a chunk at a time and +/// compresses a wave of blocks in parallel. So the rule reads only the bytes +/// already folded into the open block plus the chunk being considered, which +/// both of them have at the moment they have to decide. +/// +/// Every block still carries its own tables. Extending a block is what WinRAR +/// does on data like this; the format's table-reuse flag would say the same +/// thing more directly, but no archive WinRAR writes sets it, so no third +/// party decoder is known to have been tested against one that does. +#[derive(Debug, Clone)] +pub(crate) struct BlockSplitter { + counts: [u32; 256], + total: u64, +} + +impl Default for BlockSplitter { + fn default() -> Self { + Self::new() + } +} + +impl BlockSplitter { + pub(crate) const fn new() -> Self { + Self { + counts: [0; 256], + total: 0, + } + } + + /// Folds a chunk into the open block. + pub(crate) fn accept(&mut self, chunk: &[u8]) { + for &byte in chunk { + self.counts[usize::from(byte)] += 1; + } + self.total += chunk.len() as u64; + } + + /// Starts a new block. + pub(crate) fn reset(&mut self) { + self.counts = [0; 256]; + self.total = 0; + } + + /// Whether the open block should swallow `chunk` rather than end before it. + /// + /// Integer arithmetic throughout, because a block boundary decided by + /// floating point would let the same input pack to different archives on + /// two platforms whose `log2` disagree in the last bit. + /// An accepted chunk is folded into the block; refusal leaves it unchanged. + pub(crate) fn try_extend(&mut self, chunk: &[u8]) -> bool { + let Some(counts) = self.extension_counts(chunk) else { + return false; + }; + // The decision already counted every byte. Fold those counts instead + // of scanning an accepted chunk a second time through accept(). + for (ours, theirs) in self.counts.iter_mut().zip(counts) { + *ours += theirs; + } + self.total += chunk.len() as u64; + true + } + + #[cfg(test)] + pub(crate) fn extends(&self, chunk: &[u8]) -> bool { + self.extension_counts(chunk).is_some() + } + + fn extension_counts(&self, chunk: &[u8]) -> Option<[u32; 256]> { + let open = self.total; + if open == 0 || chunk.is_empty() { + return None; + } + if open + chunk.len() as u64 > MAX_LZ_BLOCK_SIZE as u64 { + return None; + } + let mut counts = [0u32; 256]; + for &byte in chunk { + counts[usize::from(byte)] += 1; + } + let chunk_len = chunk.len() as u64; + // How many of the chunk's bytes the open block's distribution places + // wrongly. Both sides are scaled by `open` so neither divides early. + let mut misplaced = 0u64; + for (theirs, ours) in counts.iter().zip(&self.counts) { + misplaced += (u64::from(*theirs) * open).abs_diff(u64::from(*ours) * chunk_len); + } + (misplaced / open <= chunk_len / BLOCK_DRIFT_DIVISOR).then_some(counts) + } +} + +#[cfg(test)] +mod splitter_tests { + use super::{BlockSplitter, LZ_BLOCK_SIZE, MAX_LZ_BLOCK_SIZE}; + + #[test] + fn drift_threshold_accepts_256_changed_bytes_and_refuses_257() { + let initial = vec![0; LZ_BLOCK_SIZE]; + for (changed, accepted) in [(256, true), (257, false)] { + let mut splitter = BlockSplitter::new(); + splitter.accept(&initial); + let mut next = initial.clone(); + next[..changed].fill(1); + assert_eq!(splitter.try_extend(&next), accepted); + if accepted { + assert_eq!(splitter.total, (2 * LZ_BLOCK_SIZE) as u64); + assert_eq!(splitter.counts[0], (2 * LZ_BLOCK_SIZE - changed) as u32); + assert_eq!(splitter.counts[1], changed as u32); + } else { + assert_eq!(splitter.total, LZ_BLOCK_SIZE as u64); + assert_eq!(splitter.counts[0], LZ_BLOCK_SIZE as u32); + assert_eq!(splitter.counts[1], 0); + } + assert!(splitter.counts[2..].iter().all(|&count| count == 0)); + } + } + + #[test] + fn one_pass_extension_preserves_decisions_counts_and_refused_state() { + let initial = vec![0; LZ_BLOCK_SIZE]; + for changed in [0, 1, 128, 255, 256, 257, 512, 1024] { + let mut next = initial.clone(); + next[..changed].fill(1); + let mut reference = BlockSplitter::new(); + let mut actual = BlockSplitter::new(); + assert!(!actual.try_extend(&next)); + assert_eq!(actual.counts, reference.counts); + assert_eq!(actual.total, reference.total); + reference.accept(&initial); + actual.accept(&initial); + for chunk in [&next[..], &initial[..], &[][..], &next[..], &initial[..31]] { + let expected = reference.extends(chunk); + assert_eq!(actual.try_extend(chunk), expected, "changed={changed}"); + if expected { + reference.accept(chunk); + } + assert_eq!(actual.counts, reference.counts); + assert_eq!(actual.total, reference.total); + } + } + let mut reference = BlockSplitter::new(); + let mut actual = BlockSplitter::new(); + reference.accept(&vec![7; MAX_LZ_BLOCK_SIZE - LZ_BLOCK_SIZE]); + actual.accept(&vec![7; MAX_LZ_BLOCK_SIZE - LZ_BLOCK_SIZE]); + for length in [LZ_BLOCK_SIZE, 1, 0] { + let chunk = vec![7; length]; + let expected = reference.extends(&chunk); + assert_eq!(actual.try_extend(&chunk), expected); + if expected { + reference.accept(&chunk); + } + assert_eq!(actual.counts, reference.counts); + assert_eq!(actual.total, reference.total); + } + } +} + +const MAX_FILTER_BLOCK_LENGTH: usize = 0x3ffff; + +/// The most channels a RAR 5 delta filter record can name. The count is written +/// as five bits biased by one, so this is what the format can say, not a policy. +pub(crate) const MAX_DELTA_CHANNELS: usize = 32; + +/// How much input goes into one compressed block once a filter is carried. +/// +/// A filter record cannot describe more than [`MAX_FILTER_BLOCK_LENGTH`] bytes, +/// so this is the smaller of that ceiling and the plain block size. Splitting a +/// filtered range across blocks costs one more record per block and converts +/// the same bytes either way: the transform reads an absolute file offset, and +/// an instruction straddling a boundary was already left alone at the old +/// 256 KiB one. +const FILTERED_LZ_BLOCK_SIZE: usize = if LZ_BLOCK_SIZE < MAX_FILTER_BLOCK_LENGTH { + LZ_BLOCK_SIZE +} else { + MAX_FILTER_BLOCK_LENGTH +}; + +/// Where the encoder stops looking for anything better. +/// +/// A search that has reached this far ends, whether it is a chain walk or a +/// tree descent, and the optimal parse takes the +/// match and steps over the bytes it covers instead of pricing each of them. The +/// second half matters more than it sounds. The parse prices every position in a +/// block, because a cheaper path can arrive at any of them, so without it a +/// 4 KiB match gets confirmed at all 4096 of its positions to learn what the +/// first one already said. On a mebibyte that repeats, that cost level 5 +/// fifty-three seconds to save four bytes over level 3. +/// +/// 512 is where committing is free. On a mebibyte of source at level 5 it packs +/// two bytes smaller than pricing every position and finishes in 7.08s rather +/// than 7.31s, and the repeating mebibyte drops to 1.19s. Committing sooner does +/// buy time, and it is not worth it: at 128 the source packs 0.16% larger for +/// 1.2x, at 64 it packs 0.47% larger for 1.5x, and neither closes the distance +/// to WinRAR. +const NICE_MATCH_LENGTH: usize = 512; + +const MAX_MATCH_CANDIDATES: usize = 256; + +#[derive(Clone, Copy, PartialEq, Eq)] +struct LengthSlices<'a> { + main: &'a [u8], + distance: &'a [u8], + align: &'a [u8], + length: &'a [u8], +} + +impl OwnedLengths { + fn slices(&self) -> LengthSlices<'_> { + LengthSlices { + main: &self.main, + distance: &self.distance, + align: &self.align, + length: &self.length, + } + } +} + +pub fn encode_table_lengths(lengths: &TableLengths, algorithm_version: u8) -> Result> { + encode_table_lengths_with_bit_count(lengths, algorithm_version).map(|(data, _)| data) +} + +pub fn encode_table_lengths_with_bit_count( + lengths: &TableLengths, + algorithm_version: u8, +) -> Result<(Vec, usize)> { + encode_table_slices( + LengthSlices { + main: &lengths.main, + distance: &lengths.distance, + align: &lengths.align, + length: &lengths.length, + }, + algorithm_version, + &Allowance::default(), + ) + .map(|(bytes, bits)| (bytes.into_vec(), bits)) +} + +fn encode_table_slices( + lengths: LengthSlices<'_>, + algorithm_version: u8, + allowance: &B, +) -> Result<(Buffer, usize)> { + let distance_size = match algorithm_version { + 0 => DISTANCE_TABLE_SIZE_50, + 1 => DISTANCE_TABLE_SIZE_70, + _ => { + return Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version", + )) + } + }; + if lengths.main.len() != MAIN_TABLE_SIZE + || lengths.distance.len() != distance_size + || lengths.align.len() != ALIGN_TABLE_SIZE + || lengths.length.len() != LENGTH_TABLE_SIZE + { + return Err(Error::InvalidData("RAR 5 table length count mismatch")); + } + + // The version and all four slice lengths were checked above. They form + // one exact-sized table, so assembly cannot request further growth. + let flattened = Buffer::from_slices( + &[ + lengths.main, + lengths.distance, + lengths.align, + lengths.length, + ], + allowance, + )?; + for &length in flattened.iter() { + if length > 15 { + return Err(Error::InvalidData("RAR 5 Huffman length is too large")); + } + } + + let level_tokens = encode_table_level_tokens_with_allowance(&flattened, allowance)?; + let level_lengths = level_code_lengths_with_allowance(&level_tokens, allowance)?; + let level_table = EncoderCodeTable::from_lengths(&level_lengths, allowance)?; + let mut writer = BitWriter::with_allowance(allowance); + try_write_level_lengths(&mut writer, &level_lengths)?; + for token in level_tokens.iter() { + let (code, len) = level_table.code_for_present_symbol(token.symbol); + writer + .try_write_bits(usize::from(code), usize::from(len)) + .map_err(Into::into)?; + if token.extra_bits != 0 { + writer + .try_write_bits( + usize::from(token.extra_value), + usize::from(token.extra_bits), + ) + .map_err(Into::into)?; + } + } + let bit_count = writer.bit_pos; + Ok((writer.bytes, bit_count)) +} + +pub fn encode_compressed_block( + payload: &[u8], + payload_bits: usize, + has_tables: bool, + is_last: bool, +) -> Result> { + encode_compressed_block_with_allowance( + payload, + payload_bits, + has_tables, + is_last, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} + +fn encode_compressed_block_with_allowance( + payload: &[u8], + payload_bits: usize, + has_tables: bool, + is_last: bool, + allowance: &B, +) -> Result> { + if payload_bits > payload.len() * 8 { + return Err(Error::InvalidData("RAR 5 block bit count exceeds payload")); + } + if !payload.is_empty() && payload_bits <= (payload.len() - 1) * 8 { + return Err(Error::InvalidData("RAR 5 block has unused payload bytes")); + } + if payload.len() > 0x00ff_ffff { + return Err(Error::InvalidData("RAR 5 block payload is too large")); + } + + let size_len = if payload.len() <= 0xff { + 1 + } else if payload.len() <= 0xffff { + 2 + } else { + 3 + }; + let final_byte_bits = if payload.is_empty() { + 1 + } else { + ((payload_bits - 1) % 8) + 1 + }; + let mut flags = (final_byte_bits as u8) - 1; + flags |= ((size_len - 1) as u8) << 3; + if is_last { + flags |= 0x40; + } + if has_tables { + flags |= 0x80; + } + + let mut size_bytes = [0u8; 3]; + let mut size = payload.len(); + for byte in &mut size_bytes[..size_len] { + *byte = size as u8; + size >>= 8; + } + let checksum = size_bytes[..size_len] + .iter() + .fold(0x5a ^ flags, |acc, &byte| acc ^ byte); + // The header and bounded payload have an exact final size. + Buffer::from_slices( + &[&[flags, checksum], &size_bytes[..size_len], payload], + allowance, + ) +} + +pub fn encode_literal_only(data: &[u8], algorithm_version: u8) -> Result> { + let distance_size = match algorithm_version { + 0 => DISTANCE_TABLE_SIZE_50, + 1 => DISTANCE_TABLE_SIZE_70, + _ => { + return Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version", + )) + } + }; + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; distance_size], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + let present = literal_presence(data); + let literal_count = present.iter().filter(|&&used| used).count(); + let literal_length = huffman::bits_for_symbol_count(literal_count); + let mut literal_codes = [0u16; 256]; + let mut next_code = 0u16; + for (symbol, used) in present.into_iter().enumerate() { + if used { + lengths.main[symbol] = literal_length; + // Every literal has the same length, so canonical order is simply + // the order of the present byte values. + literal_codes[symbol] = next_code; + next_code += 1; + } + } + + // The version, table sizes and generated lengths are all fixed above; + // malformed-table errors remain available on the public table encoder. + let (table_data, table_bits) = encode_table_lengths_with_bit_count(&lengths, algorithm_version) + .expect("generated literal table is valid"); + let mut writer = BitWriter { + bytes: Buffer::from_vec(table_data), + bit_pos: table_bits, + }; + for &byte in data { + writer.write_bits( + usize::from(literal_codes[byte as usize]), + usize::from(literal_length), + ); + } + let payload_bits = writer.bit_pos; + encode_compressed_block(&writer.finish(), payload_bits, true, true) +} + +pub fn encode_lz_member(data: &[u8], algorithm_version: u8) -> Result> { + encode_lz_member_with_history(data, &[], algorithm_version) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct EncodeOptions { + pub max_match_candidates: usize, + pub lazy_matching: bool, + pub lazy_lookahead: usize, + pub max_match_distance: usize, + pub optimal_parse: bool, +} + +impl EncodeOptions { + pub const fn new(max_match_candidates: usize) -> Self { + Self { + max_match_candidates, + lazy_matching: false, + lazy_lookahead: 1, + max_match_distance: MAX_ENCODER_MATCH_OFFSET, + optimal_parse: false, + } + } + + pub const fn with_optimal_parse(mut self, enabled: bool) -> Self { + self.optimal_parse = enabled; + self + } + + pub const fn with_lazy_matching(mut self, enabled: bool) -> Self { + self.lazy_matching = enabled; + self + } + + pub const fn with_lazy_lookahead(mut self, bytes: usize) -> Self { + self.lazy_lookahead = bytes; + self + } + + pub const fn with_max_match_distance(mut self, distance: usize) -> Self { + self.max_match_distance = distance; + self + } +} + +impl Default for EncodeOptions { + fn default() -> Self { + Self::new(MAX_MATCH_CANDIDATES) + } +} + +pub fn encode_lz_member_with_history( + data: &[u8], + history: &[u8], + algorithm_version: u8, +) -> Result> { + encode_lz_member_inner( + data, + history, + algorithm_version, + EncodeOptions::default(), + None, + ) +} + +pub fn encode_lz_member_with_options( + data: &[u8], + algorithm_version: u8, + options: EncodeOptions, +) -> Result> { + encode_lz_member_with_history_and_options(data, &[], algorithm_version, options) +} + +#[cfg(test)] +pub(crate) fn encode_lz_member_with_options_and_progress( + data: &[u8], + algorithm_version: u8, + options: EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + encode_lz_member_inner(data, &[], algorithm_version, options, Some(progress)) +} + +#[cfg(test)] +pub(crate) fn encode_lz_reader_to( + reader: &mut dyn Read, + input_size: u64, + output: &mut dyn Write, + algorithm_version: u8, + options: EncodeOptions, + block_size: usize, + progress: Option<&mut dyn FnMut(u64) -> bool>, +) -> crate::Result<()> { + reader_to_with_allowance( + reader, + input_size, + output, + algorithm_version, + options, + block_size, + progress, + &Allowance::default(), + ) +} + +#[cfg(test)] +#[allow(clippy::too_many_arguments)] +fn reader_to_with_allowance( + reader: &mut dyn Read, + input_size: u64, + output: &mut dyn Write, + algorithm_version: u8, + options: EncodeOptions, + block_size: usize, + mut progress: Option<&mut dyn FnMut(u64) -> bool>, + allowance: &B, +) -> crate::Result<()> { + if block_size == 0 { + return Err(crate::Error::InvalidHeader( + "RAR 5 streaming block size is zero", + )); + } + let block_size = block_size.min(MAX_COMPRESSED_BLOCK_OUTPUT); + let mut history = Buffer::new(allowance); + let mut chunk = Buffer::filled(input_size.min(block_size as u64) as usize, 0u8, allowance)?; + let mut block = Buffer::new(allowance); + let mut remaining = input_size; + let mut completed = 0u64; + let mut held: Option> = None; + while remaining != 0 || held.is_some() { + // One chunk, then further chunks while the data is not moving, which is + // the cut [`BlockSplitter`] makes for the other two writers. Deciding + // needs the chunk in hand, so the one that ends a block is held over. + let mut splitter = BlockSplitter::new(); + block.clear(); + match held.take() { + Some(first) => block + .extend_from_slice(&first) + .map_err(Into::::into)?, + None => { + let wanted = usize::try_from(remaining.min(block_size as u64)) + .map_err(|_| crate::Error::InvalidHeader("RAR 5 block size overflows usize"))?; + reader.read_exact(&mut chunk[..wanted])?; + remaining -= wanted as u64; + block + .extend_from_slice(&chunk[..wanted]) + .map_err(Into::::into)?; + } + } + splitter.accept(&block); + while remaining != 0 { + let wanted = usize::try_from(remaining.min(block_size as u64)) + .map_err(|_| crate::Error::InvalidHeader("RAR 5 block size overflows usize"))?; + reader.read_exact(&mut chunk[..wanted])?; + remaining -= wanted as u64; + if !splitter.try_extend(&chunk[..wanted]) { + held = Some(Buffer::copied(&chunk[..wanted], allowance)?); + break; + } + block + .extend_from_slice(&chunk[..wanted]) + .map_err(Into::::into)?; + } + let (window, start) = member_window_with_allowance(&block, &history, options, allowance)?; + let packed = encode_lz_block_with_allowance( + &window, + start..window.len(), + MemberSearch::Fresh, + algorithm_version, + &[], + options, + remaining == 0 && held.is_none(), + None, + allowance, + )?; + drop(window); + output.write_all(&packed)?; + history.remember(&block, options.max_match_distance)?; + completed += block.len() as u64; + if progress + .as_deref_mut() + .is_some_and(|report| !report(completed)) + { + return Err(crate::Error::Cancelled); + } + } + let mut trailing = [0u8; 1]; + if reader.read(&mut trailing)? != 0 { + return Err(crate::Error::InvalidHeader( + "entry source size changed while compressing", + )); + } + Ok(()) +} + +#[cfg(test)] +pub(crate) fn encode_lz_streaming_block( + data: &[u8], + history: &[u8], + algorithm_version: u8, + options: EncodeOptions, + is_last: bool, +) -> Result> { + encode_lz_block( + data, + history, + algorithm_version, + &[], + options, + is_last, + None, + ) +} + +/// Encode adjacent streaming blocks with one seeded chain finder. The first +/// block without history keeps its existing tree parse; subsequent blocks use +/// chains just as separately seeded streaming blocks do. +#[cfg(test)] +pub(crate) fn encode_lz_streaming_blocks( + data: &[u8], + history: &[u8], + blocks: &[(usize, bool)], + algorithm_version: u8, + options: EncodeOptions, + block_done: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result>> { + streaming_blocks_with_allowance( + data, + history, + blocks, + algorithm_version, + options, + block_done, + &Allowance::default(), + ) + .map(|outputs| outputs.into_iter().map(Buffer::into_vec).collect()) +} + +pub(crate) fn streaming_blocks_with_allowance( + data: &[u8], + history: &[u8], + blocks: &[(usize, bool)], + algorithm_version: u8, + options: EncodeOptions, + mut block_done: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result, B>> { + let mut previous = 0; + for &(end, _) in blocks { + if end <= previous || end > data.len() { + return Err(Error::InvalidData("RAR 5 streaming block range is invalid")); + } + previous = end; + } + if previous != data.len() { + return Err(Error::InvalidData( + "RAR 5 streaming blocks do not cover input", + )); + } + let (combined, start) = member_window_with_allowance(data, history, options, allowance)?; + + let mut at = start; + let mut output = Buffer::with_capacity(blocks.len(), allowance)?; + let mut first = 0; + // Block ends are offsets into `data`, so the bytes a block covers are the + // step from the end before it. Reporting them as they land is what keeps a + // progress bar moving: a whole member can be one run, and a run that + // reports only when it finishes reports nothing until it is done. + let mut reported = 0usize; + let mut report = |end: usize, block_done: &mut Option<&mut dyn FnMut(usize) -> bool>| { + let delta = end - reported; + reported = end; + match block_done { + Some(report) => report(delta), + None => true, + } + }; + if start == 0 && options.optimal_parse && !blocks.is_empty() { + let (end, is_last) = blocks[0]; + output.push_admitted(encode_lz_block_with_allowance( + &combined[..end], + 0..end, + MemberSearch::Fresh, + algorithm_version, + &[], + options, + is_last, + None, + allowance, + )?); + at = end; + first = 1; + if !report(end, &mut block_done) { + return Err(Error::Cancelled); + } + } + if first == blocks.len() { + return Ok(output); + } + let finder = member_finder_with_allowance(&combined, at, options, allowance)?; + let mut search = if options.optimal_parse { + SharedMemberSearch::Optimal(OptimalCollector { + finder: CollectorFinder::Chains(finder), + }) + } else { + SharedMemberSearch::Lazy(finder) + }; + for &(end, is_last) in &blocks[first..] { + let end = start + end; + output.push_admitted(encode_lz_block_with_allowance( + &combined, + at..end, + search.borrow(), + algorithm_version, + &[], + options, + is_last, + None, + allowance, + )?); + at = end; + if !report(end - start, &mut block_done) { + return Err(Error::Cancelled); + } + } + Ok(output) +} + +pub fn encode_lz_member_with_history_and_options( + data: &[u8], + history: &[u8], + algorithm_version: u8, + options: EncodeOptions, +) -> Result> { + encode_lz_member_inner(data, history, algorithm_version, options, None) +} + +/// The writer rejects these before compressing anything, so reaching this is +/// either a direct `codec` caller or a bug. Either way the codec stays total. +fn rar50_filter(kind: crate::FilterKind) -> Result { + Rar50Filter::try_from(kind) + .map_err(|_| Error::InvalidData("RAR 5 has no builtin type for this filter")) +} + +/// Applies `filters` to a copy of `data`, returning the transformed bytes and +/// the records that describe them. +#[cfg(test)] +pub(crate) fn filtered_lz_member( + data: &[u8], + filters: &[crate::FilterSpec], +) -> Result<(Vec, Vec)> { + filtered_member_with_allowance(data, filters, &Allowance::default()) + .map(|(data, records)| (data.into_vec(), records.into_vec())) +} + +fn filtered_member_with_allowance( + data: &[u8], + filters: &[crate::FilterSpec], + allowance: &B, +) -> Result<(Buffer, Buffer)> { + let mut filtered = Buffer::copied(data, allowance)?; + let mut records = Buffer::with_capacity(filters.len(), allowance)?; + for filter in filters { + let range = filter.range.clone().unwrap_or(0..data.len()); + if range.start >= range.end || range.end > data.len() { + return Err(Error::InvalidData("RAR 5 filter range is invalid")); + } + let filter_data = &mut filtered[range.clone()]; + let (filter_type, channels) = encode_filter_data( + rar50_filter(filter.kind)?, + filter_data, + range.start, + allowance, + )?; + records.push_admitted(EncodeFilter { + offset: range.start, + length: range.len(), + filter_type, + channels, + }); + } + Ok((filtered, records)) +} + +fn encode_filter_data( + kind: Rar50Filter, + data: &mut [u8], + file_offset: usize, + allowance: &B, +) -> Result<(FilterType, usize)> { + if file_offset > u32::MAX as usize { + return Err(Error::InvalidData("RAR 5 filter offset is too large")); + } + match kind { + Rar50Filter::Delta { channels } => { + let transformed = filters::delta_encode_with_allowance( + data, + channels, + rar50_delta_messages(), + allowance, + )?; + data.copy_from_slice(&transformed); + Ok((FilterType::Delta, channels)) + } + Rar50Filter::E8 => { + e8e9_encode(data, file_offset as u32, false); + Ok((FilterType::E8, 0)) + } + Rar50Filter::E8E9 => { + e8e9_encode(data, file_offset as u32, true); + Ok((FilterType::E8E9, 0)) + } + Rar50Filter::Arm => { + arm_encode(data, file_offset as u32); + Ok((FilterType::Arm, 0)) + } + } +} + +/// Transforms the member and cuts it into the blocks a filter record can +/// describe, then compresses those blocks against one search state. +/// +/// The transform runs first and over the whole member, because the search has +/// to read final bytes: a block reaches back into the ones before it, and a +/// match must point at what the decoder will really have. Each block still +/// gets its own records covering only its own bytes, so a filtered range +/// spanning several blocks converts exactly as it did when each block was +/// transformed alone: the transform reads an absolute file offset, which the +/// cut does not change. +/// +/// Blocks used to be compressed one at a time, each against a fresh copy of +/// the history behind it and a finder rebuilt from that copy. That is the +/// cost [`encode_lz_member_inner`] took off the unfiltered path and left +/// here: at 64 KiB a block, a four-megabyte member re-copied and re-inserted +/// 126 MiB of history, thirty-one times what it holds. +fn filtered_lz_blocks( + data: &[u8], + filters: &[crate::FilterSpec], + history: &[u8], + algorithm_version: u8, + options: EncodeOptions, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let filters = normalized_filter_specs(data.len(), filters, allowance)?; + let history = &history[history.len().saturating_sub(options.max_match_distance)..]; + let start = history.len(); + let mut combined = Buffer::from_slices(&[history, data], allowance)?; + + let mut blocks = Buffer::new(allowance); + let mut chunk_start = 0usize; + while chunk_start < data.len() { + let chunk_end = (chunk_start + FILTERED_LZ_BLOCK_SIZE).min(data.len()); + let mut records = Buffer::new(allowance); + for filter in filters.iter() { + let filter_start = filter.range.start.max(chunk_start); + let filter_end = filter.range.end.min(chunk_end); + if filter_start >= filter_end { + continue; + } + let (filter_type, channels) = encode_filter_data( + filter.kind, + &mut combined[start + filter_start..start + filter_end], + filter_start, + allowance, + )?; + records + .push(EncodeFilter { + offset: filter_start - chunk_start, + length: filter_end - filter_start, + filter_type, + channels, + }) + .map_err(Into::into)?; + } + blocks + .push((chunk_start..chunk_end, records)) + .map_err(Into::into)?; + chunk_start = chunk_end; + } + + // One search state for the whole member, as the unfiltered path has. + let mut search = if options.optimal_parse { + SharedMemberSearch::Optimal(OptimalCollector::with_allowance( + &combined, start, options, allowance, + )?) + } else { + SharedMemberSearch::Lazy(member_finder_with_allowance( + &combined, start, options, allowance, + )?) + }; + + let mut out = Buffer::new(allowance); + for (block, records) in blocks { + let mut chunk_progress = |position: usize| { + progress + .as_deref_mut() + .is_none_or(|report| report(block.start.saturating_add(position))) + }; + let packed = encode_lz_block_with_allowance( + &combined, + start + block.start..start + block.end, + search.borrow(), + algorithm_version, + &records, + options, + block.end == data.len(), + Some(&mut chunk_progress), + allowance, + )?; + out.extend_from_slice(&packed).map_err(Into::into)?; + } + Ok(out) +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct NormalizedFilterSpec { + kind: Rar50Filter, + range: Range, +} + +fn normalized_filter_specs( + data_len: usize, + filters: &[crate::FilterSpec], + allowance: &B, +) -> Result> { + let mut normalized = Buffer::with_capacity(filters.len(), allowance)?; + for filter in filters { + let range = filter.range.clone().unwrap_or(0..data_len); + if range.start >= range.end || range.end > data_len { + return Err(Error::InvalidData("RAR 5 filter range is invalid")); + } + normalized.push_admitted(NormalizedFilterSpec { + kind: rar50_filter(filter.kind)?, + range, + }); + } + Ok(normalized) +} + +fn encode_lz_member_inner( + data: &[u8], + history: &[u8], + algorithm_version: u8, + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + encode_member_with_allowance( + data, + history, + algorithm_version, + options, + progress, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} + +pub(crate) fn encode_owned_member( + data: &[u8], + version: u8, + options: EncodeOptions, + filters: Option<&[crate::FilterSpec]>, + progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + match filters { + None => encode_member_with_allowance(data, &[], version, options, progress, allowance), + Some(filters) => { + EncoderState::new(options, allowance).encode(data, version, Some(filters), progress) + } + } +} + +pub(crate) fn filtered_owned_member( + data: &[u8], + filters: &[crate::FilterSpec], + allowance: &B, +) -> Result> { + filtered_member_with_allowance(data, filters, allowance).map(|(bytes, _)| bytes) +} + +fn encode_member_with_allowance( + data: &[u8], + history: &[u8], + algorithm_version: u8, + options: EncodeOptions, + mut progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let (window, start) = member_window_with_allowance(data, history, options, allowance)?; + let combined = &*window; + if data.len() > LZ_BLOCK_SIZE { + // One search state for the whole member. It used to be built per + // block, which meant rehashing a window of history every 64 KiB: on a + // 16 MiB member that was half the encode. The optimal parse used to be + // worse still, rebuilding per pass; its collector searches each block + // once and lets the passes replay the answers. + let mut search = if options.optimal_parse { + SharedMemberSearch::Optimal(OptimalCollector::with_allowance( + combined, start, options, allowance, + )?) + } else { + SharedMemberSearch::Lazy(member_finder_with_allowance( + combined, start, options, allowance, + )?) + }; + + let mut out = Buffer::new(allowance); + let mut completed = 0usize; + let mut block_start = start; + let mut splitter = BlockSplitter::new(); + while block_start < combined.len() { + // Take one chunk, then keep taking them while the data is not + // moving. See [`BlockSplitter`]. + splitter.reset(); + let mut block_end = (block_start + LZ_BLOCK_SIZE).min(combined.len()); + splitter.accept(&combined[block_start..block_end]); + while block_end < combined.len() { + let next_end = (block_end + LZ_BLOCK_SIZE).min(combined.len()); + let next = &combined[block_end..next_end]; + if !splitter.try_extend(next) { + break; + } + block_end = next_end; + } + let is_last = block_end == combined.len(); + let mut chunk_progress = |position: usize| { + progress + .as_deref_mut() + .is_none_or(|report| report(completed.saturating_add(position))) + }; + let packed = encode_lz_block_with_allowance( + combined, + block_start..block_end, + search.borrow(), + algorithm_version, + &[], + options, + is_last, + Some(&mut chunk_progress), + allowance, + )?; + out.extend_from_slice(&packed).map_err(Into::into)?; + completed = completed.saturating_add(block_end - block_start); + block_start = block_end; + } + return Ok(out); + } + encode_lz_block_with_allowance( + combined, + start..combined.len(), + MemberSearch::Fresh, + algorithm_version, + &[], + options, + true, + progress, + allowance, + ) +} + +#[allow(clippy::too_many_arguments)] +fn encode_filtered_member_with_allowance( + data: &[u8], + history: &[u8], + algorithm_version: u8, + filters: &[EncodeFilter], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let (window, start) = member_window_with_allowance(data, history, options, allowance)?; + let end = window.len(); + encode_lz_block_with_allowance( + &window, + start..end, + MemberSearch::Fresh, + algorithm_version, + filters, + options, + true, + progress, + allowance, + ) +} + +/// How far back a parse over `reach` bytes has to remember. +/// +/// Nothing further than the maximum distance is ever accepted as a match, so a +/// link to anything older can be dropped. Neither can a match reach back past +/// the start of what is being parsed, so a member shorter than the dictionary +/// sets the window instead: asking for `--dict-size 32m` on a one-megabyte +/// member should not reserve thirty-two megabytes of links that can never name +/// a position. +fn finder_window(options: EncodeOptions, reach: usize) -> usize { + options.max_match_distance.min(reach).max(LZ_BLOCK_SIZE) +} + +/// A finder for the whole member, seeded with the history it carries in. It +/// keeps growing as the blocks are parsed, so it is sized to the widest window +/// the member could ever want rather than to any one block. +fn member_finder_with_allowance( + combined: &[u8], + start: usize, + options: EncodeOptions, + allowance: &B, +) -> Result> { + let mut finder = + Rar50MatchFinder::with_allowance(finder_window(options, combined.len()), allowance)?; + for pos in 0..start { + finder.insert(combined, pos); + } + Ok(finder) +} + +/// A finder holding everything a parse of `block` may reach back to, and +/// nothing older. +fn seeded_finder( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + allowance: &B, +) -> Result> { + // Sized to what this block can actually reach, not to the maximum distance, + // so the first blocks of a member do not clear a window the data is not yet + // long enough to fill. + let behind = block.start.min(options.max_match_distance); + let mut finder = + Rar50MatchFinder::with_allowance(behind + (block.end - block.start), allowance)?; + for pos in block.start - behind..block.start { + finder.insert(combined, pos); + } + Ok(finder) +} + +/// The search state a member shares across its blocks, when it has any. +enum MemberSearch<'a, B: Budget = Allowance> { + /// Nothing shared: the block builds what it needs and drops it. + Fresh, + /// The member's chain finder, which the lazy path feeds block by block. + Lazy(&'a mut Rar50MatchFinder), + /// The member's match collector, which the optimal parse feeds block by + /// block. + Optimal(&'a mut OptimalCollector), +} + +enum SharedMemberSearch { + Lazy(Rar50MatchFinder), + Optimal(OptimalCollector), +} + +impl SharedMemberSearch { + fn borrow(&mut self) -> MemberSearch<'_, B> { + match self { + Self::Lazy(finder) => MemberSearch::Lazy(finder), + Self::Optimal(collector) => MemberSearch::Optimal(collector), + } + } +} + +/// The matches at every position of one block, found once and priced by every +/// pass of the optimal parse. The runs at one position carry strictly +/// increasing lengths and distances, so each is the nearest distance found +/// that reaches its length. +/// +/// One position holds at most one run per length it can reach, so the whole +/// block is bounded by the block size times [`NICE_MATCH_LENGTH`]. Nothing +/// approaches that: the worst measured is about six runs per position, on a +/// mebibyte of two-symbol noise, where every position has many candidates whose +/// lengths creep up one byte at a time. That block cost three megabytes. +struct BlockMatches { + /// Every position's runs, one position after another. + runs: Buffer<(u32, u32), B>, + /// Where each position's runs start in `runs`, with one extra entry to + /// close the last position. + starts: Buffer, +} + +/// One match finder for a member's whole optimal parse, and the walk that asks +/// it about each block once. +/// +/// The parse prices each block [`OPTIMAL_PARSE_PASSES`] times, but nothing the +/// finder answers depends on the prices, so it used to be asked the same +/// questions once per pass, through a finder rebuilt and reseeded once per +/// pass. Collecting the answers first and replaying them lets every pass after +/// the first skip the finder entirely. +/// +/// Searching once is also what makes the tree finder affordable, and the tree +/// is where the speed is: pricing every position means searching at every +/// position, which is the load a chain walk carries worst and a tree carries +/// best. A member that starts with no history gets the tree. One that carries +/// history keeps the chains, because the only way into a tree is a descent per +/// position, and paying that across a dictionary of history would cost more +/// than the chains ever did. +struct OptimalCollector { + finder: CollectorFinder, +} + +enum CollectorFinder { + Tree(match_finder::TreeMatchFinder), + Chains(Rar50MatchFinder), +} + +impl OptimalCollector { + #[cfg(test)] + fn new(combined: &[u8], start: usize, options: EncodeOptions) -> Self { + Self::with_allowance(combined, start, options, &Allowance::default()) + .expect("unlimited collector allocation") + } +} + +impl OptimalCollector { + fn with_allowance( + combined: &[u8], + start: usize, + options: EncodeOptions, + allowance: &B, + ) -> Result { + let finder = if start == 0 { + CollectorFinder::Tree(match_finder::TreeMatchFinder::with_allowance( + finder_window(options, combined.len()), + allowance, + )?) + } else { + CollectorFinder::Chains(member_finder_with_allowance( + combined, start, options, allowance, + )?) + }; + Ok(Self { finder }) + } + + /// Finds the matches the parse will price at each position of `block`, + /// taking the positions into the finder as it goes. Blocks must arrive in + /// order, each exactly once, the same discipline the member's shared chain + /// finder already asks of the lazy path. + /// + /// Searching stops where the parse stops pricing. A match that reaches + /// [`NICE_MATCH_LENGTH`] is one the parse commits to and steps over, so the + /// positions it covers are not searched from either. Skipping the pricing + /// alone would have left the search doing all the work it used to: on a + /// mebibyte that repeats, one search per 4 KiB became a million. + fn collect( + &mut self, + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + ) -> Result> { + let allowance = match &self.finder { + CollectorFinder::Tree(finder) => finder.allowance(), + CollectorFinder::Chains(finder) => finder.allowance(), + }; + let span = block.end - block.start; + let mut matches = BlockMatches { + // One run per position to start with, which is where data that + // matches at all lands, so the common case grows this once. + runs: Buffer::with_capacity(span, &allowance)?, + starts: Buffer::with_capacity(span + 1, &allowance)?, + }; + // The first position past a match the parse will commit to. The parse + // reaches the same decision from the same lengths, so the two agree on + // which positions matter without having to be told. + let mut committed_through = block.start; + for pos in block.clone() { + matches.starts.push_admitted(matches.runs.len() as u32); + let searching = pos >= committed_through && options.max_match_candidates != 0; + let max_distance = pos.min(options.max_match_distance); + let before = matches.runs.len(); + match &mut self.finder { + CollectorFinder::Tree(tree) => { + // Inserting into a tree is the same descent as searching + // it, so a position the parse steps over is stepped over + // here too rather than inserted for nothing. Its bytes are + // a copy of what the match already points at, so the tree + // loses little by not holding them. + let avail = combined.len() - pos; + if !searching || avail < 4 { + continue; + } + // Compares stop where the parse stops caring about better + // alternatives. A match that reaches that far is measured + // out to its real end, which is the length the parse + // commits to and steps over. + let len_limit = avail.min(NICE_MATCH_LENGTH); + tree.matches( + combined, + pos, + len_limit, + max_distance, + options.max_match_candidates, + &mut matches.runs, + ) + .map_err(Into::into)?; + if let Some(last) = matches.runs[before..].last_mut() { + let limit = avail.min(MAX_ENCODER_MATCH_LENGTH); + if last.0 as usize == len_limit && len_limit < limit { + last.0 = match_length(combined, pos, last.1 as usize, limit) as u32; + } + } + } + CollectorFinder::Chains(finder) => { + // Inserting into a chain is one store, so every position + // goes in whether or not it is searched from. That keeps a + // solid member's candidates exactly what they were. + finder.insert(combined, pos); + let max_length = (block.end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if !searching || max_distance == 0 || max_length < 4 { + continue; + } + // The chain walks nearest first, so the first distance to + // reach a length is the cheapest one that can. + let mut longest = 0usize; + let mut checked = 0usize; + let mut candidate = finder.first(combined, pos); + while candidate != match_finder::NO_POSITION + && longest < max_length + && longest < NICE_MATCH_LENGTH + { + if candidate >= pos { + candidate = finder.previous(candidate); + continue; + } + let distance = pos - candidate; + if distance > max_distance { + break; + } + checked += 1; + if combined[candidate + longest] == combined[pos + longest] { + let length = match_length(combined, pos, distance, max_length); + if length > longest { + matches + .runs + .push((length as u32, distance as u32)) + .map_err(Into::into)?; + longest = length; + } + } + if checked >= options.max_match_candidates { + break; + } + candidate = finder.previous(candidate); + } + } + } + // The parse can only take a match the block still has room for, so + // the reach it will commit to is measured the way it measures it. + if let Some(&(length, _)) = matches.runs[before..].last() { + let reach = (length as usize) + .min(block.end - pos) + .min(MAX_ENCODER_MATCH_LENGTH); + if reach >= NICE_MATCH_LENGTH { + committed_through = pos + reach; + } + } + } + matches.starts.push_admitted(matches.runs.len() as u32); + Ok(matches) + } +} + +/// The bytes one member's parse reaches across, and where its own data starts. +/// +/// A member with no history to carry borrows its own data rather than copying +/// it, which is every member of a non-solid archive. +enum MemberWindow<'a, B: Budget> { + Borrowed(&'a [u8]), + Owned(Buffer), +} + +impl std::ops::Deref for MemberWindow<'_, B> { + type Target = [u8]; + fn deref(&self) -> &[u8] { + match self { + Self::Borrowed(data) => data, + Self::Owned(data) => data, + } + } +} + +fn member_window_with_allowance<'a, B: Budget>( + data: &'a [u8], + history: &[u8], + options: EncodeOptions, + allowance: &B, +) -> Result<(MemberWindow<'a, B>, usize)> { + let history = &history[history.len().saturating_sub(options.max_match_distance)..]; + if history.is_empty() { + return Ok((MemberWindow::Borrowed(data), 0)); + } + let combined = Buffer::from_slices(&[history, data], allowance)?; + Ok((MemberWindow::Owned(combined), history.len())) +} + +/// One block, with its own history and its own finder. The member path shares +/// a finder across blocks instead; this is for the callers that encode a block +/// on its own, which are the filtered path and the tests. +#[cfg(test)] +fn encode_lz_block( + data: &[u8], + history: &[u8], + algorithm_version: u8, + initial_filters: &[EncodeFilter], + options: EncodeOptions, + is_last: bool, + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let (combined, start) = + member_window_with_allowance(data, history, options, &Allowance::default())?; + encode_lz_block_in_window( + &combined, + start..combined.len(), + MemberSearch::Fresh, + algorithm_version, + initial_filters, + options, + is_last, + progress, + ) +} + +#[allow(clippy::too_many_arguments)] +#[cfg(test)] +fn encode_lz_block_in_window( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_>, + algorithm_version: u8, + initial_filters: &[EncodeFilter], + options: EncodeOptions, + is_last: bool, + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let allowance = match &search { + MemberSearch::Fresh => Allowance::default(), + MemberSearch::Lazy(finder) => finder.allowance(), + MemberSearch::Optimal(collector) => match &collector.finder { + CollectorFinder::Tree(finder) => finder.allowance(), + CollectorFinder::Chains(finder) => finder.allowance(), + }, + }; + encode_lz_block_with_allowance( + combined, + block, + search, + algorithm_version, + initial_filters, + options, + is_last, + progress, + &allowance, + ) + .map(Buffer::into_vec) +} + +#[allow(clippy::too_many_arguments)] +fn encode_lz_block_with_allowance( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_, B>, + algorithm_version: u8, + initial_filters: &[EncodeFilter], + options: EncodeOptions, + is_last: bool, + progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let distance_size = match algorithm_version { + 0 => DISTANCE_TABLE_SIZE_50, + 1 => DISTANCE_TABLE_SIZE_70, + _ => { + return Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version", + )) + } + }; + let mut tokens = encode_tokens_with_allowance( + combined, + block, + search, + options, + distance_size, + initial_filters, + progress, + allowance, + )?; + if !initial_filters.is_empty() { + tokens.prepend(initial_filters.iter().copied().map(EncodeToken::Filter))?; + } + encode_token_block_with_allowance( + &tokens, + algorithm_version, + distance_size, + is_last, + allowance, + ) +} + +#[cfg(test)] +fn encode_token_block( + tokens: &[EncodeToken], + algorithm_version: u8, + distance_size: usize, + is_last: bool, +) -> Result> { + encode_token_block_with_allowance( + tokens, + algorithm_version, + distance_size, + is_last, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} + +fn encode_token_block_with_allowance( + tokens: &[EncodeToken], + algorithm_version: u8, + distance_size: usize, + is_last: bool, + allowance: &B, +) -> Result> { + let lengths = table_lengths_with_allowance(tokens, &[], distance_size, allowance)?; + + let main_table = EncoderCodeTable::from_lengths(&lengths.main, allowance)?; + let distance_table = EncoderCodeTable::from_lengths(&lengths.distance, allowance)?; + let align_table = EncoderCodeTable::from_lengths(&lengths.align, allowance)?; + let length_table = EncoderCodeTable::from_lengths(&lengths.length, allowance)?; + let (table_data, table_bits) = + encode_table_slices(lengths.slices(), algorithm_version, allowance)?; + let payload_bits = + token_stream_bits_after_tables(tokens, &[], &lengths, distance_size, table_bits)?; + let mut writer = BitWriter { + bytes: table_data, + bit_pos: table_bits, + }; + writer + .bytes + .reserve_total_capacity(payload_bits.div_ceil(8))?; + let mut state = EncoderMatchState::default(); + for &token in tokens { + match token { + EncodeToken::Filter(filter) => { + let (code, len) = main_table.code_for_present_symbol(256); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + // token_stream_bits_after_tables validated this same record + // before its exact payload allocation was admitted. + write_valid_filter(&mut writer, filter); + } + EncodeToken::Literal(byte) => { + let (code, len) = main_table.code_for_present_symbol(byte as usize); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + } + EncodeToken::Match { length, distance } => { + match state.encode_valid_match(length, distance, distance_size) { + EncodedMatch::LastLengthRepeat => { + let (code, len) = main_table.code_for_present_symbol(257); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + } + EncodedMatch::RepeatDistance { + index, + length_slot, + length_extra, + } => { + let (code, len) = main_table.code_for_present_symbol(258 + index); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + let (code, len) = length_table.code_for_present_symbol(length_slot); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + let length_extra_bits = length_slot_extra_bits(length_slot); + if length_extra_bits != 0 { + writer + .write_admitted_bits(length_extra, usize::from(length_extra_bits)); + } + } + EncodedMatch::New { + length_slot, + length_extra, + distance_slot, + distance_extra, + distance_bit_count, + } => { + let (code, len) = main_table.code_for_present_symbol(262 + length_slot); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + let length_extra_bits = length_slot_extra_bits(length_slot); + if length_extra_bits != 0 { + writer + .write_admitted_bits(length_extra, usize::from(length_extra_bits)); + } + let (code, len) = distance_table.code_for_present_symbol(distance_slot); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + if distance_bit_count >= 4 { + if distance_bit_count > 4 { + writer.write_admitted_bits( + distance_extra >> 4, + distance_bit_count - 4, + ); + } + let (code, len) = + align_table.code_for_present_symbol(distance_extra & 0x0f); + writer.write_admitted_bits(usize::from(code), usize::from(len)); + } else if distance_bit_count != 0 { + writer.write_admitted_bits(distance_extra, distance_bit_count); + } + } + } + state.remember(length, distance); + } + } + } + + debug_assert_eq!(writer.bit_pos, payload_bits); + encode_compressed_block_with_allowance(&writer.bytes, payload_bits, true, is_last, allowance) +} + +#[derive(Debug)] +struct EncoderState { + history: Buffer, + options: EncodeOptions, +} + +impl EncoderState { + fn new(options: EncodeOptions, allowance: &B) -> Self { + Self { + history: Buffer::new(allowance), + options, + } + } + fn encode( + &mut self, + input: &[u8], + version: u8, + filters: Option<&[crate::FilterSpec]>, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + let allowance = self.history.allowance(); + let packed = match filters { + None => encode_member_with_allowance( + input, + &self.history, + version, + self.options, + progress, + &allowance, + )?, + Some(filters) if input.len() > FILTERED_LZ_BLOCK_SIZE => filtered_lz_blocks( + input, + filters, + &self.history, + version, + self.options, + progress, + &allowance, + )?, + Some(filters) => { + let (filtered, records) = + filtered_member_with_allowance(input, filters, &allowance)?; + encode_filtered_member_with_allowance( + &filtered, + &self.history, + version, + &records, + self.options, + progress, + &allowance, + )? + } + }; + // Commit history only after the encode and its callback succeed. The + // packed result remains charged while any history growth is admitted. + self.history + .remember(input, self.options.max_match_distance)?; + Ok(packed) + } +} + +#[derive(Debug)] +pub struct Unpack50Encoder { + state: EncoderState, +} + +impl Clone for Unpack50Encoder { + fn clone(&self) -> Self { + Self { + state: EncoderState { + history: Buffer::from_vec(self.state.history.to_vec()), + options: self.state.options, + }, + } + } +} + +impl Default for Unpack50Encoder { + fn default() -> Self { + Self::with_options(EncodeOptions::default()) + } +} + +impl Unpack50Encoder { + pub fn new() -> Self { + Self::default() + } + pub fn with_options(options: EncodeOptions) -> Self { + Self { + state: EncoderState::new(options, &Allowance::default()), + } + } + pub fn encode_member(&mut self, input: &[u8], algorithm_version: u8) -> Result> { + self.state + .encode(input, algorithm_version, None, None) + .map(Buffer::into_vec) + } + pub fn encode_member_with_filter( + &mut self, + input: &[u8], + algorithm_version: u8, + filter: crate::FilterSpec, + ) -> Result> { + self.encode_member_with_filters(input, algorithm_version, &[filter]) + } + pub fn encode_member_with_filters( + &mut self, + input: &[u8], + algorithm_version: u8, + filters: &[crate::FilterSpec], + ) -> Result> { + self.state + .encode(input, algorithm_version, Some(filters), None) + .map(Buffer::into_vec) + } + #[cfg(test)] + pub(crate) fn encode_member_with_filters_and_progress( + &mut self, + input: &[u8], + algorithm_version: u8, + filters: &[crate::FilterSpec], + progress: &mut dyn FnMut(usize) -> bool, + ) -> Result> { + self.state + .encode(input, algorithm_version, Some(filters), Some(progress)) + .map(Buffer::into_vec) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum EncodeToken { + Filter(EncodeFilter), + Literal(u8), + Match { length: usize, distance: usize }, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct EncodeFilter { + offset: usize, + length: usize, + filter_type: FilterType, + channels: usize, +} + +#[derive(Debug, Clone, Copy, Default)] +struct EncoderMatchState { + reps: [usize; 4], + last_length: usize, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum EncodedMatch { + LastLengthRepeat, + RepeatDistance { + index: usize, + length_slot: usize, + length_extra: usize, + }, + New { + length_slot: usize, + length_extra: usize, + distance_slot: usize, + distance_extra: usize, + distance_bit_count: usize, + }, +} + +impl EncoderMatchState { + fn encode_match( + &self, + length: usize, + distance: usize, + distance_size: usize, + ) -> Result { + if distance == self.reps[0] && length == self.last_length { + return Ok(EncodedMatch::LastLengthRepeat); + } + if let Some(index) = self + .reps + .iter() + .position(|&repeat_distance| repeat_distance == distance && repeat_distance != 0) + { + let (length_slot, length_extra) = length_slot_for_match(length)?; + return Ok(EncodedMatch::RepeatDistance { + index, + length_slot, + length_extra, + }); + } + + let (distance_slot, distance_extra) = distance_slot_for_match(distance, distance_size)?; + let encoded_length = length + .checked_sub(length_bonus(distance)) + .ok_or(Error::InvalidData("RAR 5 adjusted match length underflows"))?; + let distance_bit_count = distance_slot_bit_count(distance_slot)?; + let (length_slot, length_extra) = length_slot_for_match(encoded_length)?; + Ok(EncodedMatch::New { + length_slot, + length_extra, + distance_slot, + distance_extra, + distance_bit_count, + }) + } + + /// Encode a match after [`table_lengths_with_allowance`] has validated the + /// same immutable token sequence from the same initial state. + fn encode_valid_match( + &self, + length: usize, + distance: usize, + distance_size: usize, + ) -> EncodedMatch { + if distance == self.reps[0] && length == self.last_length { + return EncodedMatch::LastLengthRepeat; + } + if let Some(index) = self + .reps + .iter() + .position(|&repeat_distance| repeat_distance == distance && repeat_distance != 0) + { + let (length_slot, length_extra) = length_slot_for_valid_match(length); + return EncodedMatch::RepeatDistance { + index, + length_slot, + length_extra, + }; + } + + let (distance_slot, distance_extra) = distance_slot_for_valid_match(distance); + debug_assert!(distance_slot < distance_size); + let bonus = length_bonus(distance); + debug_assert!(length >= bonus + 2); + let (length_slot, length_extra) = length_slot_for_valid_match(length - bonus); + EncodedMatch::New { + length_slot, + length_extra, + distance_slot, + distance_extra, + distance_bit_count: distance_slot_bit_count_valid(distance_slot), + } + } + + fn remember(&mut self, length: usize, distance: usize) { + if distance == self.reps[0] && length == self.last_length { + return; + } + if let Some(index) = self + .reps + .iter() + .position(|&repeat_distance| repeat_distance == distance) + { + self.reps[..=index].rotate_right(1); + } else { + self.reps.rotate_right(1); + } + self.reps[0] = distance; + self.last_length = length; + } +} + +/// The Huffman code lengths a block of tokens produces. The block writer needs +/// these to emit the tables; the optimal parse needs them to know what each +/// token it is considering will actually cost. +#[cfg(test)] +fn table_lengths_for_tokens(tokens: &[EncodeToken], distance_size: usize) -> Result { + table_lengths_with_filters(tokens, &[], distance_size) +} + +#[cfg(test)] +fn table_lengths_with_filters( + tokens: &[EncodeToken], + filters: &[EncodeFilter], + distance_size: usize, +) -> Result { + table_lengths_with_allowance(tokens, filters, distance_size, &Allowance::default()) +} + +fn table_lengths_with_allowance( + tokens: &[EncodeToken], + filters: &[EncodeFilter], + distance_size: usize, + allowance: &B, +) -> Result> { + let mut main_frequencies = Buffer::filled(MAIN_TABLE_SIZE, 0usize, allowance)?; + main_frequencies[256] = filters.len(); + let mut distance_frequencies = Buffer::filled(distance_size, 0usize, allowance)?; + let mut align_frequencies = Buffer::filled(ALIGN_TABLE_SIZE, 0usize, allowance)?; + let mut length_frequencies = Buffer::filled(LENGTH_TABLE_SIZE, 0usize, allowance)?; + let mut state = EncoderMatchState::default(); + for token in tokens { + match *token { + EncodeToken::Filter(_) => main_frequencies[256] += 1, + EncodeToken::Literal(byte) => main_frequencies[byte as usize] += 1, + EncodeToken::Match { length, distance } => { + match state.encode_match(length, distance, distance_size)? { + EncodedMatch::LastLengthRepeat => main_frequencies[257] += 1, + EncodedMatch::RepeatDistance { + index, length_slot, .. + } => { + main_frequencies[258 + index] += 1; + length_frequencies[length_slot] += 1; + } + EncodedMatch::New { + length_slot, + distance_slot, + distance_extra, + distance_bit_count, + .. + } => { + main_frequencies[262 + length_slot] += 1; + distance_frequencies[distance_slot] += 1; + if distance_bit_count >= 4 { + align_frequencies[distance_extra & 0x0f] += 1; + } + } + } + state.remember(length, distance); + } + } + } + + Ok(OwnedLengths { + main: huffman::complete_lengths_with_allowance(&main_frequencies, 15, allowance)?, + distance: huffman::complete_lengths_with_allowance(&distance_frequencies, 15, allowance)?, + align: huffman::complete_lengths_with_allowance(&align_frequencies, 15, allowance)?, + length: huffman::complete_lengths_with_allowance(&length_frequencies, 15, allowance)?, + }) +} + +/// Actual payload size, including the transmitted tables and filter records. +/// Padding and block-header size are monotonic in this bit count. +fn token_stream_bits( + tokens: &[EncodeToken], + filters: &[EncodeFilter], + lengths: &OwnedLengths, + distance_size: usize, +) -> Result { + let version = if distance_size == DISTANCE_TABLE_SIZE_70 { + 1 + } else { + 0 + }; + let allowance = lengths.main.allowance(); + let (_, bits) = encode_table_slices(lengths.slices(), version, &allowance)?; + token_stream_bits_after_tables(tokens, filters, lengths, distance_size, bits) +} + +fn token_stream_bits_after_tables( + tokens: &[EncodeToken], + filters: &[EncodeFilter], + lengths: &OwnedLengths, + distance_size: usize, + mut bits: usize, +) -> Result { + let allowance = lengths.main.allowance(); + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let mut state = EncoderMatchState::default(); + for token in filters + .iter() + .copied() + .map(EncodeToken::Filter) + .chain(tokens.iter().copied()) + { + match token { + EncodeToken::Literal(byte) => bits += prices.literal(byte), + EncodeToken::Match { length, distance } => { + bits += prices.match_cost(&state, length, distance, distance_size)?; + state.remember(length, distance); + } + EncodeToken::Filter(filter) => { + let mut writer = BitWriter::with_allowance(&allowance); + try_write_filter(&mut writer, filter)?; + bits += usize::from(lengths.main[256]) + writer.bit_pos; + } + } + } + Ok(bits) +} + +struct OptimalWorkspace { + price: Buffer, + arrive_length: Buffer, + arrive_distance: Buffer, + arrive_reps: Buffer<[u32; 4], B>, + arrive_last_length: Buffer, +} + +impl OptimalWorkspace { + fn new(allowance: &B) -> Self { + Self { + price: Buffer::new(allowance), + arrive_length: Buffer::new(allowance), + arrive_distance: Buffer::new(allowance), + arrive_reps: Buffer::new(allowance), + arrive_last_length: Buffer::new(allowance), + } + } +} + +/// What a literal is assumed to cost before any block has been coded, in the +/// same bit units [`estimated_match_cost`] reports. A literal is one main-table +/// symbol out of 256 plus the odds that the table is skewed, so eight is the +/// floor and nine is what real blocks measure. +const ESTIMATED_LITERAL_COST: u32 = 9; + +/// How many times the optimal parse runs over a block. The first pass guesses +/// prices; the rest reprice against the tables the pass before produced. +const OPTIMAL_PARSE_PASSES: usize = 3; + +/// What a symbol the first pass never used is assumed to cost. Reaching for +/// one is not forbidden, only expensive: the tables are rebuilt from whatever +/// the last pass chose, so a symbol that earns its place gets a real code. +const UNUSED_SYMBOL_COST: usize = 15; + +/// Prices a token against the code lengths a previous pass produced, which is +/// what the block will really spend, rather than against the flat guess in +/// [`estimated_match_cost`]. +struct TokenPrices<'a> { + lengths: LengthSlices<'a>, +} + +impl TokenPrices<'_> { + fn code(bits: u8) -> usize { + if bits == 0 { + UNUSED_SYMBOL_COST + } else { + usize::from(bits) + } + } + + fn literal(&self, byte: u8) -> usize { + Self::code(self.lengths.main[byte as usize]) + } + + // This is the inner optimal-parse loop's pricing operation. Keep it in + // that loop rather than returning a codec Result through a stack slot for + // every candidate length, including across generic codegen units. + #[inline(always)] + fn match_cost( + &self, + state: &EncoderMatchState, + length: usize, + distance: usize, + distance_size: usize, + ) -> Result { + Ok(match state.encode_match(length, distance, distance_size)? { + EncodedMatch::LastLengthRepeat => Self::code(self.lengths.main[257]), + EncodedMatch::RepeatDistance { + index, length_slot, .. + } => { + Self::code(self.lengths.main[258 + index]) + + Self::code(self.lengths.length[length_slot]) + + usize::from(length_slot_extra_bits(length_slot)) + } + EncodedMatch::New { + length_slot, + distance_slot, + distance_extra, + distance_bit_count, + .. + } => { + let align = if distance_bit_count >= 4 { + distance_bit_count - 4 + Self::code(self.lengths.align[distance_extra & 0x0f]) + } else { + distance_bit_count + }; + Self::code(self.lengths.main[262 + length_slot]) + + usize::from(length_slot_extra_bits(length_slot)) + + Self::code(self.lengths.distance[distance_slot]) + + align + } + }) + } +} + +/// Length-slot prices are invariant throughout one pass. A run also keeps the +/// same distance and arriving state while it prices every possible endpoint. +struct OptimalMatchPrices { + new_lengths: [u32; LENGTH_TABLE_SIZE], + repeat_lengths: [u32; LENGTH_TABLE_SIZE], + repeats: [u32; 4], + last_repeat: u32, +} + +struct MatchRunPrice<'a> { + lengths: &'a [u32; LENGTH_TABLE_SIZE], + distance: u32, + bonus: usize, + last_length: Option, + last_repeat: u32, +} + +impl OptimalMatchPrices { + fn new(prices: Option<&TokenPrices<'_>>) -> Self { + Self { + new_lengths: std::array::from_fn(|slot| { + let code = prices.map_or(0, |prices| { + TokenPrices::code(prices.lengths.main[262 + slot]) + }); + (code + usize::from(length_slot_extra_bits(slot))) as u32 + }), + repeat_lengths: std::array::from_fn(|slot| { + let code = + prices.map_or(0, |prices| TokenPrices::code(prices.lengths.length[slot])); + (code + usize::from(length_slot_extra_bits(slot))) as u32 + }), + repeats: std::array::from_fn(|index| { + prices.map_or(5, |prices| { + TokenPrices::code(prices.lengths.main[258 + index]) as u32 + }) + }), + last_repeat: prices.map_or(2, |prices| { + TokenPrices::code(prices.lengths.main[257]) as u32 + }), + } + } + + fn run( + &self, + state: &EncoderMatchState, + distance: usize, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + ) -> Result> { + if let Some(index) = state + .reps + .iter() + .position(|&repeat| repeat == distance && repeat != 0) + { + return Ok(MatchRunPrice { + lengths: &self.repeat_lengths, + distance: self.repeats[index], + bonus: 0, + last_length: (index == 0).then_some(state.last_length), + last_repeat: self.last_repeat, + }); + } + let (slot, extra) = distance_slot_for_match(distance, distance_size)?; + let bits = distance_slot_bit_count(slot)?; + let cost = prices.map_or(10 + bits, |prices| { + TokenPrices::code(prices.lengths.distance[slot]) + + if bits >= 4 { + bits - 4 + TokenPrices::code(prices.lengths.align[extra & 0x0f]) + } else { + bits + } + }); + Ok(MatchRunPrice { + lengths: &self.new_lengths, + distance: cost as u32, + bonus: length_bonus(distance), + last_length: None, + last_repeat: self.last_repeat, + }) + } +} + +impl MatchRunPrice<'_> { + #[inline] + fn cost(&self, length: usize) -> Option { + if self.last_length == Some(length) { + return Some(self.last_repeat); + } + let encoded = length.checked_sub(self.bonus)?; + if encoded < 2 { + return None; + } + debug_assert!(length <= MAX_ENCODER_MATCH_LENGTH); + let (slot, _) = length_slot_for_valid_match(encoded); + Some(self.distance + self.lengths[slot]) + } +} + +struct OptimalSlices<'a> { + price: &'a mut [u32], + arrive_length: &'a mut [u32], + arrive_distance: &'a mut [u32], + arrive_reps: &'a mut [[u32; 4]], + arrive_last_length: &'a mut [u32], +} + +// No growth or ownership changes occur here. Keep one pricing implementation +// for bounded and unlimited execution instead of specializing this hot loop on +// their differently sized allocation owners and fallible push operations. +#[allow(clippy::too_many_arguments)] +fn price_optimal_paths( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + runs: &[(u32, u32)], + starts: &[u32], + workspace: OptimalSlices<'_>, + reaches: &mut [(usize, usize, usize)], +) { + let start = block.start; + let end = block.end; + let span = end - start; + let OptimalSlices { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + } = workspace; + // The first position past a match the parse committed to. Nothing is + // priced from the positions before it. See [`NICE_MATCH_LENGTH`]. + let mut committed_through = 0usize; + let match_prices = OptimalMatchPrices::new(prices); + + for index in 0..span { + let pos = start + index; + if index < committed_through { + continue; + } + // Every priced position extends a literal path to its successor; + // a committed match skips only to an already priced endpoint. Blocks + // are at most 1 MiB, so even all 15-bit literals stay below u32::MAX. + let here = price[index]; + let literal_cost = prices.map_or(ESTIMATED_LITERAL_COST, |prices| { + prices.literal(combined[pos]) as u32 + }); + let literal = here.saturating_add(literal_cost); + if literal < price[index + 1] { + price[index + 1] = literal; + arrive_length[index + 1] = 0; + arrive_distance[index + 1] = 0; + // A literal emits no distance, so it leaves the remembered ones + // exactly as it found them. + arrive_reps[index + 1] = arrive_reps[index]; + arrive_last_length[index + 1] = arrive_last_length[index]; + } + + let max_distance = pos.min(options.max_match_distance); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_distance == 0 || max_length < 4 { + continue; + } + + let state = EncoderMatchState { + reps: arrive_reps[index].map(|distance| distance as usize), + last_length: arrive_last_length[index] as usize, + }; + + let mut reaches_len = 0; + let mut longest = 0usize; + + // A match at a remembered distance is priced out of the main table + // alone, a handful of bits against twenty for a fresh distance, so it + // earns its place even when it is shorter than anything the collector + // found. The collector only reports a candidate that beats the longest + // found so far, so these have to be asked for separately. + for repeat in state.reps { + if repeat == 0 || repeat > max_distance { + continue; + } + let length = match_length(combined, pos, repeat, max_length); + if length >= 4 { + reaches[reaches_len] = (4, length, repeat); + reaches_len += 1; + } + } + + // The collector reports nearest first, so the first distance to reach + // a length is the cheapest one that can. Each report that improves on + // the longest so far owns one run of lengths. The tree measures + // against the whole member where the chains stopped at the block, so + // a length is capped here to what this block can still hold. + for &(length, distance) in &runs[starts[index] as usize..starts[index + 1] as usize] { + let length = (length as usize).min(max_length); + if length > longest { + reaches[reaches_len] = (longest + 1, length, distance as usize); + reaches_len += 1; + longest = length; + } + } + + let reaches = &reaches[..reaches_len]; + + // Equal token prices do not make shorter matches redundant: their + // endpoints can expose a better continuation. Price every endpoint + // unless the explicit long-match heuristic commits past all of them. + let committed_reach = reaches + .iter() + .map(|&(_, end, _)| end) + .max() + .filter(|&length| length >= NICE_MATCH_LENGTH); + for &(run_start, run_end, distance) in reaches.iter() { + let mut length = run_start.max(4); + if let Some(committed) = committed_reach { + if run_end < committed { + continue; + } + length = committed; + } + let Ok(run_price) = match_prices.run(&state, distance, distance_size, prices) else { + continue; + }; + while length <= run_end { + let reach = length; + if let Some(cost) = run_price.cost(reach) { + let reached = here.saturating_add(cost); + let target = index + reach; + if reached < price[target] { + price[target] = reached; + arrive_length[target] = reach as u32; + arrive_distance[target] = distance as u32; + let mut next = state; + next.remember(reach, distance); + arrive_reps[target] = next.reps.map(|distance| distance as u32); + arrive_last_length[target] = next.last_length as u32; + } + } + length = reach + 1; + } + } + + // A committed match is at least 512 bytes long. Even after the + // distance bonus, that length and every collected u32 distance fit + // their encoder tables, so the endpoint has already been priced. + let longest_reach = reaches.iter().map(|&(_, length, _)| length).max(); + if let Some(reach) = longest_reach { + if reach >= NICE_MATCH_LENGTH { + committed_through = index + reach; + } + } + } +} + +/// Prices every path through the block and keeps the cheapest, instead of +/// taking the longest match at each position and checking one or two bytes +/// ahead. Prices come from [`estimated_match_cost`], so this is only as good +/// as that estimate, but it sees the whole block where lazy matching sees two +/// bytes. +/// +/// The repeated-distance discount depends on the path taken, which a forward +/// pass does not know. Each node carries the whole four-slot distance memory +/// the cheapest path to it leaves behind, so the next hop is priced against +/// what that path would really have remembered. Two paths reaching one node +/// with different memories still collapse into whichever was cheaper, so this +/// stays an approximation, just a far closer one than carrying the arriving +/// match alone. It is also not quite every path: once a match reaches +/// [`NICE_MATCH_LENGTH`] the parse takes it and steps over the bytes it covers +/// rather than pricing each of them. +/// +/// Does no searching of its own: `matches` holds what an [`OptimalCollector`] +/// found at each position of this block, and prices never change what a +/// search would find, so every pass prices the same collection. +fn optimal_tokens_in_workspace( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + matches: &BlockMatches, + workspace: &mut OptimalWorkspace, +) -> Result> { + #[cfg(test)] + convergence_tests::record_pricing_pass(); + let start = block.start; + let end = block.end; + let span = end - start; + + let allowance = workspace.price.allowance().clone(); + if !B::LIMITED && matches.runs.is_empty() { + // Every parse starts with empty distance memory. Without a collected + // match, literals cannot introduce a remembered distance, so they are + // the only path through this block under any set of table prices. + // Limited parses retain their allocation and refusal order below. + return Buffer::collect( + combined[block].iter().copied().map(EncodeToken::Literal), + &allowance, + ); + } + let OptimalWorkspace { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + } = workspace; + price.resize(span + 1, u32::MAX)?; + price.fill(u32::MAX); + arrive_length.resize(span + 1, 0)?; + arrive_length.fill(0); + arrive_distance.resize(span + 1, 0)?; + arrive_distance.fill(0); + arrive_reps.resize(span + 1, [0; 4])?; + arrive_reps.fill([0; 4]); + arrive_last_length.resize(span + 1, 0)?; + arrive_last_length.fill(0); + price[0] = 0; + + // Admit the largest candidate list once. Pricing only borrows already + // charged arrays, so its inner loop is identical for both budget policies. + // Each position contributes at most four remembered-distance candidates. + let longest_run = matches + .starts + .windows(2) + .map(|pair| (pair[1] - pair[0]) as usize) + .max() + .unwrap_or(0); + // A position contributes at most one run for each encodable match length. + // Four remembered distances are added while pricing, so this bound cannot + // approach usize::MAX for a valid BlockMatches collection. + debug_assert!(longest_run <= MAX_ENCODER_MATCH_LENGTH); + let reach_capacity = longest_run + 4; + let mut reaches = Buffer::filled(reach_capacity, (0usize, 0usize, 0usize), &allowance)?; + price_optimal_paths( + combined, + block.clone(), + options, + distance_size, + prices, + &matches.runs, + &matches.starts, + OptimalSlices { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + }, + &mut reaches, + ); + + let mut reversed = Buffer::new(&allowance); + let mut index = span; + while index > 0 { + let length = arrive_length[index] as usize; + if length == 0 { + reversed + .push(EncodeToken::Literal(combined[start + index - 1])) + .map_err(Into::into)?; + index -= 1; + } else { + reversed + .push(EncodeToken::Match { + length, + distance: arrive_distance[index] as usize, + }) + .map_err(Into::into)?; + index -= length; + } + } + reversed.reverse(); + Ok(reversed) +} + +#[cfg(test)] +fn encode_tokens_with_progress( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_>, + options: EncodeOptions, + distance_size: usize, + initial_filters: &[EncodeFilter], + progress: Option<&mut dyn FnMut(usize) -> bool>, +) -> Result> { + let allowance = match &search { + MemberSearch::Fresh => Allowance::default(), + MemberSearch::Lazy(finder) => finder.allowance().clone(), + MemberSearch::Optimal(collector) => match &collector.finder { + CollectorFinder::Tree(finder) => finder.allowance().clone(), + CollectorFinder::Chains(finder) => finder.allowance().clone(), + }, + }; + encode_tokens_with_allowance( + combined, + block, + search, + options, + distance_size, + initial_filters, + progress, + &allowance, + ) +} + +#[allow(clippy::too_many_arguments)] +fn encode_tokens_with_allowance( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_, B>, + options: EncodeOptions, + distance_size: usize, + initial_filters: &[EncodeFilter], + mut progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let start = block.start; + let end = block.end; + if options.optimal_parse { + let mut own; + let collector = match search { + MemberSearch::Optimal(collector) => collector, + _ => { + own = OptimalCollector::with_allowance(combined, start, options, allowance)?; + &mut own + } + }; + let matches = collector.collect(combined, block.clone(), options)?; + // The prices come from the Huffman tables, and the tables come from + // the parse, so the first pass has to guess. Each pass after it prices + // against what the pass before actually produced. + let mut workspace = OptimalWorkspace::new(allowance); + let mut tokens = optimal_tokens_in_workspace( + combined, + block.clone(), + options, + distance_size, + None, + &matches, + &mut workspace, + )?; + let mut lengths = + table_lengths_with_allowance(&tokens, initial_filters, distance_size, allowance)?; + let mut best_bits = token_stream_bits(&tokens, initial_filters, &lengths, distance_size)?; + // Without a collected match, every pass starts with no remembered + // distance and can only produce the same literals. Keep the first + // tables and stream validation before skipping the equal reparse. + // Limited callers retain every original admission and refusal point. + let passes = if !B::LIMITED && matches.runs.is_empty() { + 1 + } else { + OPTIMAL_PARSE_PASSES + }; + let mut best = None; + for _ in 1..passes { + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let next = optimal_tokens_in_workspace( + combined, + block.clone(), + options, + distance_size, + Some(&prices), + &matches, + &mut workspace, + )?; + if next == tokens { + break; + } + let next_lengths = + table_lengths_with_allowance(&next, initial_filters, distance_size, allowance)?; + let tables_converged = lengths.slices() == next_lengths.slices(); + lengths = next_lengths; + let bits = token_stream_bits(&next, initial_filters, &lengths, distance_size)?; + if bits < best_bits { + best_bits = bits; + best = None; + } else if best.is_none() { + // Keep an earlier winner only when repricing actually loses. + best = Some(std::mem::replace(&mut tokens, Buffer::new(allowance))); + } + tokens = next; + if tables_converged { + // With the same matches, initial state and table prices, the + // next pass would reproduce these tokens and stop above. Keep + // the normal winner and tie handling before skipping it. + break; + } + } + let tokens = best.unwrap_or(tokens); + if progress.is_some_and(|report| !report(end - start)) { + return Err(Error::Cancelled); + } + return Ok(tokens); + } + + let mut own; + let finder = match search { + MemberSearch::Lazy(finder) => finder, + _ => { + own = seeded_finder(combined, start..end, options, allowance)?; + &mut own + } + }; + let mut tokens = Buffer::new(allowance); + let mut pos = start; + let mut state = EncoderMatchState::default(); + let mut next_report = 0usize; + let mut pending_match: Option = None; + while pos < end { + let candidate = pending_match + .take() + .or_else(|| best_match(combined, pos, end, finder, options, &state, distance_size)); + if let Some(candidate) = candidate { + let (emit_literal, cached_next) = lazy_match_decision( + combined, + pos, + end, + finder, + options, + &state, + distance_size, + candidate, + ); + if emit_literal { + tokens + .push(EncodeToken::Literal(combined[pos])) + .map_err(Into::into)?; + finder.insert(combined, pos); + pos += 1; + pending_match = cached_next; + continue; + } + let MatchCandidate { + length, distance, .. + } = candidate; + tokens + .push(EncodeToken::Match { length, distance }) + .map_err(Into::into)?; + state.remember(length, distance); + for history_pos in pos..pos + length { + finder.insert(combined, history_pos); + } + pos += length; + } else { + tokens + .push(EncodeToken::Literal(combined[pos])) + .map_err(Into::into)?; + finder.insert(combined, pos); + pos += 1; + } + let consumed = pos - start; + if consumed >= next_report { + if progress + .as_deref_mut() + .is_some_and(|report| !report(consumed)) + { + return Err(Error::Cancelled); + } + next_report = consumed.saturating_add(1024 * 1024); + } + } + if progress.is_some_and(|report| !report(end - start)) { + return Err(Error::Cancelled); + } + Ok(tokens) +} + +#[cfg(test)] +#[path = "convergence_tests.rs"] +mod convergence_tests; + +/// Decides whether a literal should be emitted instead of `current` because a +/// better match starts within the lazy lookahead window. Also returns the +/// match found one byte ahead (when computed) so the caller can reuse it for +/// the next position instead of searching again. +#[allow(clippy::too_many_arguments)] +fn lazy_match_decision( + input: &[u8], + pos: usize, + end: usize, + finder: &Rar50MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, + distance_size: usize, + current: MatchCandidate, +) -> (bool, Option) { + if !options.lazy_matching { + return (false, None); + } + let lookahead = options.lazy_lookahead.max(1); + let mut cached_next = None; + for offset in 1..=lookahead { + if pos + offset >= end { + break; + } + let next = best_match( + input, + pos + offset, + end, + finder, + options, + state, + distance_size, + ); + if offset == 1 { + cached_next = next; + } + let skipped_literal_score = offset as isize * 8; + if next.is_some_and(|next| next.score > current.score + skipped_literal_score) { + return (true, cached_next); + } + } + (false, None) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct MatchCandidate { + length: usize, + distance: usize, + score: isize, +} + +fn best_match( + input: &[u8], + pos: usize, + end: usize, + finder: &Rar50MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, + distance_size: usize, +) -> Option { + let max_distance = pos.min(options.max_match_distance); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_distance == 0 || max_length < 4 { + return None; + } + let mut best = None; + let mut checked = 0usize; + for distance in state.reps { + // Remembered matches were admitted under this same distance limit at + // an earlier position, so only unfilled repeat slots need skipping. + if distance == 0 { + continue; + } + let length = match_length(input, pos, distance, max_length); + consider_match_candidate(&mut best, state, distance_size, length, distance); + } + if let Some(best) = best { + if best.length == max_length || best.length >= NICE_MATCH_LENGTH { + return Some(best); + } + } + let mut candidate = finder.first(input, pos); + while candidate != match_finder::NO_POSITION { + let distance = pos - candidate; + if distance > max_distance { + break; + } + checked += 1; + // A candidate can only improve on the current best when it matches at + // least one byte past the best length, so probe that byte first. + let best_length = best.map_or(0, |best: MatchCandidate| best.length); + if best_length == 0 || input[candidate + best_length] == input[pos + best_length] { + let length = match_length(input, pos, distance, max_length); + consider_match_candidate(&mut best, state, distance_size, length, distance); + } + if let Some(best) = best { + if best.length == max_length || best.length >= NICE_MATCH_LENGTH { + break; + } + } + if checked >= options.max_match_candidates { + break; + } + candidate = finder.previous(candidate); + } + best +} + +fn match_length(input: &[u8], pos: usize, distance: usize, max_length: usize) -> usize { + super::super::fast::match_length(input, pos, distance, max_length) +} + +fn consider_match_candidate( + best: &mut Option, + state: &EncoderMatchState, + distance_size: usize, + length: usize, + distance: usize, +) { + if length < 4 { + return; + } + let Ok(cost) = estimated_match_cost(state, length, distance, distance_size) else { + return; + }; + let candidate = MatchCandidate { + length, + distance, + score: (length as isize * 16) - cost as isize, + }; + if best.is_none_or(|best| { + candidate.score > best.score + || (candidate.score == best.score + && (candidate.length > best.length + || (candidate.length == best.length && candidate.distance < best.distance))) + }) { + *best = Some(candidate); + } +} + +// Generic parsers can be instantiated in a different codegen unit. Keep the +// estimate available for inlining into their per-length pricing loop. +#[inline] +fn estimated_match_cost( + state: &EncoderMatchState, + length: usize, + distance: usize, + distance_size: usize, +) -> Result { + if distance == state.reps[0] && length == state.last_length { + return Ok(2); + } + if state + .reps + .iter() + .any(|&repeat_distance| repeat_distance == distance && repeat_distance != 0) + { + let (length_slot, _) = length_slot_for_match(length)?; + return Ok(5 + usize::from(length_slot_extra_bits(length_slot))); + } + + let (distance_slot, _) = distance_slot_for_match(distance, distance_size)?; + let encoded_length = length + .checked_sub(length_bonus(distance)) + .ok_or(Error::InvalidData("RAR 5 adjusted match length underflows"))?; + let (length_slot, _) = length_slot_for_match(encoded_length)?; + Ok(10 + + usize::from(length_slot_extra_bits(length_slot)) + + distance_slot_bit_count(distance_slot)?) +} + +fn length_slot_for_match(length: usize) -> Result<(usize, usize)> { + if length < 2 { + return Err(Error::InvalidData("RAR 5 match length is too short")); + } + Ok(length_slot_for_valid_match(length)) +} + +fn length_slot_for_valid_match(length: usize) -> (usize, usize) { + debug_assert!(length >= 2); + let value = length - 2; + if value < 8 { + return (value, 0); + } + let bit_count = value.ilog2() as usize - 2; + let slot = ((bit_count + 1) << 2) | ((value >> bit_count) & 3); + // The encoder caps matches at 4096 bytes, which fits slots 0..44. + (slot, value & ((1 << bit_count) - 1)) +} + +fn distance_slot_for_match(distance: usize, distance_size: usize) -> Result<(usize, usize)> { + // Every emitted match comes from an earlier input position, and the two + // production distance tables both have at least four entries. + if distance == 0 { + return Err(Error::InvalidData("RAR 5 match distance is zero")); + } + let result = distance_slot_for_valid_match(distance); + if result.0 >= distance_size { + return Err(Error::InvalidData("RAR 5 match distance is too large")); + } + Ok(result) +} + +fn distance_slot_for_valid_match(distance: usize) -> (usize, usize) { + debug_assert!(distance != 0); + let value = distance - 1; + if value < 4 { + return (value, 0); + } + let bit_count = value.ilog2() as usize - 1; + let slot = (bit_count << 1) + 2 + ((value >> bit_count) & 1); + (slot, value & ((1 << bit_count) - 1)) +} + +fn distance_slot_bit_count_valid(slot: usize) -> usize { + if slot < 4 { + 0 + } else { + (slot - 2) >> 1 + } +} + +fn literal_presence(data: &[u8]) -> [bool; 256] { + let mut present = [false; 256]; + for &byte in data { + present[byte as usize] = true; + } + present +} + +fn try_write_filter(writer: &mut BitWriter, filter: EncodeFilter) -> Result<()> { + if filter.offset > u32::MAX as usize { + return Err(Error::InvalidData("RAR 5 filter offset is too large")); + } + if filter.length > u32::MAX as usize { + return Err(Error::InvalidData("RAR 5 filter length is too large")); + } + try_write_filter_data(writer, filter.offset as u32)?; + try_write_filter_data(writer, filter.length as u32)?; + match filter.filter_type { + FilterType::Delta => { + if filter.channels == 0 || filter.channels > MAX_DELTA_CHANNELS { + return Err(Error::InvalidData( + "RAR 5 DELTA filter channel count is invalid", + )); + } + writer.try_write_bits(0, 3).map_err(Into::into)?; + writer + .try_write_bits(filter.channels - 1, 5) + .map_err(Into::into)?; + } + FilterType::E8 => writer.try_write_bits(1, 3).map_err(Into::into)?, + FilterType::E8E9 => writer.try_write_bits(2, 3).map_err(Into::into)?, + FilterType::Arm => writer.try_write_bits(3, 3).map_err(Into::into)?, + } + Ok(()) +} + +fn write_valid_filter(writer: &mut BitWriter, filter: EncodeFilter) { + debug_assert!(u32::try_from(filter.offset).is_ok()); + debug_assert!(u32::try_from(filter.length).is_ok()); + write_filter_data_admitted(writer, filter.offset as u32); + write_filter_data_admitted(writer, filter.length as u32); + match filter.filter_type { + FilterType::Delta => { + debug_assert!((1..=MAX_DELTA_CHANNELS).contains(&filter.channels)); + writer.write_admitted_bits(0, 3); + writer.write_admitted_bits(filter.channels - 1, 5); + } + FilterType::E8 => writer.write_admitted_bits(1, 3), + FilterType::E8E9 => writer.write_admitted_bits(2, 3), + FilterType::Arm => writer.write_admitted_bits(3, 3), + } +} + +fn try_write_filter_data(writer: &mut BitWriter, value: u32) -> Result<()> { + let byte_count = filter_data_byte_count(value); + writer + .try_write_bits(byte_count - 1, 2) + .map_err(Into::into)?; + for index in 0..byte_count { + writer + .try_write_bits(((value >> (index * 8)) & 0xff) as usize, 8) + .map_err(Into::into)?; + } + Ok(()) +} + +fn write_filter_data_admitted(writer: &mut BitWriter, value: u32) { + let byte_count = filter_data_byte_count(value); + writer.write_admitted_bits(byte_count - 1, 2); + for index in 0..byte_count { + writer.write_admitted_bits(((value >> (index * 8)) & 0xff) as usize, 8); + } +} + +fn filter_data_byte_count(value: u32) -> usize { + ((u32::BITS - value.leading_zeros()).div_ceil(8) as usize).max(1) +} + +fn e8e9_encode(data: &mut [u8], file_offset: u32, include_e9: bool) { + if data.len() <= 4 { + return; + } + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let opcode_limit = data.len() - 4; + let mut opcode_pos = 0usize; + while let Some(pos) = + super::super::fast::next_x86_opcode(data, opcode_pos, opcode_limit, cmp_mask) + { + let cur_pos = pos + 1; + let offset = file_offset.wrapping_add(cur_pos as u32) % X86_FILTER_FILE_SIZE; + let addr = u32::from_le_bytes([ + data[cur_pos], + data[cur_pos + 1], + data[cur_pos + 2], + data[cur_pos + 3], + ]); + let candidate = addr.wrapping_add(offset); + let new_addr = if candidate < X86_FILTER_FILE_SIZE { + Some(candidate) + } else { + let candidate = addr.wrapping_sub(X86_FILTER_FILE_SIZE); + (candidate & 0x8000_0000 != 0 && candidate.wrapping_add(offset) & 0x8000_0000 == 0) + .then_some(candidate) + }; + if let Some(value) = new_addr { + data[cur_pos..cur_pos + 4].copy_from_slice(&value.to_le_bytes()); + } + opcode_pos = pos + 5; + } +} + +fn arm_encode(data: &mut [u8], file_offset: u32) { + let mut pos = 0usize; + while pos + 3 < data.len() { + if data[pos + 3] == 0xeb { + let mut offset = u32::from(data[pos]) + | (u32::from(data[pos + 1]) << 8) + | (u32::from(data[pos + 2]) << 16); + offset = offset.wrapping_add(file_offset.wrapping_add(pos as u32) / 4); + data[pos] = offset as u8; + data[pos + 1] = (offset >> 8) as u8; + data[pos + 2] = (offset >> 16) as u8; + } + pos += 4; + } +} + +struct EncoderCodeTable { + symbols: Buffer<(u16, u8), B>, +} + +impl EncoderCodeTable { + fn from_lengths(lengths: &[u8], allowance: &B) -> Result { + let mut counts = [0u16; 16]; + // Both callers use the encoder's length generators, capped at 15 bits. + for &length in lengths { + if length != 0 { + counts[length as usize] += 1; + } + } + validate_huffman_counts(&counts)?; + let mut next = [0u16; 16]; + let mut code = 0; + for length in 1..16 { + code = (code + counts[length - 1]) << 1; + next[length] = code; + } + let mut symbols = Buffer::filled(lengths.len(), (0u16, 0u8), allowance)?; + for (symbol, &length) in lengths.iter().enumerate() { + if length != 0 { + symbols[symbol] = (next[length as usize], length); + next[length as usize] += 1; + } + } + Ok(Self { symbols }) + } + fn code_for_present_symbol(&self, symbol: usize) -> (u16, u8) { + // Both encoder callers build frequencies from the exact token stream + // they emit immediately afterwards. Every requested symbol therefore + // has a non-zero code in this fixed-size array. + debug_assert!(symbol < self.symbols.len()); + debug_assert_ne!(self.symbols[symbol].1, 0); + self.symbols[symbol] + } +} + +struct BitWriter { + bytes: Buffer, + bit_pos: usize, +} + +impl BitWriter { + #[cfg(test)] + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } + fn write_bits(&mut self, value: usize, count: usize) { + self.try_write_bits(value, count).unwrap(); + } + fn finish(self) -> Vec { + self.bytes.into_vec() + } +} + +impl BitWriter { + fn with_allowance(allowance: &B) -> Self { + Self { + bytes: Buffer::new(allowance), + bit_pos: 0, + } + } + #[inline] + fn try_write_bits( + &mut self, + value: usize, + count: usize, + ) -> std::result::Result<(), B::Failure> { + self.bytes + .write_msb_bits(&mut self.bit_pos, value as u64, count) + } + fn write_admitted_bits(&mut self, value: usize, count: usize) { + self.bytes + .write_msb_bits_admitted(&mut self.bit_pos, value as u64, count); + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct LevelToken { + symbol: usize, + extra_bits: u8, + extra_value: u8, +} + +impl LevelToken { + const fn plain(symbol: usize) -> Self { + Self { + symbol, + extra_bits: 0, + extra_value: 0, + } + } + + const fn repeat_previous_short(count: usize) -> Self { + Self { + symbol: 16, + extra_bits: 3, + extra_value: (count - 3) as u8, + } + } + + const fn repeat_previous_long(count: usize) -> Self { + Self { + symbol: 17, + extra_bits: 7, + extra_value: (count - 11) as u8, + } + } + + const fn zero_run_short(count: usize) -> Self { + Self { + symbol: 18, + extra_bits: 3, + extra_value: (count - 3) as u8, + } + } + + const fn zero_run_long(count: usize) -> Self { + Self { + symbol: 19, + extra_bits: 7, + extra_value: (count - 11) as u8, + } + } +} + +#[cfg(test)] +fn encode_table_level_tokens(lengths: &[u8]) -> Vec { + encode_table_level_tokens_with_allowance(lengths, &Allowance::default()) + .unwrap() + .into_vec() +} + +fn encode_table_level_tokens_with_allowance( + lengths: &[u8], + allowance: &B, +) -> Result> { + let mut tokens = Buffer::new(allowance); + let mut pos = 0usize; + let mut previous = None; + while pos < lengths.len() { + let value = lengths[pos]; + let mut run = 1usize; + while pos + run < lengths.len() && lengths[pos + run] == value { + run += 1; + } + + if value == 0 { + emit_zero_level_run(&mut tokens, run)?; + previous = Some(0); + pos += run; + continue; + } + + if previous == Some(value) && run >= 3 { + emit_repeat_level_run(&mut tokens, run)?; + pos += run; + continue; + } + + tokens + .push(LevelToken::plain(value as usize)) + .map_err(Into::into)?; + previous = Some(value); + pos += 1; + } + Ok(tokens) +} + +fn emit_repeat_level_run( + tokens: &mut Buffer, + mut run: usize, +) -> Result<()> { + while run >= 3 { + if run >= 11 { + let mut chunk = run.min(138); + if matches!(run - chunk, 1 | 2) { + chunk -= 3; + } + tokens + .push(LevelToken::repeat_previous_long(chunk)) + .map_err(Into::into)?; + run -= chunk; + } else { + let chunk = run.min(10); + tokens + .push(LevelToken::repeat_previous_short(chunk)) + .map_err(Into::into)?; + run -= chunk; + } + } + debug_assert_eq!(run, 0); + Ok(()) +} + +fn emit_zero_level_run( + tokens: &mut Buffer, + mut run: usize, +) -> Result<()> { + while run != 0 { + if run >= 11 { + let mut chunk = run.min(138); + if matches!(run - chunk, 1 | 2) { + chunk -= 3; + } + tokens + .push(LevelToken::zero_run_long(chunk)) + .map_err(Into::into)?; + run -= chunk; + } else if run >= 3 { + let chunk = run.min(10); + tokens + .push(LevelToken::zero_run_short(chunk)) + .map_err(Into::into)?; + run -= chunk; + } else { + for _ in 0..run { + tokens.push(LevelToken::plain(0)).map_err(Into::into)?; + } + break; + } + } + Ok(()) +} + +/// Prices the level alphabet by how often each symbol is used, where a flat +/// code charged the same for every symbol in play. +/// +/// A block's table is mostly runs and short lengths, so its tokens are far from +/// evenly spread and a flat code overpays for the common ones. Both codings are +/// costed here and the cheaper is written, because weighting can lose: a code +/// this deep spends eight bits rather than four to declare a length of fifteen, +/// and over twenty symbols that occasionally outweighs what the tokens save. +/// +/// Either way the code must be *complete*. Strict decoders rebuild the +/// pre-table (7-Zip's `k_BuildMode_Full`) and reject an under-full one. Huffman +/// gives Kraft equality by construction once two symbols are in play. The +/// near-uniform assignment also satisfies equality for any used-symbol count, +/// adding a phantom code when only one symbol is used. +#[cfg(test)] +fn level_code_lengths_for_tokens(tokens: &[LevelToken]) -> [u8; LEVEL_TABLE_SIZE] { + level_code_lengths_with_allowance(tokens, &Allowance::default()).unwrap() +} + +fn level_code_lengths_with_allowance( + tokens: &[LevelToken], + allowance: &B, +) -> Result<[u8; LEVEL_TABLE_SIZE]> { + let mut frequencies = [0usize; LEVEL_TABLE_SIZE]; + for token in tokens { + frequencies[token.symbol] += 1; + } + + let mut flat = [0u8; LEVEL_TABLE_SIZE]; + for (symbol, &count) in frequencies.iter().enumerate() { + flat[symbol] = u8::from(count != 0); + } + huffman::assign_flat_complete_code(&mut flat); + // One symbol in play leaves an empty branch beside it, and the flat + // assignment is the only one that pads it into a complete code. + if frequencies.iter().filter(|&&count| count != 0).count() <= 1 { + return Ok(flat); + } + + let owned = huffman::lengths_with_allowance(&frequencies, 15, allowance)?; + let mut weighted = [0; LEVEL_TABLE_SIZE]; + weighted.copy_from_slice(&owned); + Ok( + match level_code_cost(&weighted, &frequencies) < level_code_cost(&flat, &frequencies) { + true => weighted, + false => flat, + }, + ) +} + +/// What a level code costs in bits: the lengths at the head of the table as +/// [`write_level_lengths`] will write them, plus the tokens they code. +/// +/// The tokens' own extra bits are the same under either code and are left out. +fn level_code_cost( + lengths: &[u8; LEVEL_TABLE_SIZE], + frequencies: &[usize; LEVEL_TABLE_SIZE], +) -> usize { + let mut bits = 0usize; + let mut pos = 0usize; + while pos < LEVEL_TABLE_SIZE { + if lengths[pos] != 0 { + bits += if lengths[pos] == 15 { 8 } else { 4 }; + pos += 1; + continue; + } + let mut run = 1usize; + while pos + run < LEVEL_TABLE_SIZE && lengths[pos + run] == 0 { + run += 1; + } + pos += run; + while run >= 3 { + bits += 8; + run -= run.min(17); + } + bits += run * 4; + } + bits + (0..LEVEL_TABLE_SIZE) + .map(|symbol| usize::from(lengths[symbol]) * frequencies[symbol]) + .sum::() +} + +#[cfg(test)] +fn write_level_lengths(writer: &mut BitWriter, lengths: &[u8; LEVEL_TABLE_SIZE]) { + try_write_level_lengths(writer, lengths).unwrap(); +} + +fn try_write_level_lengths( + writer: &mut BitWriter, + lengths: &[u8; LEVEL_TABLE_SIZE], +) -> Result<()> { + let mut pos = 0usize; + while pos < LEVEL_TABLE_SIZE { + let length = lengths[pos]; + if length == 0 { + let mut count = 1usize; + while pos + count < LEVEL_TABLE_SIZE && lengths[pos + count] == 0 { + count += 1; + } + while count >= 3 { + let chunk = count.min(17); + writer.try_write_bits(15, 4).map_err(Into::into)?; + writer.try_write_bits(chunk - 2, 4).map_err(Into::into)?; + pos += chunk; + count -= chunk; + } + for _ in 0..count { + writer.try_write_bits(0, 4).map_err(Into::into)?; + pos += 1; + } + } else { + writer + .try_write_bits(usize::from(length), 4) + .map_err(Into::into)?; + if length == 15 { + writer.try_write_bits(0, 4).map_err(Into::into)?; + } + pos += 1; + } + } + Ok(()) +} + +#[cfg(test)] +#[path = "tests.rs"] +mod tests; + +#[cfg(test)] +#[path = "pricing_tests.rs"] +mod pricing_tests; + +#[cfg(test)] +#[path = "literal_pricing_tests.rs"] +mod literal_pricing_tests; diff --git a/arca-rar/vendor/rars/src/codec/rar50/history_retention_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/history_retention_tests.rs new file mode 100644 index 00000000..7f5e5286 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/history_retention_tests.rs @@ -0,0 +1,708 @@ +use super::*; +use crate::codec::workspace::RefusingBudget; +use std::io::{Cursor, Read}; + +#[derive(Debug, PartialEq, Eq)] +struct StateSnapshot { + tables: String, + reps: [usize; 4], + last_length: usize, + history: Vec, + history_capacity: usize, +} + +fn snapshot(state: &ReaderState) -> StateSnapshot { + StateSnapshot { + tables: format!("{:?}", state.tables), + reps: state.reps, + last_length: state.last_length, + history: state.history.to_vec(), + history_capacity: state.history.capacity(), + } +} + +struct TracedReader<'a> { + input: Cursor<&'a [u8]>, + calls: Vec<(u64, usize, usize)>, + fail_at: usize, +} +impl<'a> TracedReader<'a> { + fn new(input: &'a [u8], fail_at: usize) -> Self { + Self { + input: Cursor::new(input), + calls: Vec::new(), + fail_at, + } + } +} +impl Read for TracedReader<'_> { + fn read(&mut self, output: &mut [u8]) -> std::io::Result { + let at = self.input.position(); + if self.calls.len() == self.fail_at { + self.calls.push((at, output.len(), usize::MAX)); + return Err(std::io::Error::other("injected packed reader failure")); + } + let read = self.input.read(output)?; + self.calls.push((at, output.len(), read)); + Ok(read) + } +} + +fn source() -> Vec { + let mut data: Vec<_> = (0..4096).map(|i| ((i * 73 + i / 17) & 255) as u8).collect(); + for at in (32..data.len() - 8).step_by(64) { + data[at..at + 5].copy_from_slice(&[0xe8, 0x41, 0, 0, 0]); + data[at + 5..at + 8].copy_from_slice(&[0, 0, 0xeb]); + } + data +} +fn filter_cases() -> [Option; 5] { + [ + None, + Some(crate::FilterKind::Delta { channels: 4 }), + Some(crate::FilterKind::E8), + Some(crate::FilterKind::E8E9), + Some(crate::FilterKind::Arm), + ] +} +fn packed(data: &[u8], version: u8, filter: Option) -> Vec { + let specs: Vec<_> = filter.into_iter().map(crate::FilterSpec::whole).collect(); + Unpack50Encoder::new() + .encode_member_with_filters(data, version, &specs) + .unwrap() +} +fn result(result: Result>) -> std::result::Result, String> { + result + .map(|buffer| buffer.to_vec()) + .map_err(|error| format!("{error:?}")) +} + +#[test] +fn independent_history_unlimited_matches_original_bytes_and_live_decode_state() { + let data = source(); + for version in [0, 1] { + for filter in filter_cases() { + for dictionary in [32, 128, 4096] { + let specs: Vec<_> = filter.into_iter().map(crate::FilterSpec::whole).collect(); + let packed = Unpack50Encoder::with_options( + EncodeOptions::new(64).with_max_match_distance(dictionary), + ) + .encode_member_with_filters(&data, version, &specs) + .unwrap(); + for mode in [DecodeMode::Lz, DecodeMode::LzNoFilters] { + let mut old = ReaderState::new(&Allowance::default()); + let mut actual = ReaderState::new(&Allowance::default()); + let mut old_input = TracedReader::new(&packed, usize::MAX); + let mut actual_input = TracedReader::new(&packed, usize::MAX); + let expected = result(reference_decode( + &mut old, + &mut old_input, + version, + data.len(), + dictionary, + false, + mode, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut actual_input, + version, + data.len(), + dictionary, + false, + mode, + HistoryRetention::DiscardIndependent, + ), + ); + assert_eq!(output, expected, "version={version}, filter={filter:?}, dictionary={dictionary}, mode={mode:?}"); + assert_eq!(actual_input.calls, old_input.calls); + let mut old_state = snapshot(&old); + let actual_state = snapshot(&actual); + if let Ok(bytes) = &output { + if mode == DecodeMode::Lz { + assert_eq!(bytes, &data, "version={version}, filter={filter:?}, dictionary={dictionary}, mode={mode:?}"); + } + assert!(!old_state.history.is_empty()); + old_state.history.clear(); + old_state.history_capacity = 0; + assert!(actual.history.is_empty()); + assert_eq!(actual.history.capacity(), 0); + } + assert_eq!(actual_state, old_state); + } + } + } + } +} + +#[test] +fn independent_history_default_and_solid_routes_retain_original_raw_dictionary() { + let data = source(); + for version in [0, 1] { + for filter in filter_cases() { + let packed = packed(&data, version, filter); + let mut old = ReaderState::new(&Allowance::default()); + let mut actual = ReaderState::new(&Allowance::default()); + let expected = result(reference_decode( + &mut old, + &mut Cursor::new(&packed), + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + let output = result(actual.decode_member_with_dictionary( + &packed, + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + assert_eq!(output, expected); + assert_eq!(snapshot(&actual), snapshot(&old)); + let specs: Vec<_> = filter.into_iter().map(crate::FilterSpec::whole).collect(); + let (raw, _) = filtered_lz_member(&data, &specs).unwrap(); + assert_eq!(&actual.history[..], raw); + // The internal discard request must be overridden for solid decoding. + let next = + encode_lz_member_with_history(&raw[raw.len() - 128..], &raw, version).unwrap(); + let expected = result(reference_decode( + &mut old, + &mut Cursor::new(&next), + version, + 128, + 4096, + true, + DecodeMode::Lz, + )); + let output = result(actual.decode_member_with_dictionary_and_history( + &next, + version, + 128, + 4096, + true, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + )); + assert_eq!(output, expected); + assert_eq!(snapshot(&actual), snapshot(&old)); + } + } +} + +#[test] +fn independent_history_limited_keeps_every_original_growth_refusal_and_charge() { + let data = source()[..256].to_vec(); + for version in [0, 1] { + for filter in [None, Some(crate::FilterKind::Delta { channels: 4 })] { + let packed = packed(&data, version, filter); + let baseline = RefusingBudget::new(usize::MAX); + { + let mut state = ReaderState::new(&baseline); + reference_decode( + &mut state, + &mut Cursor::new(&packed), + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + ) + .unwrap(); + } + assert_eq!(baseline.used(), 0); + for fail_at in 0..=baseline.attempts() { + for cancel_at in [0, 3, 7, usize::MAX] { + let old_budget = RefusingBudget::new(fail_at); + let actual_budget = RefusingBudget::new(fail_at); + let mut old = ReaderState::new(&old_budget); + let mut actual = ReaderState::new(&actual_budget); + let old_token = crate::ReadCancellation::new(); + let actual_token = crate::ReadCancellation::new(); + old.read_control = crate::read_control::ReadControl::new(Some(&old_token)); + actual.read_control = + crate::read_control::ReadControl::new(Some(&actual_token)); + old.read_control.cancel_after_checks(cancel_at); + actual.read_control.cancel_after_checks(cancel_at); + let mut old_input = TracedReader::new(&packed, usize::MAX); + let mut actual_input = TracedReader::new(&packed, usize::MAX); + let expected = result(reference_decode( + &mut old, + &mut old_input, + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut actual_input, + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + ), + ); + assert_eq!( + output, expected, + "version={version}, filter={filter:?}, fail_at={fail_at}" + ); + assert_eq!(actual_input.calls, old_input.calls); + assert_eq!(snapshot(&actual), snapshot(&old)); + assert_eq!(actual_budget.attempts(), old_budget.attempts()); + assert_eq!(actual_budget.used(), old_budget.used()); + drop(actual); + drop(old); + assert_eq!(actual_budget.used(), 0); + assert_eq!(old_budget.used(), 0); + assert_eq!(actual_token.is_cancelled(), old_token.is_cancelled()); + } + } + } + } +} + +#[test] +fn independent_history_preserves_reader_corruption_and_cancellation_order() { + let data = source()[..256].to_vec(); + for version in [0, 1] { + for filter in [None, Some(crate::FilterKind::Delta { channels: 4 })] { + let packed = packed(&data, version, filter); + for cut in [0, 1, 3, packed.len() / 2, packed.len() - 1, packed.len()] { + for fail_at in [0, 1, 2, usize::MAX] { + for cancel_at in [0, 1, 3, 7, 15, usize::MAX] { + let old_token = crate::ReadCancellation::new(); + let actual_token = crate::ReadCancellation::new(); + let mut old = ReaderState::new(&Allowance::default()); + let mut actual = ReaderState::new(&Allowance::default()); + old.read_control = crate::read_control::ReadControl::new(Some(&old_token)); + actual.read_control = + crate::read_control::ReadControl::new(Some(&actual_token)); + old.read_control.cancel_after_checks(cancel_at); + actual.read_control.cancel_after_checks(cancel_at); + let mut old_input = TracedReader::new(&packed[..cut], fail_at); + let mut actual_input = TracedReader::new(&packed[..cut], fail_at); + let expected = result(reference_decode( + &mut old, + &mut old_input, + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut actual_input, + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + ), + ); + assert_eq!(output, expected); + assert_eq!(actual_input.calls, old_input.calls); + assert_eq!(actual_token.is_cancelled(), old_token.is_cancelled()); + let mut expected_state = snapshot(&old); + if output.is_ok() { + expected_state.history.clear(); + expected_state.history_capacity = 0; + } + assert_eq!(snapshot(&actual), expected_state); + } + } + } + } + } +} + +#[test] +fn independent_history_numeric_limits_keep_original_refusal_values_and_state() { + let data = source()[..256].to_vec(); + for filter in [None, Some(crate::FilterKind::Delta { channels: 4 })] { + let packed = packed(&data, 0, filter); + for limit in [0, 32, 128, 512, 2048, 8192, 65536] { + let old_budget = Allowance::limited(limit); + let actual_budget = Allowance::limited(limit); + let mut old = ReaderState::new(&old_budget); + let mut actual = ReaderState::new(&actual_budget); + let expected = result(reference_decode( + &mut old, + &mut Cursor::new(&packed), + 0, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut Cursor::new(&packed), + 0, + data.len(), + 4096, + false, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + ), + ); + assert_eq!(output, expected, "limit={limit}, filter={filter:?}"); + assert_eq!(snapshot(&actual), snapshot(&old)); + assert_eq!(actual_budget.used(), old_budget.used()); + drop(actual); + drop(old); + assert_eq!(actual_budget.used(), 0); + assert_eq!(old_budget.used(), 0); + } + } +} + +#[derive(Clone, Debug, Default)] +struct AllocationTrace(std::sync::Arc>>); +impl Budget for AllocationTrace { + type Charge = Self; + type Failure = std::convert::Infallible; + const LIMITED: bool = false; + fn grow( + values: &mut Vec, + _: &mut Self, + additional: usize, + ) -> std::result::Result<(), Self::Failure> { + values.reserve(additional); + Ok(()) + } + fn charge(&self) -> Self { + self.clone() + } + fn allowance(charge: &Self) -> Self { + charge.clone() + } + fn resize(charge: &mut Self, bytes: u64) -> Result<()> { + charge.0.lock().unwrap().push(bytes); + Ok(()) + } +} + +#[test] +fn independent_history_omits_only_final_explicit_buffer_admissions() { + let data = source(); + for version in [0, 1] { + for filter in filter_cases() { + let packed = packed(&data, version, filter); + let retained = AllocationTrace::default(); + let discarded = AllocationTrace::default(); + let mut old = ReaderState::new(&retained); + let mut actual = ReaderState::new(&discarded); + let expected = result(reference_decode( + &mut old, + &mut Cursor::new(&packed), + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut Cursor::new(&packed), + version, + data.len(), + 4096, + false, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + ), + ); + assert_eq!(output, expected); + assert_eq!(output.unwrap(), data); + assert_eq!(old.history.len(), 4096); + assert_eq!(old.history.capacity(), 4096); + assert!(actual.history.is_empty()); + assert_eq!(actual.history.capacity(), 0); + let old = retained.0.lock().unwrap(); + let actual = discarded.0.lock().unwrap(); + let omitted = if filter.is_some() { 2 } else { 1 }; + assert_eq!(old.len() - actual.len(), omitted); + assert_eq!( + old.iter().sum::() - actual.iter().sum::(), + omitted as u64 * 4096 + ); + // This observes only explicit Buffer capacity admissions, not every + // allocator call or whole-chain peak memory. + } + } +} + +#[test] +fn independent_history_preserves_undersized_window_zero_fill_compatibility() { + let data = source(); + for version in [0, 1] { + let packed = packed(&data, version, None); + let mut old = ReaderState::new(&Allowance::default()); + let mut actual = ReaderState::new(&Allowance::default()); + let expected = result(reference_decode( + &mut old, + &mut Cursor::new(&packed), + version, + data.len(), + 32, + false, + DecodeMode::Lz, + )) + .unwrap(); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut Cursor::new(&packed), + version, + data.len(), + 32, + false, + DecodeMode::Lz, + HistoryRetention::DiscardIndependent, + ), + ) + .unwrap(); + assert_eq!(output, expected); + // The retained original decoder fills an out-of-window reference with + // zeroes. This deliberately undersized codec call is not a source + // roundtrip; archive integrity checks still reject damaged payloads. + assert_ne!(output, data); + assert_eq!(output[96], 0); + assert_eq!(data[96], 0xe8); + let mut old_state = snapshot(&old); + old_state.history.clear(); + old_state.history_capacity = 0; + assert_eq!(snapshot(&actual), old_state); + } +} + +#[test] +fn independent_history_filtered_unknown_version_keeps_validation_and_late_cancel_order() { + let data = source()[..256].to_vec(); + let packed = packed(&data, 0, Some(crate::FilterKind::Delta { channels: 4 })); + for version in [2, 255] { + for dictionary in [0, 4096] { + for mode in [ + DecodeMode::LiteralOnly, + DecodeMode::Lz, + DecodeMode::LzNoFilters, + ] { + for cancel_at in [0, 1, 3, 7, usize::MAX] { + for fail_at in [0, 1, 3, usize::MAX] { + let old_budget = RefusingBudget::new(fail_at); + let actual_budget = RefusingBudget::new(fail_at); + let old_token = crate::ReadCancellation::new(); + let actual_token = crate::ReadCancellation::new(); + let mut old = ReaderState::new(&old_budget); + let mut actual = ReaderState::new(&actual_budget); + old.read_control = crate::read_control::ReadControl::new(Some(&old_token)); + actual.read_control = + crate::read_control::ReadControl::new(Some(&actual_token)); + old.read_control.cancel_after_checks(cancel_at); + actual.read_control.cancel_after_checks(cancel_at); + let mut old_input = TracedReader::new(&packed, usize::MAX); + let mut actual_input = TracedReader::new(&packed, usize::MAX); + let expected = result(reference_decode( + &mut old, + &mut old_input, + version, + data.len(), + dictionary, + false, + mode, + )); + let output = result( + actual.decode_member_from_reader_with_dictionary_and_history( + &mut actual_input, + version, + data.len(), + dictionary, + false, + mode, + HistoryRetention::DiscardIndependent, + ), + ); + assert!(output.is_err()); + assert_eq!(output, expected); + assert_eq!(actual_input.calls, old_input.calls); + assert_eq!(snapshot(&actual), snapshot(&old)); + assert_eq!(actual_token.is_cancelled(), old_token.is_cancelled()); + assert_eq!(actual_budget.attempts(), old_budget.attempts()); + drop(actual); + drop(old); + assert_eq!(actual_budget.used(), 0); + assert_eq!(old_budget.used(), 0); + } + } + } + } + } +} + +// Full unchanged d2 buffered decoding body, independent of history-policy plumbing. +#[allow(clippy::too_many_arguments)] +fn reference_decode( + state: &mut ReaderState, + input: &mut impl Read, + algorithm_version: u8, + output_size: usize, + dictionary_size: usize, + solid: bool, + mode: DecodeMode, +) -> Result> { + state.read_control.check_codec()?; + let control = state.read_control.clone(); + let input = &mut control.reader(input); + if dictionary_size == 0 { + return Err(Error::InvalidData("RAR 5 dictionary size is zero")); + } + if !solid { + state.reset(); + } + + let allowance = state.history.allowance(); + let mut output = + Buffer::with_capacity(output_size.min(MAX_INITIAL_OUTPUT_CAPACITY), &allowance)?; + let mut filters = Buffer::new(&allowance); + + loop { + let block = read_compressed_block_with_allowance(input, &state.history.allowance())?; + let payload = &*block.payload; + let mut payload_bit_pos = 0; + if block.header.has_tables { + let (lengths, table_bits) = read_table_lengths_with_allowance( + payload, + algorithm_version, + &block.payload.allowance(), + )?; + state.tables = Some(ReaderTables::from_lengths( + &lengths, + &block.payload.allowance(), + )?); + payload_bit_pos = table_bits; + } + let tables = state + .tables + .take() + .ok_or(Error::InvalidData("RAR 5 block reuses missing tables"))?; + let mut bits = BitReader::new(payload); + bits.bit_pos = payload_bit_pos; + + let mut poller = state.read_control.poller(); + while bits.bit_pos < block.header.payload_bits && output.len() < output_size { + poller.check_codec(output.len())?; + let symbol = tables.main.decode(&mut bits)?; + match symbol { + 0..=255 => output.try_push(symbol as u8)?, + 256 if mode.uses_lz() => { + filters.try_push(read_filter(&mut bits, output.len())?)?; + } + 257 if mode.uses_lz() => { + if state.last_length != 0 { + state.copy_match( + &mut output, + state.reps[0], + state.last_length, + output_size, + dictionary_size, + )?; + } + } + 258..=261 if mode.uses_lz() => { + let rep_index = symbol - 258; + let distance = state.reps[rep_index]; + if distance == 0 { + return Err(Error::InvalidData( + "RAR 5 repeat distance is not initialized", + )); + } + let length_slot = tables.length.decode(&mut bits)?; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // The length table has 44 symbols and read_bits limits + // the extra value to this slot's declared width. + let length = length_from_slot_parts(length_slot, length_extra); + state.reps[..=rep_index].rotate_right(1); + state.reps[0] = distance; + state.last_length = length; + state.copy_match( + &mut output, + distance, + length, + output_size, + dictionary_size, + )?; + } + 262.. if mode.uses_lz() => { + let length_slot = symbol - 262; + let length_extra = bits.read_bits(length_slot_extra_bits(length_slot))?; + // Main symbols end at slot 43 and read_bits limits the + // extra value to this slot's declared width. + let mut length = length_from_slot_parts(length_slot, length_extra); + let distance_slot = tables.distance.decode(&mut bits)?; + let distance_bit_count = distance_slot_bit_count(distance_slot)?; + let distance_extra = if distance_bit_count >= 4 && tables.align_mode { + let high = bits.read_bits((distance_bit_count - 4) as u8)?; + let low = tables.align.decode(&mut bits)? as u32; + (high << 4) | low + } else { + bits.read_bits(distance_bit_count as u8)? + }; + // distance_slot_bit_count rejected slots above 65 and + // the extra value was read at exactly that width. + let distance = + distance_from_slot_parts(distance_slot, distance_bit_count, distance_extra); + length += length_bonus(distance); + state.reps.rotate_right(1); + state.reps[0] = distance; + state.last_length = length; + state.copy_match( + &mut output, + distance, + length, + output_size, + dictionary_size, + )?; + } + _ => { + return Err(Error::InvalidData( + "RAR 5 literal-only decoder encountered non-literal symbol", + )); + } + } + } + + state.tables = Some(tables); + if block.header.is_last || output.len() >= output_size { + break; + } + } + + if output.len() == output_size { + let history_output = if mode.applies_filters() && !filters.is_empty() { + Some(Buffer::copied( + &output[output.len().saturating_sub(dictionary_size)..], + &allowance, + )?) + } else { + None + }; + if mode.applies_filters() { + state.read_control.check_codec()?; + apply_filters_with_allowance(&mut output, &filters, &state.read_control, &allowance)?; + } + state.remember_history( + history_output.as_deref().unwrap_or(&output), + dictionary_size, + )?; + Ok(output) + } else { + Err(Error::NeedMoreInput) + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/huffman_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/huffman_tests.rs new file mode 100644 index 00000000..e2f38bd0 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/huffman_tests.rs @@ -0,0 +1,23 @@ +use super::*; + +#[test] +fn public_huffman_constructor_rejects_active_alphabet_count_overflow() { + for length in [1, 15] { + for active in [65_535, 65_536, 65_537] { + assert!(matches!( + HuffmanTable::from_lengths(&vec![length; active]), + Err(Error::InvalidData("RAR 5 oversubscribed Huffman table")) + )); + } + } +} + +#[test] +fn public_huffman_constructor_keeps_wide_sparse_symbol_indices() { + let mut lengths = vec![0; 65_538]; + lengths[65_537] = 1; + let table = HuffmanTable::from_lengths(&lengths).unwrap(); + let mut bits = BitReader::new(&[0]); + assert_eq!(table.state.decode(&mut bits), Ok(65_537)); + assert_eq!(bits.bit_pos, 1); +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/literal_pricing_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/literal_pricing_tests.rs new file mode 100644 index 00000000..a7d21a00 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/literal_pricing_tests.rs @@ -0,0 +1,907 @@ +use super::*; +use crate::codec::workspace::RefusingBudget; + +// Retained upstream initialization, reach admission and backtracking. Pricing +// uses the original scalar implementation below, never the literal shortcut. +#[allow(clippy::too_many_arguments)] +fn reference_optimal_tokens( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + matches: &BlockMatches, + workspace: &mut OptimalWorkspace, +) -> Result> { + let start = block.start; + let end = block.end; + let span = end - start; + + let allowance = workspace.price.allowance().clone(); + let OptimalWorkspace { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + } = workspace; + price.resize(span + 1, u32::MAX)?; + price.fill(u32::MAX); + arrive_length.resize(span + 1, 0)?; + arrive_length.fill(0); + arrive_distance.resize(span + 1, 0)?; + arrive_distance.fill(0); + arrive_reps.resize(span + 1, [0; 4])?; + arrive_reps.fill([0; 4]); + arrive_last_length.resize(span + 1, 0)?; + arrive_last_length.fill(0); + price[0] = 0; + + // Admit the largest candidate list once. Pricing only borrows already + // charged arrays, so its inner loop is identical for both budget policies. + // Each position contributes at most four remembered-distance candidates. + let longest_run = matches + .starts + .windows(2) + .map(|pair| (pair[1] - pair[0]) as usize) + .max() + .unwrap_or(0); + // A position contributes at most one run for each encodable match length. + // Four remembered distances are added while pricing, so this bound cannot + // approach usize::MAX for a valid BlockMatches collection. + debug_assert!(longest_run <= MAX_ENCODER_MATCH_LENGTH); + let reach_capacity = longest_run + 4; + let mut reaches = Buffer::filled(reach_capacity, (0usize, 0usize, 0usize), &allowance)?; + reference_price_optimal_paths( + combined, + block.clone(), + options, + distance_size, + prices, + &matches.runs, + &matches.starts, + OptimalSlices { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + }, + &mut reaches, + ); + + let mut reversed = Buffer::new(&allowance); + let mut index = span; + while index > 0 { + let length = arrive_length[index] as usize; + if length == 0 { + reversed + .push(EncodeToken::Literal(combined[start + index - 1])) + .map_err(Into::into)?; + index -= 1; + } else { + reversed + .push(EncodeToken::Match { + length, + distance: arrive_distance[index] as usize, + }) + .map_err(Into::into)?; + index -= length; + } + } + reversed.reverse(); + Ok(reversed) +} + +#[allow(clippy::too_many_arguments)] +fn reference_encode_tokens( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_, B>, + options: EncodeOptions, + distance_size: usize, + initial_filters: &[EncodeFilter], + progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let start = block.start; + let end = block.end; + if options.optimal_parse { + let mut own; + let collector = match search { + MemberSearch::Optimal(collector) => collector, + _ => { + own = OptimalCollector::with_allowance(combined, start, options, allowance)?; + &mut own + } + }; + let matches = collector.collect(combined, block.clone(), options)?; + // The prices come from the Huffman tables, and the tables come from + // the parse, so the first pass has to guess. Each pass after it prices + // against what the pass before actually produced. + let mut workspace = OptimalWorkspace::new(allowance); + let mut tokens = reference_optimal_tokens( + combined, + block.clone(), + options, + distance_size, + None, + &matches, + &mut workspace, + )?; + let mut lengths = + table_lengths_with_allowance(&tokens, initial_filters, distance_size, allowance)?; + let mut best_bits = token_stream_bits(&tokens, initial_filters, &lengths, distance_size)?; + let mut best = None; + for _ in 1..OPTIMAL_PARSE_PASSES { + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let next = reference_optimal_tokens( + combined, + block.clone(), + options, + distance_size, + Some(&prices), + &matches, + &mut workspace, + )?; + if next == tokens { + break; + } + lengths = + table_lengths_with_allowance(&next, initial_filters, distance_size, allowance)?; + let bits = token_stream_bits(&next, initial_filters, &lengths, distance_size)?; + if bits < best_bits { + best_bits = bits; + best = None; + } else if best.is_none() { + // Keep an earlier winner only when repricing actually loses. + best = Some(std::mem::replace(&mut tokens, Buffer::new(allowance))); + } + tokens = next; + } + let tokens = best.unwrap_or(tokens); + if progress.is_some_and(|report| !report(end - start)) { + return Err(Error::Cancelled); + } + return Ok(tokens); + } + + unreachable!("the reference covers only optimal parsing"); +} + +#[allow(clippy::too_many_arguments)] +fn reference_encode_block( + combined: &[u8], + block: std::ops::Range, + search: MemberSearch<'_, B>, + algorithm_version: u8, + initial_filters: &[EncodeFilter], + options: EncodeOptions, + is_last: bool, + progress: Option<&mut dyn FnMut(usize) -> bool>, + allowance: &B, +) -> Result> { + let distance_size = match algorithm_version { + 0 => DISTANCE_TABLE_SIZE_50, + 1 => DISTANCE_TABLE_SIZE_70, + _ => { + return Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version", + )) + } + }; + let mut tokens = reference_encode_tokens( + combined, + block, + search, + options, + distance_size, + initial_filters, + progress, + allowance, + )?; + if !initial_filters.is_empty() { + tokens.prepend(initial_filters.iter().copied().map(EncodeToken::Filter))?; + } + encode_token_block_with_allowance( + &tokens, + algorithm_version, + distance_size, + is_last, + allowance, + ) +} + +fn noise(size: usize) -> Vec { + let mut state = 0x8bad_f00du32; + (0..size) + .map(|_| { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (state >> 24) as u8 + }) + .collect() +} + +fn empty_matches(span: usize, allowance: &B) -> Result> { + Ok(BlockMatches { + runs: Buffer::new(allowance), + starts: Buffer::filled(span + 1, 0, allowance)?, + }) +} + +#[derive(Debug, PartialEq, Eq)] +struct WorkspaceState { + price: Vec, + length: Vec, + distance: Vec, + reps: Vec<[u32; 4]>, + last_length: Vec, +} + +fn workspace_state(workspace: &OptimalWorkspace) -> WorkspaceState { + WorkspaceState { + price: workspace.price.to_vec(), + length: workspace.arrive_length.to_vec(), + distance: workspace.arrive_distance.to_vec(), + reps: workspace.arrive_reps.to_vec(), + last_length: workspace.arrive_last_length.to_vec(), + } +} + +fn poison(workspace: &mut OptimalWorkspace, span: usize) { + workspace.price.resize(span + 1, 0x1234_5678).unwrap(); + workspace.price.fill(0x1234_5678); + workspace.arrive_length.resize(span + 1, 4096).unwrap(); + workspace.arrive_length.fill(4096); + workspace.arrive_distance.resize(span + 1, 257).unwrap(); + workspace.arrive_distance.fill(257); + workspace + .arrive_reps + .resize(span + 1, [3, 3, 7, 3]) + .unwrap(); + workspace.arrive_reps.fill([3, 3, 7, 3]); + workspace.arrive_last_length.resize(span + 1, 511).unwrap(); + workspace.arrive_last_length.fill(511); +} + +#[test] +fn empty_collections_match_the_retained_parser_for_every_price_mode() { + let allowance = Allowance::default(); + for data in [ + Vec::new(), + vec![1], + (0..=255).collect(), + noise(4096), + b"abcd".repeat(1024), + ] { + for start in [0, data.len().min(128)] { + let block = start..data.len(); + for candidates in [0, 128] { + // The candidate-zero case also proves that identical bytes and + // nonzero history cannot invent a remembered distance. + let options = EncodeOptions::new(candidates) + .with_optimal_parse(true) + .with_max_match_distance(if candidates == 0 { usize::MAX } else { 0 }); + let mut collector = OptimalCollector::new(&data, start, options); + let matches = collector.collect(&data, block.clone(), options).unwrap(); + assert!(matches.runs.is_empty()); + for distance_size in [DISTANCE_TABLE_SIZE_50, DISTANCE_TABLE_SIZE_70] { + let mut workspace = OptimalWorkspace::new(&allowance); + let mut old = OptimalWorkspace::new(&allowance); + let literals = reference_optimal_tokens( + &data, + block.clone(), + options, + distance_size, + None, + &matches, + &mut old, + ) + .unwrap(); + let lengths = table_lengths_for_tokens(&literals, distance_size).unwrap(); + let actual = TokenPrices { + lengths: lengths.slices(), + }; + for prices in [None, Some(&actual)] { + poison(&mut workspace, block.len()); + let before = workspace_state(&workspace); + let expected = reference_optimal_tokens( + &data, + block.clone(), + options, + distance_size, + prices, + &matches, + &mut old, + ) + .unwrap(); + let result = optimal_tokens_in_workspace( + &data, + block.clone(), + options, + distance_size, + prices, + &matches, + &mut workspace, + ) + .unwrap(); + assert_eq!(result, expected); + assert_eq!( + workspace_state(&workspace), + before, + "literal shortcut must not initialize or read stale arrays" + ); + assert!(result + .iter() + .all(|token| matches!(token, EncodeToken::Literal(_)))); + } + } + } + } + } +} + +#[test] +fn real_no_match_collections_use_the_shortcut_and_later_matches_reset_poison() { + let allowance = Allowance::default(); + let options = EncodeOptions::new(128).with_optimal_parse(true); + let repeated = b"abcd".repeat(1024); + let literal = noise(repeated.len()); + let mut repeat_collector = OptimalCollector::new(&repeated, 0, options); + let repeat_matches = repeat_collector + .collect(&repeated, 0..repeated.len(), options) + .unwrap(); + assert!(!repeat_matches.runs.is_empty()); + let mut literal_collector = OptimalCollector::new(&literal, 0, options); + let literal_matches = literal_collector + .collect(&literal, 0..literal.len(), options) + .unwrap(); + assert!( + literal_matches.runs.is_empty(), + "fixture must really contain no collected four-byte match" + ); + for distance_size in [DISTANCE_TABLE_SIZE_50, DISTANCE_TABLE_SIZE_70] { + let mut workspace = OptimalWorkspace::new(&allowance); + let mut old = OptimalWorkspace::new(&allowance); + for (data, matches) in [ + (&repeated, &repeat_matches), + (&literal, &literal_matches), + (&repeated, &repeat_matches), + ] { + poison(&mut workspace, repeated.len()); + poison(&mut old, repeated.len()); + let before = workspace_state(&workspace); + let expected = reference_optimal_tokens( + data, + 0..data.len(), + options, + distance_size, + None, + matches, + &mut old, + ) + .unwrap(); + let result = optimal_tokens_in_workspace( + data, + 0..data.len(), + options, + distance_size, + None, + matches, + &mut workspace, + ) + .unwrap(); + assert_eq!(result, expected); + if matches.runs.is_empty() { + assert_eq!(workspace_state(&workspace), before); + } else { + assert_eq!(workspace_state(&workspace), workspace_state(&old)); + } + } + } +} + +#[test] +fn literal_pipeline_keeps_filters_winner_selection_and_packed_bytes() { + let allowance = Allowance::default(); + let input = noise(4096); + let specs = [ + crate::FilterSpec::whole(crate::FilterKind::Delta { channels: 4 }), + crate::FilterSpec::whole(crate::FilterKind::Arm), + ]; + for candidates in [0, 128] { + let options = EncodeOptions::new(candidates).with_optimal_parse(true); + for version in [0, 1] { + for specs in [&[][..], &specs[..1], &specs[1..]] { + let (transformed, records) = + filtered_member_with_allowance(&input, specs, &allowance).unwrap(); + let mut collector = OptimalCollector::new(&transformed, 0, options); + let matches = collector + .collect(&transformed, 0..transformed.len(), options) + .unwrap(); + assert!(matches.runs.is_empty()); + let expected = reference_encode_block( + &transformed, + 0..transformed.len(), + MemberSearch::Fresh, + version, + &records, + options, + true, + None, + &allowance, + ) + .unwrap(); + let actual = Unpack50Encoder::with_options(options) + .encode_member_with_filters(&input, version, specs) + .unwrap(); + assert_eq!(&*expected, actual); + let decoded = Unpack50Decoder::new() + .decode_member(&actual, version, input.len(), false, DecodeMode::Lz) + .unwrap(); + assert_eq!(decoded, input); + } + } + } +} + +#[test] +fn literal_pipeline_retains_validation_before_final_progress_and_cancellation() { + let allowance = Allowance::default(); + let data: Vec<_> = (0..32).collect(); + let options = EncodeOptions::new(128).with_optimal_parse(true); + let valid = EncodeFilter { + offset: 0, + length: data.len(), + filter_type: FilterType::Delta, + channels: 1, + }; + let invalid = EncodeFilter { + channels: 0, + ..valid + }; + for version in [0, 1, 2] { + for records in [&[][..], &[valid][..], &[invalid][..]] { + for continue_work in [true, false] { + let mut expected_reports = Vec::new(); + let mut expected_report = |amount| { + expected_reports.push(amount); + continue_work + }; + let expected = reference_encode_block( + &data, + 0..data.len(), + MemberSearch::Fresh, + version, + records, + options, + true, + Some(&mut expected_report), + &allowance, + ) + .map(|buffer| buffer.to_vec()); + let mut actual_reports = Vec::new(); + let mut actual_report = |amount| { + actual_reports.push(amount); + continue_work + }; + let actual = encode_lz_block_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + version, + records, + options, + true, + Some(&mut actual_report), + &allowance, + ) + .map(|buffer| buffer.to_vec()); + assert_eq!(actual, expected); + assert_eq!(actual_reports, expected_reports); + if version > 1 || records == [invalid] { + assert!(actual_reports.is_empty()); + assert!(matches!(actual, Err(Error::InvalidData(_)))); + } else { + assert_eq!(actual_reports, [data.len()]); + if !continue_work { + assert!(matches!(actual, Err(Error::Cancelled))); + } + } + } + } + } +} + +fn bounded_parse( + allowance: &B, + old: bool, +) -> (Result>, WorkspaceState) { + let data: Vec<_> = (0..32).collect(); + let options = EncodeOptions::new(128).with_optimal_parse(true); + let mut workspace = OptimalWorkspace::new(allowance); + let result = (|| { + let matches = empty_matches(data.len(), allowance)?; + if old { + reference_optimal_tokens( + &data, + 0..data.len(), + options, + DISTANCE_TABLE_SIZE_50, + None, + &matches, + &mut workspace, + ) + } else { + optimal_tokens_in_workspace( + &data, + 0..data.len(), + options, + DISTANCE_TABLE_SIZE_50, + None, + &matches, + &mut workspace, + ) + } + })() + .map(|buffer| buffer.to_vec()); + (result, workspace_state(&workspace)) +} + +#[test] +fn bounded_literal_parses_preserve_all_quota_failures_and_growth_attempts() { + let mut saw_limit = false; + let mut saw_success = false; + for limit in [0, 32, 128, 132, 256, 512, 1024, 2048, 4096, 65536] { + let expected_budget = Allowance::limited(limit); + let actual_budget = Allowance::limited(limit); + let expected = bounded_parse(&expected_budget, true); + let actual = bounded_parse(&actual_budget, false); + saw_limit |= matches!(actual.0, Err(Error::WorkspaceLimitExceeded(_))); + saw_success |= actual.0.is_ok(); + assert_eq!(actual, expected, "limit={limit}"); + assert_eq!(actual_budget.used(), expected_budget.used()); + assert_eq!( + actual_budget.used(), + 0, + "all owned charges must be released" + ); + } + assert!(saw_limit && saw_success); + let mut saw_refusal = false; + let mut saw_success = false; + for fail_at in 0..24 { + let expected_budget = RefusingBudget::new(fail_at); + let actual_budget = RefusingBudget::new(fail_at); + let expected = bounded_parse(&expected_budget, true); + let actual = bounded_parse(&actual_budget, false); + saw_refusal |= matches!(actual.0, Err(Error::Cancelled)); + saw_success |= actual.0.is_ok(); + assert_eq!(actual, expected, "growth refusal={fail_at}"); + assert_eq!(actual_budget.attempts(), expected_budget.attempts()); + assert_eq!(actual_budget.used(), expected_budget.used()); + assert_eq!(actual_budget.used(), 0); + } + assert!(saw_refusal && saw_success); +} + +#[test] +fn bounded_outer_pipeline_keeps_errors_before_progress() { + let data: Vec<_> = (0..32).collect(); + let options = EncodeOptions::new(128).with_optimal_parse(true); + for limit in [0, 128, 4096, 65536, 8 * 1024 * 1024] { + let mut expected_reports = Vec::new(); + let mut expected_report = |amount| { + expected_reports.push(amount); + false + }; + let expected = reference_encode_block( + &data, + 0..data.len(), + MemberSearch::Fresh, + 0, + &[], + options, + true, + Some(&mut expected_report), + &Allowance::limited(limit), + ) + .map(|buffer| buffer.to_vec()); + let mut actual_reports = Vec::new(); + let mut actual_report = |amount| { + actual_reports.push(amount); + false + }; + let actual = encode_lz_block_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + 0, + &[], + options, + true, + Some(&mut actual_report), + &Allowance::limited(limit), + ) + .map(|buffer| buffer.to_vec()); + assert_eq!(actual, expected, "limit={limit}"); + assert_eq!(actual_reports, expected_reports); + } +} + +#[test] +fn literal_outer_pipeline_matches_old_parses_for_history_tails_and_real_matches() { + let allowance = Allowance::default(); + let mut rare_repeat = noise(4096); + rare_repeat.copy_within(128..144, 192); + let cases = [ + Vec::new(), + vec![7], + (0..32).collect(), + (0..=255).collect(), + noise(4096), + b"abcd".repeat(8), + rare_repeat, + ]; + let mut saw_empty = false; + let mut saw_matches = false; + for data in cases { + for start in [0, data.len().min(3), data.len().min(128)] { + for candidates in [0, 128] { + let options = EncodeOptions::new(candidates).with_optimal_parse(true); + let mut collector = OptimalCollector::new(&data, start, options); + let matches = collector + .collect(&data, start..data.len(), options) + .unwrap(); + saw_empty |= matches.runs.is_empty(); + saw_matches |= !matches.runs.is_empty(); + for distance_size in [DISTANCE_TABLE_SIZE_50, DISTANCE_TABLE_SIZE_70] { + for continue_work in [true, false] { + let mut expected_reports = Vec::new(); + let mut expected_report = |amount| { + expected_reports.push(amount); + continue_work + }; + let expected = reference_encode_tokens( + &data, + start..data.len(), + MemberSearch::Fresh, + options, + distance_size, + &[], + Some(&mut expected_report), + &allowance, + ); + let mut actual_reports = Vec::new(); + let mut actual_report = |amount| { + actual_reports.push(amount); + continue_work + }; + let actual = encode_tokens_with_allowance( + &data, + start..data.len(), + MemberSearch::Fresh, + options, + distance_size, + &[], + Some(&mut actual_report), + &allowance, + ); + assert_eq!(actual, expected, "start={start}, candidates={candidates}"); + assert_eq!(actual_reports, expected_reports); + assert_eq!(actual_reports, [data.len() - start]); + } + } + } + } + } + assert!(saw_empty && saw_matches); +} + +#[test] +fn bounded_outer_reparses_keep_every_growth_refusal_and_callback() { + let data: Vec<_> = (0..32).collect(); + let options = EncodeOptions::new(128).with_optimal_parse(true); + let mut saw_refusal = false; + let mut saw_success = false; + for fail_at in 0..128 { + for continue_work in [true, false] { + let expected_budget = RefusingBudget::new(fail_at); + let actual_budget = RefusingBudget::new(fail_at); + let mut expected_reports = Vec::new(); + let mut expected_report = |amount| { + expected_reports.push(amount); + continue_work + }; + let expected = reference_encode_block( + &data, + 0..data.len(), + MemberSearch::Fresh, + 0, + &[], + options, + true, + Some(&mut expected_report), + &expected_budget, + ) + .map(|buffer| buffer.to_vec()); + let mut actual_reports = Vec::new(); + let mut actual_report = |amount| { + actual_reports.push(amount); + continue_work + }; + let actual = encode_lz_block_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + 0, + &[], + options, + true, + Some(&mut actual_report), + &actual_budget, + ) + .map(|buffer| buffer.to_vec()); + saw_refusal |= expected_reports.is_empty() && matches!(actual, Err(Error::Cancelled)); + saw_success |= actual.is_ok(); + assert_eq!( + actual, expected, + "fail_at={fail_at}, continue={continue_work}" + ); + assert_eq!(actual_reports, expected_reports); + assert_eq!(actual_budget.attempts(), expected_budget.attempts()); + assert_eq!(actual_budget.used(), expected_budget.used()); + assert_eq!(actual_budget.used(), 0); + } + } + assert!(saw_refusal && saw_success); +} + +// Retain the original upstream scalar pricing loop as an independent oracle. +#[allow(clippy::too_many_arguments)] +fn reference_price_optimal_paths( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + runs: &[(u32, u32)], + starts: &[u32], + workspace: OptimalSlices<'_>, + reaches: &mut [(usize, usize, usize)], +) { + let start = block.start; + let end = block.end; + let span = end - start; + let OptimalSlices { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + } = workspace; + // The first position past a match the parse committed to. Nothing is + // priced from the positions before it. See [`NICE_MATCH_LENGTH`]. + let mut committed_through = 0usize; + + for index in 0..span { + let pos = start + index; + if index < committed_through { + continue; + } + // Every priced position extends a literal path to its successor; + // a committed match skips only to an already priced endpoint. Blocks + // are at most 1 MiB, so even all 15-bit literals stay below u32::MAX. + let here = price[index]; + let literal_cost = prices.map_or(ESTIMATED_LITERAL_COST, |prices| { + prices.literal(combined[pos]) as u32 + }); + let literal = here.saturating_add(literal_cost); + if literal < price[index + 1] { + price[index + 1] = literal; + arrive_length[index + 1] = 0; + arrive_distance[index + 1] = 0; + // A literal emits no distance, so it leaves the remembered ones + // exactly as it found them. + arrive_reps[index + 1] = arrive_reps[index]; + arrive_last_length[index + 1] = arrive_last_length[index]; + } + + let max_distance = pos.min(options.max_match_distance); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_distance == 0 || max_length < 4 { + continue; + } + + let state = EncoderMatchState { + reps: arrive_reps[index].map(|distance| distance as usize), + last_length: arrive_last_length[index] as usize, + }; + + let mut reaches_len = 0; + let mut longest = 0usize; + + // A match at a remembered distance is priced out of the main table + // alone, a handful of bits against twenty for a fresh distance, so it + // earns its place even when it is shorter than anything the collector + // found. The collector only reports a candidate that beats the longest + // found so far, so these have to be asked for separately. + for repeat in state.reps { + if repeat == 0 || repeat > max_distance { + continue; + } + let length = match_length(combined, pos, repeat, max_length); + if length >= 4 { + reaches[reaches_len] = (4, length, repeat); + reaches_len += 1; + } + } + + // The collector reports nearest first, so the first distance to reach + // a length is the cheapest one that can. Each report that improves on + // the longest so far owns one run of lengths. The tree measures + // against the whole member where the chains stopped at the block, so + // a length is capped here to what this block can still hold. + for &(length, distance) in &runs[starts[index] as usize..starts[index + 1] as usize] { + let length = (length as usize).min(max_length); + if length > longest { + reaches[reaches_len] = (longest + 1, length, distance as usize); + reaches_len += 1; + longest = length; + } + } + + let reaches = &reaches[..reaches_len]; + + // Equal token prices do not make shorter matches redundant: their + // endpoints can expose a better continuation. Price every endpoint + // unless the explicit long-match heuristic commits past all of them. + let committed_reach = reaches + .iter() + .map(|&(_, end, _)| end) + .max() + .filter(|&length| length >= NICE_MATCH_LENGTH); + for &(run_start, run_end, distance) in reaches.iter() { + let mut length = run_start.max(4); + if let Some(committed) = committed_reach { + if run_end < committed { + continue; + } + length = committed; + } + while length <= run_end { + let reach = length; + let cost = match prices { + Some(prices) => prices.match_cost(&state, reach, distance, distance_size), + None => estimated_match_cost(&state, reach, distance, distance_size), + }; + if let Ok(cost) = cost { + let reached = here.saturating_add(cost as u32); + let target = index + reach; + if reached < price[target] { + price[target] = reached; + arrive_length[target] = reach as u32; + arrive_distance[target] = distance as u32; + let mut next = state; + next.remember(reach, distance); + arrive_reps[target] = next.reps.map(|distance| distance as u32); + arrive_last_length[target] = next.last_length as u32; + } + } + length = reach + 1; + } + } + + // A committed match is at least 512 bytes long. Even after the + // distance bonus, that length and every collected u32 distance fit + // their encoder tables, so the endpoint has already been priced. + let longest_reach = reaches.iter().map(|&(_, length, _)| length).max(); + if let Some(reach) = longest_reach { + if reach >= NICE_MATCH_LENGTH { + committed_through = index + reach; + } + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/pricing_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/pricing_tests.rs new file mode 100644 index 00000000..55b25e11 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/pricing_tests.rs @@ -0,0 +1,344 @@ +use super::*; + +#[test] +fn prepared_run_prices_preserve_every_length_and_distance_boundary() { + let distances = [0, 1, 3, 4, 5, 256, 257, 8192, 8193, 262144, 262145, 1 << 22]; + let states = [ + EncoderMatchState::default(), + EncoderMatchState { + reps: [1, 257, 8193, 262145], + last_length: 511, + }, + EncoderMatchState { + reps: [3, 3, 7, 3], + last_length: 4, + }, + ]; + for seed in [0, 1, 7] { + let codes = |size: usize| { + (0..size) + .map(|symbol| ((symbol * seed + seed) & 15) as u8) + .collect::>() + }; + let main = codes(MAIN_TABLE_SIZE); + let distance = codes(DISTANCE_TABLE_SIZE_70); + let align = codes(ALIGN_TABLE_SIZE); + let length = codes(LENGTH_TABLE_SIZE); + let actual = TokenPrices { + lengths: LengthSlices { + main: &main, + distance: &distance, + align: &align, + length: &length, + }, + }; + for prices in [None, Some(&actual)] { + let prepared = OptimalMatchPrices::new(prices); + for distance_size in [DISTANCE_TABLE_SIZE_50, DISTANCE_TABLE_SIZE_70] { + for state in states { + for distance in distances { + let run = prepared.run(&state, distance, distance_size, prices).ok(); + for length in 1..=MAX_ENCODER_MATCH_LENGTH { + let expected = match prices { + Some(prices) => { + prices.match_cost(&state, length, distance, distance_size) + } + None => { + estimated_match_cost(&state, length, distance, distance_size) + } + } + .ok() + .map(|cost| cost as u32); + assert_eq!( + run.as_ref().and_then(|run| run.cost(length)), + expected, + "seed={seed}, actual={}, state={state:?}, distance={distance}, length={length}, table={distance_size}", + prices.is_some(), + ); + } + } + } + } + } + } +} + +#[test] +#[cfg(target_pointer_width = "64")] +fn prepared_run_prices_refuse_unencodable_fresh_distances() { + let prepared = OptimalMatchPrices::new(None); + let state = EncoderMatchState::default(); + for (distance, size) in [ + (1usize << 40, DISTANCE_TABLE_SIZE_50), + ((1usize << 33) + 1, DISTANCE_TABLE_SIZE_70), + ] { + assert!(prepared.run(&state, distance, size, None).is_err()); + assert!(estimated_match_cost(&state, 5, distance, size).is_err()); + } +} + +#[derive(Debug, PartialEq)] +struct Paths { + price: Vec, + length: Vec, + distance: Vec, + reps: Vec<[u32; 4]>, + last_length: Vec, +} + +impl Paths { + fn new(span: usize) -> Self { + let mut price = vec![u32::MAX; span + 1]; + price[0] = 0; + Self { + price, + length: vec![0; span + 1], + distance: vec![0; span + 1], + reps: vec![[0; 4]; span + 1], + last_length: vec![0; span + 1], + } + } + + fn slices(&mut self) -> OptimalSlices<'_> { + OptimalSlices { + price: &mut self.price, + arrive_length: &mut self.length, + arrive_distance: &mut self.distance, + arrive_reps: &mut self.reps, + arrive_last_length: &mut self.last_length, + } + } +} + +#[test] +fn prepared_pricing_preserves_all_paths_and_remembered_state() { + let mut random = 0x1234_5678u32; + let noise: Vec<_> = (0..4096) + .map(|_| { + random = random.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (random >> 31) as u8 + }) + .collect(); + let mut text = Vec::new(); + for i in 0..80 { + text.extend_from_slice(b"the same match exposes different continuations "); + text.push(i); + } + for data in [ + vec![0; 4096], + b"abc".repeat(1366), + text, + noise, + (0..1024u32) + .flat_map(|word| (word * 71).to_le_bytes()) + .collect(), + ] { + for start in [0, 256] { + let block = start..data.len(); + for candidates in [0, 16, 128] { + let options = EncodeOptions::new(candidates).with_optimal_parse(true); + let mut collector = OptimalCollector::new(&data, start, options); + let matches = collector.collect(&data, block.clone(), options).unwrap(); + let capacity = matches + .starts + .windows(2) + .map(|pair| (pair[1] - pair[0]) as usize) + .max() + .unwrap_or(0) + + 4; + for distance_size in [DISTANCE_TABLE_SIZE_50, DISTANCE_TABLE_SIZE_70] { + let mut workspace = OptimalWorkspace::new(&Allowance::default()); + let tokens = optimal_tokens_in_workspace( + &data, + block.clone(), + options, + distance_size, + None, + &matches, + &mut workspace, + ) + .unwrap(); + let lengths = table_lengths_for_tokens(&tokens, distance_size).unwrap(); + let actual = TokenPrices { + lengths: lengths.slices(), + }; + for prices in [None, Some(&actual)] { + let mut expected = Paths::new(block.len()); + let mut result = Paths::new(block.len()); + let mut reaches = vec![(0, 0, 0); capacity]; + reference_price_optimal_paths( + &data, + block.clone(), + options, + distance_size, + prices, + &matches.runs, + &matches.starts, + expected.slices(), + &mut reaches, + ); + price_optimal_paths( + &data, + block.clone(), + options, + distance_size, + prices, + &matches.runs, + &matches.starts, + result.slices(), + &mut reaches, + ); + assert_eq!(result, expected, "start={start}, candidates={candidates}, table={distance_size}, actual={}", prices.is_some()); + } + } + } + } + } +} + +// Independent pre-hoisting implementation retained for differential checks. +#[allow(clippy::too_many_arguments)] +fn reference_price_optimal_paths( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + runs: &[(u32, u32)], + starts: &[u32], + workspace: OptimalSlices<'_>, + reaches: &mut [(usize, usize, usize)], +) { + let start = block.start; + let end = block.end; + let span = end - start; + let OptimalSlices { + price, + arrive_length, + arrive_distance, + arrive_reps, + arrive_last_length, + } = workspace; + // The first position past a match the parse committed to. Nothing is + // priced from the positions before it. See [`NICE_MATCH_LENGTH`]. + let mut committed_through = 0usize; + + for index in 0..span { + let pos = start + index; + if index < committed_through { + continue; + } + // Every priced position extends a literal path to its successor; + // a committed match skips only to an already priced endpoint. Blocks + // are at most 1 MiB, so even all 15-bit literals stay below u32::MAX. + let here = price[index]; + let literal_cost = prices.map_or(ESTIMATED_LITERAL_COST, |prices| { + prices.literal(combined[pos]) as u32 + }); + let literal = here.saturating_add(literal_cost); + if literal < price[index + 1] { + price[index + 1] = literal; + arrive_length[index + 1] = 0; + arrive_distance[index + 1] = 0; + // A literal emits no distance, so it leaves the remembered ones + // exactly as it found them. + arrive_reps[index + 1] = arrive_reps[index]; + arrive_last_length[index + 1] = arrive_last_length[index]; + } + + let max_distance = pos.min(options.max_match_distance); + let max_length = (end - pos).min(MAX_ENCODER_MATCH_LENGTH); + if options.max_match_candidates == 0 || max_distance == 0 || max_length < 4 { + continue; + } + + let state = EncoderMatchState { + reps: arrive_reps[index].map(|distance| distance as usize), + last_length: arrive_last_length[index] as usize, + }; + + let mut reaches_len = 0; + let mut longest = 0usize; + + // A match at a remembered distance is priced out of the main table + // alone, a handful of bits against twenty for a fresh distance, so it + // earns its place even when it is shorter than anything the collector + // found. The collector only reports a candidate that beats the longest + // found so far, so these have to be asked for separately. + for repeat in state.reps { + if repeat == 0 || repeat > max_distance { + continue; + } + let length = match_length(combined, pos, repeat, max_length); + if length >= 4 { + reaches[reaches_len] = (4, length, repeat); + reaches_len += 1; + } + } + + // The collector reports nearest first, so the first distance to reach + // a length is the cheapest one that can. Each report that improves on + // the longest so far owns one run of lengths. The tree measures + // against the whole member where the chains stopped at the block, so + // a length is capped here to what this block can still hold. + for &(length, distance) in &runs[starts[index] as usize..starts[index + 1] as usize] { + let length = (length as usize).min(max_length); + if length > longest { + reaches[reaches_len] = (longest + 1, length, distance as usize); + reaches_len += 1; + longest = length; + } + } + + let reaches = &reaches[..reaches_len]; + + // Equal token prices do not make shorter matches redundant: their + // endpoints can expose a better continuation. Price every endpoint + // unless the explicit long-match heuristic commits past all of them. + let committed_reach = reaches + .iter() + .map(|&(_, end, _)| end) + .max() + .filter(|&length| length >= NICE_MATCH_LENGTH); + for &(run_start, run_end, distance) in reaches.iter() { + let mut length = run_start.max(4); + if let Some(committed) = committed_reach { + if run_end < committed { + continue; + } + length = committed; + } + while length <= run_end { + let reach = length; + let cost = match prices { + Some(prices) => prices.match_cost(&state, reach, distance, distance_size), + None => estimated_match_cost(&state, reach, distance, distance_size), + }; + if let Ok(cost) = cost { + let reached = here.saturating_add(cost as u32); + let target = index + reach; + if reached < price[target] { + price[target] = reached; + arrive_length[target] = reach as u32; + arrive_distance[target] = distance as u32; + let mut next = state; + next.remember(reach, distance); + arrive_reps[target] = next.reps.map(|distance| distance as u32); + arrive_last_length[target] = next.last_length as u32; + } + } + length = reach + 1; + } + } + + // A committed match is at least 512 bytes long. Even after the + // distance bonus, that length and every collected u32 distance fit + // their encoder tables, so the endpoint has already been priced. + let longest_reach = reaches.iter().map(|&(_, length, _)| length).max(); + if let Some(reach) = longest_reach { + if reach >= NICE_MATCH_LENGTH { + committed_through = index + reach; + } + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/streaming_copy_tests.rs b/arca-rar/vendor/rars/src/codec/rar50/streaming_copy_tests.rs new file mode 100644 index 00000000..d777f16d --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/streaming_copy_tests.rs @@ -0,0 +1,227 @@ +use super::*; +use std::convert::Infallible; + +fn append_chunk(decoded: &mut Vec, chunk: DecodedChunk<'_>) { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => decoded.resize(decoded.len() + len, byte), + } +} + +fn reference_match(history: &[u8], pending: &[u8], distance: usize, length: usize) -> Vec { + let mut bytes = [history, pending].concat(); + let missing = distance == 0 || distance > bytes.len(); + for _ in 0..length { + let byte = if missing { + 0 + } else { + bytes[bytes.len() - distance] + }; + bytes.push(byte); + } + bytes[history.len()..].to_vec() +} + +#[test] +fn buffered_matches_equal_scalar_with_history_pending_overlap_and_missing_history() { + for history_len in 0..=6 { + let history: Vec<_> = (0..history_len).map(|n| n as u8 + 11).collect(); + let mut decoder = ReaderState::new(&Allowance::default()); + decoder.history = Buffer::from_vec(history.clone()); + for pending_len in 0..=6 { + let pending: Vec<_> = (0..pending_len).map(|n| n as u8 + 31).collect(); + for distance in 0..=history_len + pending_len + 2 { + for length in [0, 1, 2, 3, 7, 32, 129] { + let mut output = Buffer::from_vec(pending.clone()); + decoder + .copy_match(&mut output, distance, length, pending_len + length, 32) + .unwrap(); + assert_eq!( + &*output, + reference_match(&history, &pending, distance, length), + "history={history_len}, pending={pending_len}, distance={distance}, length={length}" + ); + } + } + } + } +} + +#[test] +fn buffered_overlap_preserves_output_limit_and_workspace_refusal() { + let budget = Allowance::limited(128); + let decoder = ReaderState::new(&budget); + let mut output = Buffer::with_capacity(128, &budget).unwrap(); + output.extend_from_slice(b"ab").unwrap(); + decoder.copy_match(&mut output, 2, 126, 128, 128).unwrap(); + assert_eq!(&*output, b"ab".repeat(64)); + assert_eq!(budget.used(), 128); + assert!(matches!( + decoder.copy_match(&mut output, 2, 1, 128, 128), + Err(Error::InvalidData("RAR 5 match exceeds output limit")) + )); + assert!(matches!( + decoder.copy_match(&mut output, 2, 1, 129, 128), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(&*output, b"ab".repeat(64)); + assert_eq!(budget.used(), 128); + drop(output); + drop(decoder); + assert_eq!(budget.used(), 0); +} + +#[test] +fn streaming_matches_equal_scalar_with_history_pending_overlap_and_missing_history() { + for history_len in 0..=6 { + let history: Vec<_> = (0..history_len).map(|n| n as u8 + 11).collect(); + for pending_len in 0..=6 { + let pending: Vec<_> = (0..pending_len).map(|n| n as u8 + 31).collect(); + for distance in 1..=history_len + pending_len + 2 { + for length in [0, 1, 2, 3, 7, 32, 129] { + let mut output = StreamingOutput::new( + Buffer::from_vec(history.clone()), + pending_len + length, + 32, + 32, + ) + .unwrap(); + let mut decoded = Vec::new(); + let mut sink = |chunk: DecodedChunk<'_>| { + append_chunk(&mut decoded, chunk); + Ok::<(), Infallible>(()) + }; + for &byte in &pending { + output.push(byte, &mut sink).unwrap(); + } + output.copy_match(distance, length, &mut sink).unwrap(); + output.finish(&mut sink).unwrap(); + assert_eq!( + decoded, + reference_match(&history, &pending, distance, length), + "history={history_len}, pending={pending_len}, distance={distance}, length={length}" + ); + } + } + } + } +} + +#[test] +fn streaming_match_crosses_both_wrapped_history_slices_and_multiple_flushes() { + let count = 2 * STREAM_FLUSH_THRESHOLD + 37; + let mut history = Buffer::with_capacity(16, &Allowance::default()).unwrap(); + history + .extend_from_slice(&(1..=12).collect::>()) + .unwrap(); + let mut output = StreamingOutput::new(history, count + 3, 16, 16).unwrap(); + output.history.discard_prefix(8); + output.history.extend_admitted(31..39); + assert!(!output.history.as_slices().1.is_empty()); + let history: Vec<_> = output.history.iter().copied().collect(); + let pending = [91, 92, 93]; + let mut decoded = Vec::new(); + let mut chunks = Vec::new(); + let mut sink = |chunk: DecodedChunk<'_>| { + chunks.push(match chunk { + DecodedChunk::Bytes(bytes) => bytes.len(), + DecodedChunk::Repeated { len, .. } => len, + }); + append_chunk(&mut decoded, chunk); + Ok::<(), Infallible>(()) + }; + for byte in pending { + output.push(byte, &mut sink).unwrap(); + } + output.copy_match(12, count, &mut sink).unwrap(); + output.finish(&mut sink).unwrap(); + assert_eq!(decoded, reference_match(&history, &pending, 12, count)); + assert_eq!(chunks, [STREAM_FLUSH_THRESHOLD, STREAM_FLUSH_THRESHOLD, 40]); + assert_eq!(output.written(), decoded.len()); + assert_eq!( + output.into_history().into_vec(), + decoded[decoded.len() - 16..] + ); +} + +#[test] +fn streaming_match_stops_on_the_first_failed_flush() { + let mut output = StreamingOutput::new( + Buffer::from_vec(b"abc".to_vec()), + STREAM_FLUSH_THRESHOLD + 7, + 3, + 3, + ) + .unwrap(); + let mut calls = 0; + assert!(matches!( + output.copy_match(3, STREAM_FLUSH_THRESHOLD + 7, &mut |_chunk| { + calls += 1; + Err("failed sink") + }), + Err(StreamDecodeError::Sink("failed sink")) + )); + assert_eq!(calls, 1); + assert_eq!(output.written(), STREAM_FLUSH_THRESHOLD); + assert_eq!(output.pending.len(), STREAM_FLUSH_THRESHOLD); + assert_eq!( + &*output.history, + &std::collections::VecDeque::from(b"abc".to_vec()) + ); +} + +#[test] +fn streaming_match_uses_only_its_admitted_pending_and_history_storage() { + let budget = Allowance::limited((STREAM_FLUSH_THRESHOLD + 16) as u64); + let mut history = Buffer::with_capacity(16, &budget).unwrap(); + history.extend_from_slice(b"abcdefghijklmnop").unwrap(); + let count = 2 * STREAM_FLUSH_THRESHOLD + 5; + let mut output = StreamingOutput::new(history, count, 16, 16).unwrap(); + let mut observed = 0; + let mut sink = |chunk: DecodedChunk<'_>| { + observed += match chunk { + DecodedChunk::Bytes(bytes) => bytes.len(), + DecodedChunk::Repeated { len, .. } => len, + }; + Ok::<(), Infallible>(()) + }; + output.copy_match(7, count, &mut sink).unwrap(); + output.finish(&mut sink).unwrap(); + assert_eq!(observed, count); + assert_eq!(budget.used(), (STREAM_FLUSH_THRESHOLD + 16) as u64); + drop(output); + assert_eq!(budget.used(), 0); +} + +#[cfg(feature = "write")] +#[test] +fn streaming_match_flush_preserves_decoder_cancellation() { + let data: Vec<_> = b"abc" + .iter() + .copied() + .cycle() + .take(3 * STREAM_FLUSH_THRESHOLD) + .collect(); + let input = Unpack50Encoder::new().encode_member(&data, 0).unwrap(); + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack50Decoder::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + let mut calls = 0; + let result = decoder.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + data.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| { + calls += 1; + token.cancel(); + Ok::<(), Infallible>(()) + }, + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::Cancelled)) + )); + assert_eq!(calls, 1); +} diff --git a/arca-rar/vendor/rars/src/codec/rar50/tests.rs b/arca-rar/vendor/rars/src/codec/rar50/tests.rs new file mode 100644 index 00000000..c7d38c88 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rar50/tests.rs @@ -0,0 +1,5770 @@ +use crate::codec::workspace::RefusingBudget; + +fn assert_each_allocation_refusal( + mut work: impl FnMut(&RefusingBudget) -> crate::codec::Result, +) -> usize { + let baseline = RefusingBudget::new(usize::MAX); + drop(work(&baseline).unwrap()); + let attempts = baseline.attempts(); + assert!(attempts > 0); + assert_eq!(baseline.used(), 0); + + for fail_at in 0..attempts { + let budget = RefusingBudget::new(fail_at); + assert!( + matches!(work(&budget), Err(Error::Cancelled)), + "failure at allocation {fail_at}" + ); + assert_eq!(budget.used(), 0, "failure at allocation {fail_at}"); + } + attempts +} + +#[test] +fn reader_workspace_refusals_release_buffered_filters_and_checkpoints() { + let data = b"raw reader dictionary and filtered output\n".repeat(32); + for kind in [ + crate::FilterKind::E8, + crate::FilterKind::Delta { channels: 2 }, + ] { + let packed = Unpack50Encoder::new() + .encode_member_with_filter(&data, 0, crate::FilterSpec::whole(kind)) + .unwrap(); + let attempts = assert_each_allocation_refusal(|budget| { + let mut state = ReaderState::new(budget); + let decoded = state.decode_member_with_dictionary( + &packed, + 0, + data.len(), + 64, + false, + DecodeMode::Lz, + )?; + assert_eq!(&*decoded, &data); + let checkpoint = state.try_clone()?; + assert_eq!(checkpoint.history, state.history); + assert_eq!( + checkpoint.tables.as_ref().unwrap().main.state.len(), + state.tables.as_ref().unwrap().main.state.len() + ); + Ok(decoded) + }); + assert!(attempts > 15); + } +} + +#[test] +fn reader_workspace_refusals_release_streaming_history_and_input() { + let data = b"streaming reader window\n".repeat(4000); + let packed = encode_literal_only(&data, 0).unwrap(); + let attempts = assert_each_allocation_refusal(|budget| { + let mut state = ReaderState::new(budget); + let mut emitted = 0; + let result = state.decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + data.len(), + 1024, + false, + |chunk| { + emitted += match chunk { + DecodedChunk::Bytes(bytes) => bytes.len(), + DecodedChunk::Repeated { len, .. } => len, + }; + Ok::<(), std::convert::Infallible>(()) + }, + ); + match result { + Ok(()) => { + assert_eq!(emitted, data.len()); + assert_eq!(&*state.history, &data[data.len() - 1024..]); + Ok(()) + } + Err(StreamDecodeError::Decode(error)) => Err(error), + Err(_) => panic!("unexpected streaming failure"), + } + }); + assert!(attempts > 8); +} + +#[test] +fn reader_workspace_retained_output_and_checkpoint_remain_charged() { + let data = b"retained reader result".repeat(20); + let packed = encode_literal_only(&data, 0).unwrap(); + let ledger = Allowance::limited(256 * 1024); + let mut state = ReaderState::new(&ledger); + let output = state + .decode_member_with_dictionary(&packed, 0, data.len(), 64, false, DecodeMode::Lz) + .unwrap(); + let owners = ledger.used(); + let checkpoint = state.try_clone().unwrap(); + assert!(ledger.used() > owners); + drop(state); + assert!(ledger.used() > output.capacity() as u64); + drop(checkpoint); + assert_eq!(ledger.used(), output.capacity() as u64); + assert_eq!(&*output, &data); + drop(output); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn reader_workspace_history_replacement_admits_overlap_before_mutating() { + let ledger = Allowance::limited(8); + let mut state = ReaderState::new(&ledger); + state.remember_history(b"ABCDEFGH", 8).unwrap(); + assert_eq!(ledger.used(), 8); + assert!(matches!( + state.remember_history(b"xy", 2), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(&*state.history, b"ABCDEFGH"); + assert_eq!(ledger.used(), 8); + drop(state); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn bounded_reader_admits_input_before_reading_and_releases_on_errors() { + struct Source<'a> { + bytes: std::io::Cursor<&'a [u8]>, + reads: usize, + } + impl Read for Source<'_> { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + self.reads += 1; + self.bytes.read(buffer) + } + } + let data: Vec<_> = (0..8192).map(|i| ((i * 71) ^ (i >> 5)) as u8).collect(); + let options = EncodeOptions::new(16).with_max_match_distance(1024); + let denied = Allowance::limited(0); + let mut source = Source { + bytes: std::io::Cursor::new(&data), + reads: 0, + }; + let error = reader_to_with_allowance( + &mut source, + data.len() as u64, + &mut std::io::sink(), + 0, + options, + 256, + None, + &denied, + ) + .unwrap_err(); + assert!(matches!( + error, + crate::Error::Codec(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(source.reads, 0); + assert_eq!(denied.used(), 0); + + let allowance = Allowance::limited(8 * 1024 * 1024); + let mut output = Vec::new(); + reader_to_with_allowance( + &mut std::io::Cursor::new(&data), + data.len() as u64, + &mut output, + 0, + options, + 256, + None, + &allowance, + ) + .unwrap(); + assert_eq!(decode_lz(&output, 0, data.len()).unwrap(), data); + assert_eq!(allowance.used(), 0); + for declared in [data.len() as u64 - 1, data.len() as u64 + 1] { + assert!(reader_to_with_allowance( + &mut std::io::Cursor::new(&data), + declared, + &mut std::io::sink(), + 0, + options, + 256, + None, + &allowance + ) + .is_err()); + assert_eq!(allowance.used(), 0); + } + let mut prefix = Vec::new(); + assert!(matches!( + reader_to_with_allowance( + &mut std::io::Cursor::new(&data), + data.len() as u64, + &mut prefix, + 0, + options, + 256, + Some(&mut |_| false), + &allowance + ), + Err(crate::Error::Cancelled) + )); + assert!( + !prefix.is_empty(), + "streaming refusal can leave an emitted prefix" + ); + assert_eq!(allowance.used(), 0); +} + +#[test] +fn filtered_state_owns_transform_scratch_history_and_outputs() { + let data: Vec<_> = (0..FILTERED_LZ_BLOCK_SIZE + 257) + .map(|i| ((i * 17) ^ (i >> 9)) as u8) + .collect(); + for version in [0, 1] { + for optimal in [false, true] { + let options = EncodeOptions::new(16) + .with_optimal_parse(optimal) + .with_max_match_distance(8192); + for size in [4096, data.len()] { + for kind in [ + crate::FilterKind::Delta { channels: 3 }, + crate::FilterKind::E8E9, + crate::FilterKind::Arm, + ] { + let filters = [crate::FilterSpec::whole(kind)]; + let allowance = Allowance::limited(16 * 1024 * 1024); + let mut state = EncoderState::new(options, &allowance); + let mut reference = Unpack50Encoder::with_options(options); + let expected = reference + .encode_member_with_filters(&data[..size], version, &filters) + .unwrap(); + let packed = state + .encode(&data[..size], version, Some(&filters), None) + .unwrap(); + assert_eq!(&*packed, expected); + assert_eq!(&*state.history, &data[size.saturating_sub(8192)..size]); + drop(packed); + let history_charge = allowance.used(); + assert!(history_charge >= state.history.len() as u64); + let following = state.encode(b"next member", version, None, None).unwrap(); + assert_eq!( + &*following, + reference.encode_member(b"next member", version).unwrap() + ); + drop(state); + assert!(allowance.used() >= following.len() as u64); + drop(following); + assert_eq!(allowance.used(), 0); + } + } + } + } +} + +#[test] +fn delta_scratch_refusal_does_not_modify_caller_input_or_leak_records() { + let input = [7u8; 512]; + let filters = [crate::FilterSpec::whole(crate::FilterKind::Delta { + channels: 3, + })]; + let records = std::mem::size_of::() as u64; + for limit in [1024 + records - 1, 1024 + records] { + let allowance = Allowance::limited(limit); + let result = filtered_member_with_allowance(&input, &filters, &allowance); + assert_eq!(input, [7; 512]); + if limit == 1024 + records - 1 { + assert!(matches!(result, Err(Error::WorkspaceLimitExceeded(_)))); + assert_eq!(allowance.used(), 0); + } else { + let (data, descriptors) = result.unwrap(); + assert_eq!(allowance.used(), 512 + records); + assert_eq!(descriptors.len(), 1); + assert_eq!( + filters::delta_decode_with_control( + &data, + 3, + rar50_delta_messages(), + &crate::read_control::ReadControl::default() + ) + .unwrap(), + input + ); + drop((data, descriptors)); + assert_eq!(allowance.used(), 0); + } + } +} + +#[test] +fn failed_stateful_encodes_preserve_history_and_allow_reuse() { + let allowance = Allowance::limited(4 * 1024 * 1024); + let options = EncodeOptions::new(16) + .with_optimal_parse(true) + .with_max_match_distance(128); + let mut state = EncoderState::new(options, &allowance); + drop(state.encode(b"existing history", 0, None, None).unwrap()); + let previous = state.history.to_vec(); + let retained = allowance.used(); + let blocker = + Buffer::filled((4 * 1024 * 1024 - retained - 64) as usize, 0u8, &allowance).unwrap(); + assert!(matches!( + state.encode(b"refused input", 0, None, None), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(&*state.history, previous); + drop(blocker); + assert_eq!(allowance.used(), retained); + let filters = [crate::FilterSpec::whole(crate::FilterKind::E8)]; + assert!(matches!( + state.encode(b"cancelled input", 0, Some(&filters), Some(&mut |_| false)), + Err(Error::Cancelled) + )); + assert_eq!(&*state.history, previous); + assert_eq!(allowance.used(), retained); + let unwind = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _ = state.encode( + b"callback panic", + 0, + Some(&filters), + Some(&mut |_| panic!("callback")), + ); + })); + assert!(unwind.is_err()); + assert_eq!(&*state.history, previous); + assert_eq!(allowance.used(), retained); + drop(state.encode(b"successful retry", 0, None, None).unwrap()); + assert!(state.history.ends_with(b"successful retry")); + drop(state); + assert_eq!(allowance.used(), 0); +} + +#[test] +fn streaming_results_remain_owned_and_cancelled_runs_release_all_blocks() { + let data: Vec<_> = (0..8192).map(|i| (i * 71) as u8).collect(); + let blocks = [(2048, false), (4096, false), (8192, true)]; + for optimal in [false, true] { + let allowance = Allowance::limited(8 * 1024 * 1024); + let options = EncodeOptions::new(16) + .with_optimal_parse(optimal) + .with_max_match_distance(1024); + let expected = + encode_lz_streaming_blocks(&data, b"prior history", &blocks, 0, options, None).unwrap(); + let outputs = streaming_blocks_with_allowance( + &data, + b"prior history", + &blocks, + 0, + options, + None, + &allowance, + ) + .unwrap(); + for (actual, expected) in outputs.iter().zip(expected) { + assert_eq!(&**actual, expected); + } + let mut outputs = outputs.into_iter(); + let first = outputs.next().unwrap(); + drop(outputs); + assert!(allowance.used() >= first.len() as u64); + drop(first); + assert_eq!(allowance.used(), 0); + assert!(matches!( + streaming_blocks_with_allowance( + &data, + &[], + &blocks, + 0, + options, + Some(&mut |_| false), + &allowance + ), + Err(Error::Cancelled) + )); + assert_eq!(allowance.used(), 0); + assert!(streaming_blocks_with_allowance( + &data, + &[], + &[(9000, true)], + 0, + options, + None, + &allowance + ) + .is_err()); + assert_eq!(allowance.used(), 0); + } +} + +#[test] +fn streaming_block_plan_rejects_gaps_and_invalid_ends() { + let data = b"ABCD"; + let options = EncodeOptions::new(0); + let allowance = Allowance::default(); + for blocks in [ + vec![(0, false)], + vec![(5, true)], + vec![(2, false), (2, true)], + ] { + assert!(matches!( + streaming_blocks_with_allowance(data, &[], &blocks, 0, options, None, &allowance,), + Err(Error::InvalidData("RAR 5 streaming block range is invalid")) + )); + } + assert!(matches!( + streaming_blocks_with_allowance(data, &[], &[(2, false)], 0, options, None, &allowance,), + Err(Error::InvalidData( + "RAR 5 streaming blocks do not cover input" + )) + )); +} + +#[test] +fn streaming_block_encode_errors_release_first_and_shared_search_state() { + let data = b"ABCD"; + let blocks = [(2, false), (4, true)]; + let expected = Error::InvalidData("RAR 5 unknown compression algorithm version"); + for (optimal, history) in [(true, &b""[..]), (true, &b"prior"[..]), (false, &b""[..])] { + let allowance = Allowance::limited(32 * 1024 * 1024); + let options = EncodeOptions::new(0).with_optimal_parse(optimal); + assert_eq!( + streaming_blocks_with_allowance(data, history, &blocks, 2, options, None, &allowance,), + Err(expected.clone()), + "optimal={optimal}, history={history:?}" + ); + assert_eq!(allowance.used(), 0); + } +} + +#[test] +fn empty_streaming_member_has_no_blocks_or_progress() { + let options = EncodeOptions::new(0).with_optimal_parse(true); + let allowance = Allowance::limited(0); + let mut called = false; + let mut progress = |_: usize| { + called = true; + true + }; + let output = + streaming_blocks_with_allowance(&[], &[], &[], 0, options, Some(&mut progress), &allowance) + .unwrap(); + assert!(output.is_empty()); + assert!(!called); + assert_eq!(allowance.used(), 0); +} + +#[test] +fn member_allowance_covers_history_tables_and_retained_block_output() { + let data = b"bounded member with repeated words and short matches\n".repeat(3000); + let history = b"short matches and remembered history\n".repeat(1000); + for version in [0, 1] { + for optimal in [false, true] { + let options = EncodeOptions::new(16) + .with_optimal_parse(optimal) + .with_max_match_distance(65536); + for history in [&[][..], &history[..]] { + let expected = + encode_lz_member_inner(&data, history, version, options, None).unwrap(); + let allowance = Allowance::limited(32 * 1024 * 1024); + let output = encode_member_with_allowance( + &data, history, version, options, None, &allowance, + ) + .unwrap(); + assert_eq!(&*output, expected); + assert!(allowance.used() >= output.len() as u64); + let retained = allowance.used(); + let second = encode_member_with_allowance( + b"another member", + &[], + version, + options, + None, + &allowance, + ) + .unwrap(); + assert!(allowance.used() >= retained + second.len() as u64); + drop(second); + assert_eq!(allowance.used(), retained); + drop(output); + assert_eq!(allowance.used(), 0); + } + } + } +} + +#[test] +fn large_member_search_setup_failures_release_the_allowance() { + let data = vec![b'A'; LZ_BLOCK_SIZE + 1]; + let filters = [crate::FilterSpec::whole(crate::FilterKind::E8)]; + for optimal in [false, true] { + let options = EncodeOptions::new(0).with_optimal_parse(optimal); + + let unfiltered = Allowance::limited(0); + assert!(matches!( + encode_member_with_allowance(&data, &[], 0, options, None, &unfiltered,), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(unfiltered.used(), 0); + + for limit in [128, data.len() as u64 + 4096] { + let filtered = Allowance::limited(limit); + assert!(matches!( + filtered_lz_blocks(&data, &filters, &[], 0, options, None, &filtered), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(filtered.used(), 0); + } + } +} + +#[test] +fn optimal_parse_pass_failures_release_the_allowance() { + let data: Vec = (0..512).map(|i| (i * 71) as u8).collect(); + let options = EncodeOptions::new(16).with_optimal_parse(true); + // The first limit fails while building the initial optimal path; the + // second permits that path but fails while repricing it. + for limit in [1_080_000, 1_105_000] { + let allowance = Allowance::limited(limit); + assert!(matches!( + encode_member_with_allowance(&data, &[], 0, options, None, &allowance), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(allowance.used(), 0); + } +} + +#[test] +fn member_refusal_cancellation_and_unwind_release_the_whole_pipeline() { + let data = b"member cancellation and refusal\n".repeat(100); + let history = b"history".repeat(100); + let options = EncodeOptions::new(16).with_optimal_parse(true); + for limit in [0, 4096, 65536, 512 * 1024] { + let allowance = Allowance::limited(limit); + assert!(matches!( + encode_member_with_allowance(&data, &history, 0, options, None, &allowance), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(allowance.used(), 0); + } + let allowance = Allowance::limited(16 * 1024 * 1024); + assert!(matches!( + encode_member_with_allowance( + &data, + &history, + 0, + options, + Some(&mut |_| false), + &allowance + ), + Err(Error::Cancelled) + )); + assert_eq!(allowance.used(), 0); + let unwind = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _ = encode_member_with_allowance( + &data, + &history, + 0, + options, + Some(&mut |_| panic!("progress callback panic")), + &allowance, + ); + })); + assert!(unwind.is_err()); + assert_eq!(allowance.used(), 0); +} + +#[test] +fn bit_growth_and_frame_copy_reserve_before_mutation() { + let allowance = Allowance::limited(8); + let mut writer = BitWriter::with_allowance(&allowance); + writer.try_write_bits(0, 64).unwrap(); + let filled = writer.bytes.to_vec(); + let filled_bits = writer.bit_pos; + assert!(writer.try_write_bits(1, 1).is_err()); + assert_eq!(&*writer.bytes, filled); + assert_eq!(writer.bit_pos, filled_bits); + drop(writer); + assert_eq!(allowance.used(), 0); + + for limit in [18, 19] { + let allowance = Allowance::limited(limit); + let payload = Buffer::filled(8, 0u8, &allowance).unwrap(); + let frame = encode_compressed_block_with_allowance(&payload, 64, true, true, &allowance); + if limit == 18 { + assert!(matches!(frame, Err(Error::WorkspaceLimitExceeded(_)))); + assert_eq!(allowance.used(), 8); + } else { + let frame = frame.unwrap(); + assert_eq!(allowance.used(), 19); + drop(payload); + assert_eq!(allowance.used(), 11); + drop(frame); + assert_eq!(allowance.used(), 0); + } + } +} + +#[test] +fn token_block_budget_refusals_release_all_encoder_owners() { + let base = [ + EncodeToken::Literal(b'A'), + EncodeToken::Literal(b'B'), + EncodeToken::Match { + length: 2, + distance: 2, + }, + EncodeToken::Match { + length: 2, + distance: 2, + }, + EncodeToken::Match { + length: 3, + distance: 2, + }, + ]; + + for filtered in [false, true] { + let mut tokens = Vec::new(); + if filtered { + tokens.push(EncodeToken::Filter(EncodeFilter { + offset: 0, + length: 9, + filter_type: FilterType::E8, + channels: 0, + })); + } + tokens.extend_from_slice(&base); + tokens.extend(std::iter::repeat_n(EncodeToken::Literal(b'A'), 100)); + let expected = encode_token_block(&tokens, 0, DISTANCE_TABLE_SIZE_50, true).unwrap(); + let mut decoded = b"ABABABABA".to_vec(); + decoded.extend(std::iter::repeat_n(b'A', 100)); + assert_eq!(decode_lz(&expected, 0, decoded.len()).unwrap(), decoded); + + let mut limit = 0; + let mut refusals = 0; + let mut admitted = false; + for _ in 0..256 { + let allowance = Allowance::limited(limit); + match encode_token_block_with_allowance( + &tokens, + 0, + DISTANCE_TABLE_SIZE_50, + true, + &allowance, + ) { + Err(Error::WorkspaceLimitExceeded(details)) => { + refusals += 1; + assert_eq!(allowance.used(), 0); + let next = details.used + details.required; + assert!(next > limit); + limit = next; + } + Ok(encoded) => { + assert_eq!(&*encoded, expected); + drop(encoded); + assert_eq!(allowance.used(), 0); + admitted = true; + break; + } + Err(error) => panic!("unexpected token block error: {error:?}"), + } + } + assert!( + admitted, + "token block did not fit after 256 admission thresholds" + ); + assert!(refusals > 1); + + let baseline_budget = RefusingBudget::new(usize::MAX); + let baseline = encode_token_block_with_allowance( + &tokens, + 0, + DISTANCE_TABLE_SIZE_50, + true, + &baseline_budget, + ) + .unwrap(); + assert_eq!(&*baseline, expected); + let attempts = baseline_budget.attempts(); + drop(baseline); + assert_eq!(baseline_budget.used(), 0); + assert!(attempts > 1); + + for fail_at in 0..attempts { + let budget = RefusingBudget::new(fail_at); + assert_eq!( + encode_token_block_with_allowance( + &tokens, + 0, + DISTANCE_TABLE_SIZE_50, + true, + &budget, + ), + Err(Error::Cancelled), + "filtered={filtered}, failure at allocation {fail_at}" + ); + assert_eq!(budget.used(), 0); + } + } +} + +#[test] +fn member_allocation_refusals_release_search_and_output_owners() { + let data = b"ABCDABCDABCDABCD".repeat(16); + let filters = [EncodeFilter { + offset: 0, + length: data.len(), + filter_type: FilterType::E8, + channels: 0, + }]; + + for optimal in [false, true] { + let options = EncodeOptions::new(16) + .with_max_match_distance(256) + .with_optimal_parse(optimal); + let expected = + encode_member_with_allowance(&data, &[], 0, options, None, &Allowance::default()) + .unwrap(); + assert_eq!(decode_lz(&expected, 0, data.len()).unwrap(), data); + let attempts = assert_each_allocation_refusal(|budget| { + encode_member_with_allowance(&data, &[], 0, options, None, budget) + }); + assert!(attempts > 1); + + let expected = encode_filtered_member_with_allowance( + &data, + &[], + 0, + &filters, + options, + None, + &Allowance::default(), + ) + .unwrap(); + assert_eq!(decode_lz(&expected, 0, data.len()).unwrap(), data); + let attempts = assert_each_allocation_refusal(|budget| { + encode_filtered_member_with_allowance(&data, &[], 0, &filters, options, None, budget) + }); + assert!(attempts > 1); + + let blocks = [(data.len() / 2, false), (data.len(), true)]; + let expected = streaming_blocks_with_allowance( + &data, + &[], + &blocks, + 0, + options, + None, + &Allowance::default(), + ) + .unwrap(); + let packed: Vec<_> = expected + .iter() + .flat_map(|block| block.iter().copied()) + .collect(); + assert_eq!(decode_lz(&packed, 0, data.len()).unwrap(), data); + let attempts = assert_each_allocation_refusal(|budget| { + streaming_blocks_with_allowance(&data, &[], &blocks, 0, options, None, budget) + }); + assert!(attempts > 1); + + let specs = [crate::FilterSpec::whole(crate::FilterKind::E8)]; + let expected = + filtered_lz_blocks(&data, &specs, &[], 0, options, None, &Allowance::default()) + .unwrap(); + assert_eq!(decode_lz(&expected, 0, data.len()).unwrap(), data); + let attempts = assert_each_allocation_refusal(|budget| { + filtered_lz_blocks(&data, &specs, &[], 0, options, None, budget) + }); + assert!(attempts > 1); + } +} + +#[test] +fn filtered_multiblock_output_growth_refusals_release_storage() { + let data = vec![b'A'; FILTERED_LZ_BLOCK_SIZE + 1]; + let filters = [crate::FilterSpec::whole(crate::FilterKind::E8)]; + let options = EncodeOptions::new(16).with_max_match_distance(256); + let expected = filtered_lz_blocks( + &data, + &filters, + &[], + 0, + options, + None, + &Allowance::default(), + ) + .unwrap(); + assert_eq!(decode_lz(&expected, 0, data.len()).unwrap(), data); + assert_each_allocation_refusal(|budget| { + filtered_lz_blocks(&data, &filters, &[], 0, options, None, budget) + }); +} + +#[test] +fn member_history_and_large_output_refusals_release_storage() { + let data: Vec = (0..2048) + .map(|index| ((index * 71) ^ (index >> 3)) as u8) + .collect(); + let history = vec![0xee; 256]; + let blocks = [(data.len() / 2, false), (data.len(), true)]; + let filters = [EncodeFilter { + offset: 0, + length: data.len(), + filter_type: FilterType::E8, + channels: 0, + }]; + + for optimal in [false, true] { + let options = EncodeOptions::new(16) + .with_max_match_distance(history.len()) + .with_optimal_parse(optimal); + assert_each_allocation_refusal(|budget| { + streaming_blocks_with_allowance(&data, &history, &blocks, 0, options, None, budget) + }); + assert_each_allocation_refusal(|budget| { + encode_filtered_member_with_allowance( + &data, &history, 0, &filters, options, None, budget, + ) + }); + assert_each_allocation_refusal(|budget| { + let mut state = EncoderState::new(options, budget); + state.encode(&data, 0, None, None) + }); + } + + let large = vec![b'A'; LZ_BLOCK_SIZE + 1]; + let options = EncodeOptions::new(16).with_max_match_distance(256); + let expected = + encode_member_with_allowance(&large, &[], 0, options, None, &Allowance::default()).unwrap(); + assert_eq!(decode_lz(&expected, 0, large.len()).unwrap(), large); + assert_each_allocation_refusal(|budget| { + encode_member_with_allowance(&large, &[], 0, options, None, budget) + }); +} + +#[test] +fn parse_repricing_and_lazy_literal_refusals_release_storage() { + let optimal_data = wordy_text(4096); + let optimal = EncodeOptions::new(32).with_optimal_parse(true); + assert_each_allocation_refusal(|budget| { + encode_tokens_with_allowance( + &optimal_data, + 0..optimal_data.len(), + MemberSearch::Fresh, + optimal, + DISTANCE_TABLE_SIZE_50, + &[], + None, + budget, + ) + }); + + let pos = 160; + let mut lazy_data: Vec = (0..240u16) + .map(|value| value.wrapping_mul(91) as u8) + .collect(); + lazy_data[pos - 30..pos - 22].copy_from_slice(b"ABCDEFGH"); + lazy_data[pos - 80..pos - 70].copy_from_slice(b"CDEFGHIJKL"); + lazy_data[pos..pos + 12].copy_from_slice(b"ABCDEFGHIJKL"); + let lazy = EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(2); + let tokens = encode_tokens_with_allowance( + &lazy_data, + pos..lazy_data.len(), + MemberSearch::Fresh, + lazy, + DISTANCE_TABLE_SIZE_50, + &[], + None, + &Allowance::default(), + ) + .unwrap(); + assert!(matches!(tokens.first(), Some(EncodeToken::Literal(_)))); + assert_each_allocation_refusal(|budget| { + encode_tokens_with_allowance( + &lazy_data, + pos..lazy_data.len(), + MemberSearch::Fresh, + lazy, + DISTANCE_TABLE_SIZE_50, + &[], + None, + budget, + ) + }); + + assert_each_allocation_refusal(|budget| EncoderCodeTable::from_lengths(&[1, 1], budget)); +} + +#[test] +fn production_limited_budget_covers_residual_allocation_sites() { + let denied = Allowance::limited(0); + assert!(matches!( + EncoderCodeTable::from_lengths(&[1, 1], &denied), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(denied.used(), 0); + + let mut noise = 0x2545_f491_4f6c_dd1du64; + let data: Vec = (0..4096) + .map(|_| { + noise ^= noise << 13; + noise ^= noise >> 7; + noise ^= noise << 17; + b'A' + ((noise >> 40) as u8 & 1) + }) + .collect(); + let options = EncodeOptions::new(64).with_optimal_parse(true); + for start in [0, data.len() / 2] { + let probe = Allowance::limited(64 * 1024 * 1024); + let collector = OptimalCollector::with_allowance(&data, start, options, &probe).unwrap(); + let finder_bytes = probe.used(); + drop(collector); + assert_eq!(probe.used(), 0); + + let span = data.len() - start; + let run_bytes = span * std::mem::size_of::<(u32, u32)>(); + let initial_bytes = run_bytes + (span + 1) * std::mem::size_of::(); + for limit in [ + finder_bytes + run_bytes as u64 - 1, + finder_bytes + initial_bytes as u64 - 1, + finder_bytes + initial_bytes as u64, + ] { + let allowance = Allowance::limited(limit); + let mut collector = + OptimalCollector::with_allowance(&data, start, options, &allowance).unwrap(); + assert!(matches!( + collector.collect(&data, start..data.len(), options), + Err(Error::WorkspaceLimitExceeded(_)) + )); + drop(collector); + assert_eq!(allowance.used(), 0); + } + } + + let input = b"state history must be admitted after its packed output"; + let options = EncodeOptions::new(0).with_max_match_distance(32); + let mut limit = 0u64; + let mut refusals = 0; + loop { + let allowance = Allowance::limited(limit); + let mut state = EncoderState::new(options, &allowance); + match state.encode(input, 0, None, None) { + Err(Error::WorkspaceLimitExceeded(details)) => { + refusals += 1; + let next = details.used + details.required; + assert!(next > limit); + limit = next; + } + Ok(packed) => { + assert_eq!(&*state.history, &input[input.len() - 32..]); + drop((packed, state)); + assert_eq!(allowance.used(), 0); + break; + } + Err(error) => panic!("unexpected state error: {error:?}"), + } + } + assert!(refusals > 1); +} + +#[test] +fn token_block_allocation_refusals_cover_each_control_form() { + let filter = EncodeToken::Filter(EncodeFilter { + offset: 0, + length: 1, + filter_type: FilterType::E8, + channels: 0, + }); + let mut filters = vec![filter; 256]; + filters.push(EncodeToken::Literal(b'A')); + + let mut last_length = vec![ + EncodeToken::Literal(b'A'), + EncodeToken::Match { + length: 2, + distance: 1, + }, + ]; + last_length.extend(std::iter::repeat_n( + EncodeToken::Match { + length: 2, + distance: 1, + }, + 256, + )); + + let mut repeat_distance = last_length[..2].to_vec(); + repeat_distance.extend((0..256).map(|index| EncodeToken::Match { + length: 3 + index % 2, + distance: 1, + })); + + let mut new_distance = vec![EncodeToken::Literal(b'A'); 100]; + new_distance.extend((0..256).map(|index| EncodeToken::Match { + length: 10, + distance: 70 + index % 5, + })); + + for (tokens, output_size) in [ + (filters, 1), + (last_length, 1 + 2 * 257), + (repeat_distance, 3 + 128 * (3 + 4)), + (new_distance, 100 + 256 * 10), + ] { + let packed = encode_token_block(&tokens, 0, DISTANCE_TABLE_SIZE_50, true).unwrap(); + assert_eq!( + decode_lz(&packed, 0, output_size).unwrap(), + vec![b'A'; output_size] + ); + assert_each_allocation_refusal(|budget| { + encode_token_block_with_allowance(&tokens, 0, DISTANCE_TABLE_SIZE_50, true, budget) + }); + } +} + +#[test] +fn filter_writer_allocation_refusals_cover_filter_type_bits() { + for filter_type in [ + FilterType::Delta, + FilterType::E8, + FilterType::E8E9, + FilterType::Arm, + ] { + let filter = EncodeFilter { + offset: 0, + length: 1, + filter_type, + channels: 1, + }; + for prefix_bits in [9, 12] { + let mut expected = BitWriter::new(); + expected.write_bits(0, prefix_bits); + try_write_filter(&mut expected, filter).unwrap(); + let expected = expected.finish(); + + let baseline = RefusingBudget::new(usize::MAX); + let mut writer = BitWriter::with_allowance(&baseline); + writer.try_write_bits(0, prefix_bits).unwrap(); + try_write_filter(&mut writer, filter).unwrap(); + assert_eq!(&*writer.bytes, expected); + drop(writer); + assert_eq!(baseline.used(), 0); + + assert_each_allocation_refusal(|budget| { + let mut writer = BitWriter::with_allowance(budget); + writer.try_write_bits(0, prefix_bits)?; + try_write_filter(&mut writer, filter)?; + Ok(writer.bytes) + }); + } + } +} + +#[test] +fn table_level_writer_refusals_release_bit_storage() { + let mut isolated_zeroes = [1u8; LEVEL_TABLE_SIZE]; + for index in (1..LEVEL_TABLE_SIZE).step_by(2) { + isolated_zeroes[index] = 0; + } + let mut offset_zero_runs = [1u8; LEVEL_TABLE_SIZE]; + for start in (1..LEVEL_TABLE_SIZE).step_by(4) { + offset_zero_runs[start..(start + 3).min(LEVEL_TABLE_SIZE)].fill(0); + } + for lengths in [ + [0u8; LEVEL_TABLE_SIZE], + isolated_zeroes, + offset_zero_runs, + [15u8; LEVEL_TABLE_SIZE], + ] { + for prefix_bits in 0..=16 { + let mut expected = BitWriter::new(); + expected.write_bits(0, prefix_bits); + try_write_level_lengths(&mut expected, &lengths).unwrap(); + let expected = expected.finish(); + + let baseline = RefusingBudget::new(usize::MAX); + let mut writer = BitWriter::with_allowance(&baseline); + writer.try_write_bits(0, prefix_bits).unwrap(); + try_write_level_lengths(&mut writer, &lengths).unwrap(); + assert_eq!(&*writer.bytes, expected); + drop(writer); + assert_eq!(baseline.used(), 0); + + assert_each_allocation_refusal(|budget| { + let mut writer = BitWriter::with_allowance(budget); + writer.try_write_bits(0, prefix_bits)?; + try_write_level_lengths(&mut writer, &lengths)?; + Ok(writer.bytes) + }); + } + } +} + +#[test] +fn table_run_refusals_release_token_storage() { + for count in [3, 10, 11, 138, 139, 1000] { + assert_each_allocation_refusal(|budget| { + let mut tokens = Buffer::new(budget); + emit_repeat_level_run(&mut tokens, count)?; + Ok(tokens) + }); + } + for count in [1, 3, 10, 11, 139, 1000] { + assert_each_allocation_refusal(|budget| { + let mut tokens = Buffer::new(budget); + emit_zero_level_run(&mut tokens, count)?; + Ok(tokens) + }); + } +} + +#[test] +fn filter_preparation_rejects_legacy_only_kinds() { + let data = b"plain bytes"; + let filters = [crate::FilterSpec::whole(crate::FilterKind::Itanium)]; + let expected = Error::InvalidData("RAR 5 has no builtin type for this filter"); + assert_eq!( + normalized_filter_specs(data.len(), &filters, &Allowance::default()), + Err(expected.clone()) + ); + assert_eq!( + filtered_member_with_allowance(data, &filters, &Allowance::default()), + Err(expected) + ); +} + +#[test] +fn parser_allowance_preserves_tokens_and_retains_the_returned_owner() { + let data: Vec<_> = (0..8192u32) + .map(|n| (n.wrapping_mul(71) ^ (n >> 4)) as u8) + .collect(); + for optimal in [false, true] { + let options = EncodeOptions::new(32) + .with_max_match_distance(65536) + .with_optimal_parse(optimal); + let expected = encode_tokens_with_progress( + &data, + 0..data.len(), + MemberSearch::Fresh, + options, + DISTANCE_TABLE_SIZE_50, + &[], + None, + ) + .unwrap(); + let allowance = Allowance::limited(16 * 1024 * 1024); + for _ in 0..3 { + let tokens = encode_tokens_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + options, + DISTANCE_TABLE_SIZE_50, + &[], + None, + &allowance, + ) + .unwrap(); + assert_eq!(tokens, expected); + let retained = allowance.used(); + assert!(retained >= (tokens.len() * std::mem::size_of::()) as u64); + assert!(retained > 0); + assert!(matches!( + Buffer::::with_capacity( + (16 * 1024 * 1024 - retained + 1) as usize, + &allowance + ), + Err(Error::WorkspaceLimitExceeded(_)) + )); + drop(tokens); + assert_eq!(allowance.used(), 0); + } + } +} + +#[test] +fn parser_refusal_and_cancellation_release_finders_matches_and_parse_arrays() { + let data: Vec<_> = (0..16384u32) + .map(|n| (n.wrapping_mul(73) ^ (n >> 3)) as u8) + .collect(); + for optimal in [false, true] { + let options = EncodeOptions::new(32) + .with_max_match_distance(65536) + .with_optimal_parse(optimal); + for limit in [0, 524288] { + let allowance = Allowance::limited(limit); + let result = encode_tokens_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + options, + DISTANCE_TABLE_SIZE_50, + &[], + None, + &allowance, + ); + assert!(matches!(result, Err(Error::WorkspaceLimitExceeded(_)))); + assert_eq!(allowance.used(), 0); + } + if optimal { + // Admit the tree itself, then refuse match/parse workspace. + let allowance = Allowance::limited(1_200_000); + assert!( + matches!(encode_tokens_with_allowance(&data, 0..data.len(), MemberSearch::Fresh, + options, DISTANCE_TABLE_SIZE_50, &[], None, &allowance), + Err(Error::WorkspaceLimitExceeded(details)) if details.used > 1_000_000) + ); + assert_eq!(allowance.used(), 0); + } + let allowance = Allowance::limited(16 * 1024 * 1024); + assert!(matches!( + encode_tokens_with_allowance( + &data, + 0..data.len(), + MemberSearch::Fresh, + options, + DISTANCE_TABLE_SIZE_50, + &[], + Some(&mut |_| false), + &allowance + ), + Err(Error::Cancelled) + )); + assert_eq!(allowance.used(), 0); + } +} + +#[test] +fn lazy_parser_honors_cancellation_at_final_progress_report() { + let allowance = Allowance::default(); + let data = b"AB"; + let mut reports = 0; + let result = encode_tokens_with_allowance( + data, + 0..data.len(), + MemberSearch::Fresh, + EncodeOptions::new(0), + DISTANCE_TABLE_SIZE_50, + &[], + Some(&mut |_| { + reports += 1; + reports == 1 + }), + &allowance, + ); + + assert_eq!(result, Err(Error::Cancelled)); + assert_eq!(reports, 2); +} + +#[test] +fn configured_x86_scanning_matches_default_across_poll_boundaries() { + let mut input = vec![0; 192 * 1024]; + for pos in [65530, 65535, 65541, 131070, 131080] { + input[pos] = 0xe9; + input[pos + 1..pos + 5].copy_from_slice(&123456u32.to_le_bytes()); + } + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + let mut expected = input.clone(); + e8e9_decode(&mut expected, 4096, true); + e8e9_decode_with_control(&mut input, 4096, true, &control).unwrap(); + assert_eq!(input, expected); +} + +#[test] +fn e8_decoder_adjusts_wrapped_negative_addresses() { + let mut data = [0xe8, 0xff, 0xff, 0xff, 0xff]; + + e8e9_decode(&mut data, 0, false); + + assert_eq!( + u32::from_le_bytes(data[1..5].try_into().unwrap()), + 0x00ff_ffff + ); +} + +#[test] +fn cancellation_interrupts_buffered_decode_and_filters() { + let data = b"cancellable RAR5 symbols ".repeat(16384); + let packed = encode_literal_only(&data, 0).unwrap(); + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack50Decoder::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + decoder.read_control.cancel_after_checks(16); + assert_eq!( + decoder + .decode_member(&packed, 0, data.len(), false, DecodeMode::Lz) + .unwrap_err(), + Error::Cancelled + ); + for arm in [false, true] { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let mut bytes = vec![0; 384 * 1024]; + let result = if arm { + arm_decode_with_control(&mut bytes, 0, &control) + } else { + e8e9_decode_with_control(&mut bytes, 0, true, &control) + }; + assert_eq!(result.unwrap_err(), Error::Cancelled); + } +} + +#[test] +fn delta_filter_cancellation_leaves_output_unchanged() { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let mut bytes = vec![0x5a; 384 * 1024]; + let filter = PendingFilter { + start: 0, + length: bytes.len(), + filter_type: FilterType::Delta, + channels: 3, + }; + + assert_eq!( + apply_filter_data(&mut bytes, &filter, &control), + Err(Error::Cancelled) + ); + assert!(bytes.iter().all(|&byte| byte == 0x5a)); +} + +#[test] +fn filter_application_propagates_range_and_cancellation_errors() { + let original = [0xe8, 0, 0, 0, 0]; + let control = crate::read_control::ReadControl::default(); + for (start, length, message) in [ + (usize::MAX, 2, "RAR 5 filter range overflows"), + (4, 2, "RAR 5 filter range exceeds output"), + ] { + let mut output = original; + let filter = PendingFilter { + start, + length, + filter_type: FilterType::E8, + channels: 0, + }; + assert_eq!( + apply_filters_with_control(&mut output, &[filter], &control), + Err(Error::InvalidData(message)) + ); + assert_eq!(output, original); + } + + for kind in [FilterType::E8, FilterType::E8E9, FilterType::Arm] { + for checks in [0, 1, 2] { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(checks); + let mut output = original; + let filter = PendingFilter { + start: 0, + length: output.len(), + filter_type: kind, + channels: 0, + }; + assert_eq!( + apply_filters_with_control(&mut output, &[filter], &control), + Err(Error::Cancelled), + "kind={kind:?}, checks={checks}" + ); + assert_eq!(output, original); + } + } +} + +#[test] +fn repricing_keeps_the_smallest_actual_block_including_filters() { + for filtered in [false, true] { + let data = wordy_text(4096); + let filters = if filtered { + vec![EncodeFilter { + offset: 0, + length: data.len(), + filter_type: FilterType::E8, + channels: 0, + }] + } else { + vec![] + }; + let options = EncodeOptions::new(32).with_optimal_parse(true); + let distances = DISTANCE_TABLE_SIZE_50; + let selected = encode_tokens_with_progress( + &data, + 0..data.len(), + MemberSearch::Fresh, + options, + distances, + &filters, + None, + ) + .unwrap(); + let lengths = table_lengths_with_filters(&selected, &filters, distances).unwrap(); + let selected_bits = token_stream_bits(&selected, &filters, &lengths, distances).unwrap(); + let all: Vec<_> = filters + .iter() + .copied() + .map(EncodeToken::Filter) + .chain(selected.iter().copied()) + .collect(); + let packed = encode_token_block(&all, 0, distances, true).unwrap(); + let parsed = parse_compressed_block(&packed).unwrap(); + assert_eq!(selected_bits, parsed.header.payload_bits); + let mut collector = OptimalCollector::new(&data, 0, options); + let matches = collector.collect(&data, 0..data.len(), options).unwrap(); + let mut pass = + optimal_tokens(&data, 0..data.len(), options, distances, None, &matches).unwrap(); + for _ in 0..OPTIMAL_PARSE_PASSES { + let lengths = table_lengths_with_filters(&pass, &filters, distances).unwrap(); + assert!( + selected_bits <= token_stream_bits(&pass, &filters, &lengths, distances).unwrap() + ); + pass = optimal_tokens( + &data, + 0..data.len(), + options, + distances, + Some(&TokenPrices { + lengths: lengths.slices(), + }), + &matches, + ) + .unwrap(); + } + } +} + +#[test] +fn shorter_equal_price_match_can_expose_a_better_continuation() { + let history = b"abcdefghijklm!mnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + let data = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + let mut combined = history.to_vec(); + combined.extend_from_slice(data); + let mut matches = BlockMatches { + runs: Buffer::new(&Allowance::default()), + starts: Buffer::new(&Allowance::default()), + }; + for pos in 0..data.len() { + matches.starts.push(matches.runs.len() as u32).unwrap(); + if pos == 0 { + matches.runs.push((13, history.len() as u32)).unwrap(); + } + if pos == 12 { + matches + .runs + .push((40, (history.len() + 12 - 14) as u32)) + .unwrap(); + } + } + matches.starts.push(matches.runs.len() as u32).unwrap(); + let tokens = optimal_tokens( + &combined, + history.len()..combined.len(), + EncodeOptions::new(32), + DISTANCE_TABLE_SIZE_50, + None, + &matches, + ) + .unwrap(); + assert_eq!(tokens.len(), 2); + assert!(matches!(tokens[0], EncodeToken::Match { length: 12, .. })); + assert!(matches!(tokens[1], EncodeToken::Match { length: 40, .. })); +} + +#[test] +fn shared_streaming_finder_preserves_separate_block_bytes() { + // Short blocks exercise seam hashes and wrap the dictionary repeatedly. + let data: Vec = (0..8192).map(|i| ((i * 17 + i / 31) % 251) as u8).collect(); + for optimal in [false, true] { + let options = EncodeOptions::new(32) + .with_optimal_parse(optimal) + .with_max_match_distance(128); + let blocks: Vec<_> = (1..=32).map(|i| (i * 256, i % 4 == 0)).collect(); + let grouped = encode_lz_streaming_blocks(&data, &[], &blocks, 0, options, None).unwrap(); + let mut start = 0; + for ((end, last), bytes) in blocks.into_iter().zip(grouped) { + let reference = + encode_lz_streaming_block(&data[start..end], &data[..start], 0, options, last) + .unwrap(); + assert_eq!(bytes, reference, "optimal={optimal}, start={start}"); + start = end; + } + } +} + +#[test] +fn optimal_streaming_blocks_allow_zero_match_distance() { + let data: Vec = (0..512).map(|i| (i * 71) as u8).collect(); + let options = EncodeOptions::new(16) + .with_optimal_parse(true) + .with_max_match_distance(0); + let blocks = + encode_lz_streaming_blocks(&data, &[], &[(256, false), (512, true)], 0, options, None) + .unwrap(); + let packed: Vec = blocks.into_iter().flatten().collect(); + assert_eq!(decode_lz(&packed, 0, data.len()).unwrap(), data); +} +use super::*; + +/// The flat code charged four bits for a symbol used once and four for one +/// used two hundred times, over an alphabet that is nothing like even. +#[test] +fn the_level_code_spends_fewer_bits_on_the_common_symbol() { + let mut tokens = vec![LevelToken::plain(0); 200]; + for symbol in [4, 7, 9, 11] { + tokens.push(LevelToken::plain(symbol)); + } + let lengths = level_code_lengths_for_tokens(&tokens); + assert!( + lengths[0] < lengths[7], + "the symbol used 200 times costs {} bits and one used once costs {}", + lengths[0], + lengths[7] + ); +} + +/// Strict decoders rebuild the pre-table and reject one that does not fill +/// its code space, so whichever coding wins has to satisfy Kraft equality. +#[test] +fn every_level_code_fills_its_code_space() { + let shapes: Vec> = vec![ + vec![LevelToken::plain(3); 8], + (0..20).map(LevelToken::plain).collect(), + { + let mut skewed = vec![LevelToken::plain(0); 900]; + skewed.extend((1..20).map(LevelToken::plain)); + skewed + }, + (0..20) + .flat_map(|symbol| std::iter::repeat_n(LevelToken::plain(symbol), 1 << symbol.min(9))) + .collect(), + ]; + for tokens in shapes { + let lengths = level_code_lengths_for_tokens(&tokens); + let used: Vec = lengths.iter().copied().filter(|&len| len != 0).collect(); + let kraft: f64 = used.iter().map(|&len| 0.5f64.powi(i32::from(len))).sum(); + assert!( + (kraft - 1.0).abs() < 1e-9, + "code over {} symbols fills {kraft} of its space: {lengths:?}", + used.len() + ); + assert!( + used.iter().all(|&len| len <= 15), + "{lengths:?} exceeds four bits" + ); + assert!(HuffmanTable::from_lengths(&lengths).is_ok()); + } +} + +/// The cost model has to agree with the writer, or it picks the wrong +/// coding whenever the two disagree about the table header. +#[test] +fn the_level_code_cost_matches_what_the_writer_emits() { + let cases: Vec<[u8; LEVEL_TABLE_SIZE]> = vec![ + [4; LEVEL_TABLE_SIZE], + { + let mut lengths = [0u8; LEVEL_TABLE_SIZE]; + lengths[0] = 1; + lengths[1] = 2; + lengths[19] = 15; + lengths + }, + { + let mut lengths = [0u8; LEVEL_TABLE_SIZE]; + lengths[2] = 15; + lengths[3] = 15; + lengths[9] = 3; + lengths + }, + ]; + for lengths in cases { + let mut writer = BitWriter::new(); + write_level_lengths(&mut writer, &lengths); + let header = level_code_cost(&lengths, &[0; LEVEL_TABLE_SIZE]); + assert_eq!( + header, writer.bit_pos, + "header cost {header} against {} bits written for {lengths:?}", + writer.bit_pos + ); + } +} + +fn encode_tokens( + input: &[u8], + history: &[u8], + options: EncodeOptions, + distance_size: usize, +) -> Vec { + let (combined, start) = + member_window_with_allowance(input, history, options, &Allowance::default()).unwrap(); + encode_tokens_with_progress( + &combined, + start..combined.len(), + MemberSearch::Fresh, + options, + distance_size, + &[], + None, + ) + .expect("encoding without cancellation cannot be cancelled") + .into_vec() +} + +fn optimal_tokens( + combined: &[u8], + block: std::ops::Range, + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, + matches: &BlockMatches, +) -> Result> { + optimal_tokens_in_workspace( + combined, + block, + options, + distance_size, + prices, + matches, + &mut OptimalWorkspace::new(&Allowance::default()), + ) + .map(Buffer::into_vec) +} + +/// One block through the optimal parse, collecting its matches first the +/// way [`encode_tokens_with_progress`] does. +fn collected_optimal_tokens( + data: &[u8], + options: EncodeOptions, + distance_size: usize, + prices: Option<&TokenPrices<'_>>, +) -> Vec { + let mut collector = OptimalCollector::new(data, 0, options); + let matches = collector.collect(data, 0..data.len(), options).unwrap(); + optimal_tokens( + data, + 0..data.len(), + options, + distance_size, + prices, + &matches, + ) + .unwrap() +} +fn should_lazy_emit_literal( + input: &[u8], + pos: usize, + finder: &Rar50MatchFinder, + options: EncodeOptions, + state: &EncoderMatchState, + distance_size: usize, + current: MatchCandidate, +) -> bool { + lazy_match_decision( + input, + pos, + input.len(), + finder, + options, + state, + distance_size, + current, + ) + .0 +} + +fn checksum(flags: u8, size_bytes: &[u8]) -> u8 { + size_bytes + .iter() + .fold(0x5a ^ flags, |acc, &byte| acc ^ byte) +} + +#[test] +fn parses_one_byte_size_block_header() { + let flags = 0xc7; + let size = [3]; + let input = [flags, checksum(flags, &size), size[0], 0xaa, 0xbb, 0xcc]; + + let block = parse_compressed_block(&input).unwrap(); + assert_eq!(block.header_len, 3); + assert_eq!(block.payload, 3..6); + assert_eq!(block.header.flags, flags); + assert!(block.header.is_last); + assert!(block.header.has_tables); + assert_eq!(block.header.final_byte_bits, 8); + assert_eq!(block.header.payload_size, 3); + assert_eq!(block.header.payload_bits, 24); +} + +#[test] +fn parses_three_byte_size_block_header_with_partial_final_byte() { + let flags = 0x94; + let size = [0x34, 0x12, 0x00]; + let mut input = vec![flags, checksum(flags, &size), size[0], size[1], size[2]]; + input.resize(0x1234 + 5, 0); + + let block = parse_compressed_block(&input).unwrap(); + assert_eq!(block.header_len, 5); + assert_eq!(block.payload, 5..0x1239); + assert!(!block.header.is_last); + assert!(block.header.has_tables); + assert_eq!(block.header.final_byte_bits, 5); + assert_eq!(block.header.payload_size, 0x1234); + assert_eq!(block.header.payload_bits, (0x1234 - 1) * 8 + 5); +} + +#[test] +fn rejects_reserved_size_length_selector() { + let input = [0x18, 0x42, 0x00]; + + assert_eq!( + parse_compressed_block(&input), + Err(Error::InvalidData("RAR 5 block size length is invalid")) + ); +} + +#[test] +fn rejects_bad_block_header_checksum() { + let input = [0xc7, 0x00, 0x03, 0xaa, 0xbb, 0xcc]; + + assert_eq!( + parse_compressed_block(&input), + Err(Error::InvalidData("RAR 5 block header checksum mismatch")) + ); +} + +#[test] +fn rejects_truncated_block_payload() { + let flags = 0xc7; + let size = [3]; + let input = [flags, checksum(flags, &size), size[0], 0xaa, 0xbb]; + + assert_eq!(parse_compressed_block(&input), Err(Error::NeedMoreInput)); +} + +#[test] +fn reads_level_lengths_with_literal_fifteen() { + let mut nibbles = vec![1, 2, 15, 0, 3, 4]; + nibbles.resize(LEVEL_TABLE_SIZE + 1, 0); + + let (lengths, bits) = read_level_lengths(&pack_nibbles(&nibbles)).unwrap(); + + assert_eq!(&lengths[..6], &[1, 2, 15, 3, 4, 0]); + assert_eq!(bits, LEVEL_TABLE_SIZE * 4 + 4); +} + +#[test] +fn reads_level_lengths_with_zero_run_at_current_position() { + let mut nibbles = vec![7, 15, 3, 2]; + nibbles.resize(LEVEL_TABLE_SIZE - 3, 0); + + let (lengths, bits) = read_level_lengths(&pack_nibbles(&nibbles)).unwrap(); + + assert_eq!(lengths[0], 7); + assert_eq!(&lengths[1..6], &[0, 0, 0, 0, 0]); + assert_eq!(lengths[6], 2); + assert_eq!(bits, (LEVEL_TABLE_SIZE - 3) * 4); +} + +#[test] +fn level_zero_run_stops_at_level_table_boundary() { + let mut nibbles = vec![0; LEVEL_TABLE_SIZE - 1]; + nibbles.extend([15, 15]); // a seventeen-entry zero run at the last slot + let (lengths, bits) = read_level_lengths(&pack_nibbles(&nibbles)).unwrap(); + assert_eq!(lengths, [0; LEVEL_TABLE_SIZE]); + assert_eq!(bits, (LEVEL_TABLE_SIZE + 1) * 4); +} + +fn pack_nibbles(nibbles: &[u8]) -> Vec { + nibbles + .chunks(2) + .map(|chunk| { + let high = chunk[0] & 0x0f; + let low = chunk.get(1).copied().unwrap_or(0) & 0x0f; + (high << 4) | low + }) + .collect() +} + +#[test] +fn reads_rar50_second_level_table_lengths() { + let mut writer = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + writer.write_bits(5, 4); + } + for count in [138, 138, 138, 16] { + writer.write_bits(19, 5); + writer.write_bits(count - 11, 7); + } + let input = writer.finish(); + + let (lengths, bits) = read_table_lengths(&input, 0).unwrap(); + + assert_eq!(lengths.main.len(), MAIN_TABLE_SIZE); + assert_eq!(lengths.distance.len(), DISTANCE_TABLE_SIZE_50); + assert_eq!(lengths.align.len(), ALIGN_TABLE_SIZE); + assert_eq!(lengths.length.len(), LENGTH_TABLE_SIZE); + assert!(lengths.main.iter().all(|&length| length == 0)); + assert!(lengths.distance.iter().all(|&length| length == 0)); + assert!(lengths.align.iter().all(|&length| length == 0)); + assert!(lengths.length.iter().all(|&length| length == 0)); + assert_eq!(bits, LEVEL_TABLE_SIZE * 4 + 4 * (5 + 7)); +} + +#[test] +fn table_length_runs_stop_at_the_table_boundary() { + // The reference decoder clips an otherwise valid run to the table + // length. Both zero runs and previous-length runs can cross it. + for (first_symbol, run_symbol, expected) in [(19, 19, 0), (5, 17, 5)] { + let mut writer = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + writer.write_bits(5, 4); + } + if first_symbol != run_symbol { + writer.write_bits(first_symbol, 5); + } + for _ in 0..4 { + writer.write_bits(run_symbol, 5); + writer.write_bits(127, 7); // a 138-entry run + } + + let (lengths, _) = read_table_lengths(&writer.finish(), 0).unwrap(); + assert!(lengths.main.iter().all(|&length| length == expected)); + assert!(lengths.distance.iter().all(|&length| length == expected)); + assert!(lengths.align.iter().all(|&length| length == expected)); + assert!(lengths.length.iter().all(|&length| length == expected)); + } +} + +#[test] +fn truncated_table_run_extras_need_more_input() { + // The last run symbol ends with fewer padding bits than its extra + // field needs. Exercise both repeat-previous and zero runs at each + // extra-field width. + for (prefix, run) in [ + (&[][..], 19), + (&[1, 1][..], 18), + (&[1][..], 17), + (&[1, 1][..], 16), + ] { + let mut writer = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + writer.write_bits(5, 4); + } + for &symbol in prefix { + writer.write_bits(symbol, 5); + } + writer.write_bits(run, 5); + assert_eq!( + read_table_lengths(&writer.finish(), 0), + Err(Error::NeedMoreInput), + "run symbol {run}" + ); + } +} + +#[test] +fn malformed_table_prefixes_fail_before_table_symbols() { + assert_eq!(read_table_lengths(&[], 0), Err(Error::NeedMoreInput)); + + let mut invalid = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + invalid.write_bits(1, 4); + } + assert!(matches!( + read_table_lengths(&invalid.finish(), 0), + Err(Error::InvalidData(_)) + )); + + let mut no_symbols = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + no_symbols.write_bits(5, 4); + } + assert_eq!( + read_table_lengths(&no_symbols.finish(), 0), + Err(Error::NeedMoreInput) + ); +} + +#[test] +fn truncated_level_escape_needs_its_count_nibble() { + // The low nibble is an escape; its following count nibble is absent. + assert_eq!(read_level_lengths(&[0x0f]), Err(Error::NeedMoreInput)); +} + +#[test] +fn decoders_reject_oversubscribed_secondary_huffman_tables() { + for invalid_table in ["distance", "align", "length"] { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + let invalid_lengths = match invalid_table { + "distance" => &mut lengths.distance, + "align" => &mut lengths.align, + "length" => &mut lengths.length, + _ => unreachable!(), + }; + invalid_lengths[..3].fill(1); + let (payload, payload_bits) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let input = encode_compressed_block(&payload, payload_bits, true, true).unwrap(); + let expected = Error::InvalidData("RAR 5 oversubscribed Huffman table"); + + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(expected.clone()), + "{invalid_table}" + ); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!( + matches!(result, Err(StreamDecodeError::Decode(error)) if error == expected), + "{invalid_table}" + ); + } +} + +#[test] +fn reads_rar70_table_length_count() { + assert_eq!( + table_length_count(1).unwrap(), + MAIN_TABLE_SIZE + DISTANCE_TABLE_SIZE_70 + ALIGN_TABLE_SIZE + LENGTH_TABLE_SIZE + ); +} + +#[test] +fn table_reader_rejects_unknown_algorithm_before_decoding() { + let expected = Error::InvalidData("RAR 5 unknown compression algorithm version"); + assert_eq!(table_length_count(2).unwrap_err(), expected); + assert_eq!(read_table_lengths(&[], 2).unwrap_err(), expected); +} + +#[test] +fn encoded_table_lengths_round_trip_with_bit_count() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[b'B' as usize] = 3; + lengths.main[262] = 3; + lengths.distance[1] = 1; + lengths.align[0] = 4; + lengths.length[0] = 1; + + let (encoded, bit_count) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let (decoded, decoded_bits) = read_table_lengths(&encoded, 0).unwrap(); + + assert_eq!(decoded, lengths); + assert_eq!(decoded_bits, bit_count); +} + +#[test] +fn table_encoder_validates_public_inputs() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[b'B' as usize] = 1; + let encoded = encode_table_lengths(&lengths, 0).unwrap(); + assert_eq!(read_table_lengths(&encoded, 0).unwrap().0, lengths); + + assert_eq!( + encode_table_lengths(&lengths, 2), + Err(Error::InvalidData( + "RAR 5 unknown compression algorithm version" + )) + ); + lengths.distance.pop(); + assert_eq!( + encode_table_lengths(&lengths, 0), + Err(Error::InvalidData("RAR 5 table length count mismatch")) + ); + lengths.distance.push(0); + lengths.main[0] = 16; + assert_eq!( + encode_table_lengths(&lengths, 0), + Err(Error::InvalidData("RAR 5 Huffman length is too large")) + ); +} + +#[test] +fn member_encoders_reject_unknown_algorithm_version() { + let expected = Error::InvalidData("RAR 5 unknown compression algorithm version"); + assert_eq!(encode_literal_only(b"AB", 2).unwrap_err(), expected); + assert_eq!(encode_lz_member(b"ABABABAB", 2).unwrap_err(), expected); +} + +#[test] +fn table_level_encoder_uses_rar5_run_symbols() { + let mut lengths = + vec![0u8; MAIN_TABLE_SIZE + DISTANCE_TABLE_SIZE_50 + ALIGN_TABLE_SIZE + LENGTH_TABLE_SIZE]; + lengths[..4].fill(6); + lengths[8..21].fill(0); + + let tokens = encode_table_level_tokens(&lengths); + + assert!(tokens.contains(&LevelToken::repeat_previous_short(3))); + assert!(tokens.iter().any(|token| token.symbol == 19)); +} + +#[test] +fn repeat_level_runs_cover_the_whole_requested_length() { + for count in 3..=1024 { + let mut tokens = Buffer::new(&Allowance::default()); + emit_repeat_level_run(&mut tokens, count).unwrap(); + let emitted: usize = tokens + .iter() + .map(|token| match token.symbol { + 16 => usize::from(token.extra_value) + 3, + 17 => usize::from(token.extra_value) + 11, + other => panic!("unexpected repeat symbol {other}"), + }) + .sum(); + assert_eq!(emitted, count, "repeat run of {count}"); + } +} + +#[test] +fn zero_level_runs_cover_the_whole_requested_length() { + for count in 1..=1024 { + let mut tokens = Buffer::new(&Allowance::default()); + emit_zero_level_run(&mut tokens, count).unwrap(); + let emitted: usize = tokens + .iter() + .map(|token| match token.symbol { + 0 => 1, + 18 => usize::from(token.extra_value) + 3, + 19 => usize::from(token.extra_value) + 11, + other => panic!("unexpected zero-run symbol {other}"), + }) + .sum(); + assert_eq!(emitted, count, "zero run of {count}"); + } +} + +#[test] +fn encoded_compressed_block_round_trips_header_fields() { + let payload = [0xaa, 0xbb, 0xc0]; + let block = encode_compressed_block(&payload, 18, true, true).unwrap(); + + let parsed = parse_compressed_block(&block).unwrap(); + + assert_eq!(parsed.payload, 3..6); + assert!(parsed.header.has_tables); + assert!(parsed.header.is_last); + assert_eq!(parsed.header.final_byte_bits, 2); + assert_eq!(parsed.header.payload_bits, 18); + assert_eq!(&block[parsed.payload], payload); +} + +#[test] +fn rejects_table_repeat_without_previous_length() { + let mut writer = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + writer.write_bits(5, 4); + } + writer.write_bits(16, 5); + writer.write_bits(0, 3); + + assert_eq!( + read_table_lengths(&writer.finish(), 0), + Err(Error::InvalidData( + "RAR 5 table repeats missing previous length" + )) + ); +} + +#[test] +fn rejects_invalid_encoded_block_bit_counts() { + assert_eq!( + encode_compressed_block(&[0], 0, true, true), + Err(Error::InvalidData("RAR 5 block has unused payload bytes")) + ); + assert_eq!( + encode_compressed_block(&[], 1, true, true), + Err(Error::InvalidData("RAR 5 block bit count exceeds payload")) + ); + let oversized = vec![0; 0x0100_0000]; + assert_eq!( + encode_compressed_block(&oversized, oversized.len() * 8, false, true), + Err(Error::InvalidData("RAR 5 block payload is too large")) + ); +} + +#[test] +fn builds_named_decode_tables_from_lengths() { + let lengths = TableLengths { + main: vec![1, 1], + distance: vec![1, 1], + align: vec![4; ALIGN_TABLE_SIZE], + length: vec![1, 1], + }; + + let tables = DecodeTables::from_lengths(&lengths).unwrap(); + + assert!(!tables.main.is_empty()); + assert!(!tables.distance.is_empty()); + assert!(!tables.align.is_empty()); + assert!(!tables.length.is_empty()); + assert!(!tables.align_mode); + let copied = tables.clone(); + drop(tables); + for table in [ + &copied.main, + &copied.distance, + &copied.align, + &copied.length, + ] { + assert!(!table.is_empty()); + assert_eq!(table.decode(&mut BitReader::new(&[0])).unwrap(), 0); + } + assert!(!copied.align_mode); +} + +#[test] +fn rejects_oversubscribed_rar50_huffman_tables() { + assert!(matches!( + HuffmanTable::from_lengths(&[1, 1, 1]), + Err(Error::InvalidData("RAR 5 oversubscribed Huffman table")) + )); + assert!(matches!( + HuffmanTable::from_lengths(&[16]), + Err(Error::InvalidData("RAR 5 Huffman length is too large")) + )); +} + +#[test] +fn decoders_reject_empty_and_invalid_main_huffman_codes() { + for (main_length, code, code_bits, message) in [ + (0, 1, 1, "RAR 5 empty Huffman table"), + (2, 0xffff, 16, "RAR 5 invalid Huffman code"), + ] { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = main_length; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(code, code_bits); + let payload_bits = writer.bit_pos; + let input = encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap(); + + assert_eq!(decode_lz(&input, 0, 1), Err(Error::InvalidData(message))); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::InvalidData(error))) if error == message + )); + } +} + +#[test] +fn detects_rar50_align_mode_when_align_lengths_are_not_uniform_four() { + let mut align = vec![4; ALIGN_TABLE_SIZE]; + align[0] = 0; + align[3] = 3; + let lengths = TableLengths { + main: vec![1, 1], + distance: vec![1, 1], + align, + length: vec![1, 1], + }; + + let tables = DecodeTables::from_lengths(&lengths).unwrap(); + + assert!(tables.align_mode); +} + +#[test] +fn decodes_synthetic_literal_only_block() { + let payload = literal_only_payload(b"ABBA"); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + + let output = decode_literal_only(&input, 0, 4).unwrap(); + + assert_eq!(output, b"ABBA"); +} + +#[test] +fn encodes_literal_only_member_that_decoder_reads() { + let data = b"literal-only RAR5 codec stream\nwith repeated words words words"; + let input = encode_literal_only(data, 0).unwrap(); + + let output = decode_literal_only(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); +} + +#[test] +fn encodes_literal_only_rar70_table_shape_that_decoder_reads() { + let data = b"small RAR7-compatible literal block"; + let input = encode_literal_only(data, 1).unwrap(); + + let output = decode_literal_only(&input, 1, data.len()).unwrap(); + + assert_eq!(output, data); +} + +#[test] +fn encodes_empty_literal_only_member() { + let input = encode_literal_only(b"", 0).unwrap(); + + let output = decode_literal_only(&input, 0, 0).unwrap(); + + assert!(output.is_empty()); +} + +#[test] +fn encodes_lz_member_with_same_member_matches() { + let data = b"RAR5 match writer phrase. RAR5 match writer phrase. RAR5 match writer phrase."; + let lz = encode_lz_member(data, 0).unwrap(); + let literal = encode_literal_only(data, 0).unwrap(); + + let output = decode_lz(&lz, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert!(lz.len() < literal.len()); + assert!( + encode_tokens(data, &[], EncodeOptions::default(), DISTANCE_TABLE_SIZE_50) + .iter() + .any(|token| matches!(token, EncodeToken::Match { .. })) + ); +} + +#[test] +fn frequency_weighted_huffman_lengths_shorten_common_symbols() { + let mut frequencies = vec![1usize; 24]; + frequencies[3] = 1024; + + let lengths = huffman::lengths_for_frequencies(&frequencies, 15); + + assert!(lengths[3] < lengths[0]); + assert!(lengths.iter().all(|&length| length <= 15)); +} + +#[test] +fn lz_encoder_uses_frequency_weighted_huffman_lengths() { + let mut data = vec![b'a'; 200]; + data.extend_from_slice(b"bcdefghijklmnopqrstuvwxyz"); + let input = encode_lz_member_with_options(&data, 0, EncodeOptions::new(0)).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert!(lengths.main[b'a' as usize] < lengths.main[b'z' as usize]); +} + +fn code_is_complete(lengths: &[u8]) -> bool { + let max_len = lengths.iter().copied().max().unwrap_or(0); + if max_len == 0 { + return true; + } + let sum: u64 = lengths + .iter() + .filter(|&&len| len != 0) + .map(|&len| 1u64 << (max_len - len)) + .sum(); + sum == (1u64 << max_len) +} + +#[test] +fn degenerate_inputs_emit_complete_huffman_tables() { + // Highly repetitive data collapses the distance/length/align tables to a + // single symbol. Those tables must still be transmitted as *complete* + // prefix codes, or strict RAR 5 decoders (7-Zip / WinRAR, which build + // with `Full_or_Empty`) reject the archive with a spurious data error. + // See issue #19. + let inputs: &[Vec] = &[ + vec![b'a'; 4000], + b"ab".repeat(4000), + (0u8..16).cycle().take(50_000).collect(), + b"lorem ipsum dolor sit amet ".repeat(2000), + ]; + for data in inputs { + let input = encode_lz_member_with_options(data, 0, EncodeOptions::new(0)).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + assert!(code_is_complete(&lengths.main), "main table incomplete"); + assert!( + code_is_complete(&lengths.distance), + "distance table incomplete" + ); + assert!(code_is_complete(&lengths.length), "length table incomplete"); + assert!(code_is_complete(&lengths.align), "align table incomplete"); + + assert_eq!(&decode_lz(&input, 0, data.len()).unwrap(), data); + } +} + +#[test] +fn lazy_lz_parser_defers_short_match_for_longer_next_match() { + let input = b"abcdXbcdYYYYYYYYYYYYabcdYYYYYYYYYYYY"; + let greedy = encode_tokens( + input, + &[], + EncodeOptions::new(MAX_MATCH_CANDIDATES), + DISTANCE_TABLE_SIZE_50, + ); + let lazy = encode_tokens( + input, + &[], + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_lazy_matching(true), + DISTANCE_TABLE_SIZE_50, + ); + let packed = encode_lz_member_with_options( + input, + 0, + EncodeOptions::new(MAX_MATCH_CANDIDATES).with_lazy_matching(true), + ) + .unwrap(); + + assert!(greedy + .iter() + .any(|token| matches!(token, EncodeToken::Match { length: 4, .. }))); + assert!(lazy + .iter() + .any(|token| matches!(token, EncodeToken::Match { length, .. } if *length > 8))); + assert_eq!(decode_lz(&packed, 0, input.len()).unwrap(), input); +} + +#[test] +fn match_selection_uses_length_then_distance_for_equal_scores() { + let state = EncoderMatchState::default(); + let distance_size = DISTANCE_TABLE_SIZE_50; + assert_eq!( + estimated_match_cost(&state, 5, 1, distance_size).unwrap(), + 10 + ); + assert_eq!( + estimated_match_cost(&state, 6, 262_144, distance_size).unwrap(), + 26 + ); + assert_eq!( + estimated_match_cost(&state, 6, 262_143, distance_size).unwrap(), + 26 + ); + + let mut best = None; + consider_match_candidate(&mut best, &state, distance_size, 5, 1); + consider_match_candidate(&mut best, &state, distance_size, 6, 262_144); + assert_eq!((best.unwrap().length, best.unwrap().distance), (6, 262_144)); + consider_match_candidate(&mut best, &state, distance_size, 6, 262_143); + assert_eq!((best.unwrap().length, best.unwrap().distance), (6, 262_143)); + + let mut best = None; + let longer = std::hint::black_box((6, 262_144)); + let shorter = std::hint::black_box((5, 1)); + consider_match_candidate(&mut best, &state, distance_size, longer.0, longer.1); + consider_match_candidate(&mut best, &state, distance_size, shorter.0, shorter.1); + assert_eq!((best.unwrap().length, best.unwrap().distance), (6, 262_144)); +} + +#[test] +fn cost_aware_match_selection_prefers_repeat_distance_token() { + let pos = 64; + let pattern = b"abcdefgh"; + let mut input: Vec = (0..96u8).map(|byte| byte.wrapping_mul(37)).collect(); + input[pos - 30..pos - 22].copy_from_slice(pattern); + input[pos - 10..pos - 2].copy_from_slice(pattern); + input[pos..pos + 8].copy_from_slice(pattern); + input[pos + 8] = b'X'; + + let mut finder = Rar50MatchFinder::new(input.len()); + for candidate in 0..pos { + finder.insert(&input, candidate); + } + let state = EncoderMatchState { + reps: [30, 0, 0, 0], + last_length: 8, + }; + + let best = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &state, + DISTANCE_TABLE_SIZE_50, + ) + .unwrap(); + + assert_eq!((best.length, best.distance), (8, 30)); +} + +#[test] +fn lazy_parser_uses_match_cost_not_only_match_length() { + let pos = 600; + let mut input: Vec = (0..700u16) + .map(|value| value.wrapping_mul(73) as u8) + .collect(); + input[pos - 512..pos - 504].copy_from_slice(b"ABCDEFGH"); + input[pos - 504] = b'Z'; + input[pos - 29..pos - 21].copy_from_slice(b"BCDEFGHI"); + input[pos - 30] = b'x'; + input[pos..pos + 9].copy_from_slice(b"ABCDEFGHI"); + + let mut finder = Rar50MatchFinder::new(input.len()); + for candidate in 0..pos { + finder.insert(&input, candidate); + } + let state = EncoderMatchState { + reps: [30, 0, 0, 0], + last_length: 8, + }; + let current = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &state, + DISTANCE_TABLE_SIZE_50, + ) + .unwrap(); + + assert_eq!((current.length, current.distance), (8, 512)); + assert!(should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default().with_lazy_matching(true), + &state, + DISTANCE_TABLE_SIZE_50, + current, + )); +} + +#[test] +fn lazy_parser_uses_bounded_cost_lookahead() { + let pos = 160; + let mut input: Vec = (0..240u16) + .map(|value| value.wrapping_mul(91) as u8) + .collect(); + input[pos - 30..pos - 22].copy_from_slice(b"ABCDEFGH"); + input[pos - 80..pos - 70].copy_from_slice(b"CDEFGHIJKL"); + input[pos..pos + 12].copy_from_slice(b"ABCDEFGHIJKL"); + + let mut finder = Rar50MatchFinder::new(input.len()); + for candidate in 0..pos { + finder.insert(&input, candidate); + } + let state = EncoderMatchState::default(); + let current = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &state, + DISTANCE_TABLE_SIZE_50, + ) + .unwrap(); + + assert_eq!((current.length, current.distance), (8, 30)); + assert!(!should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(1), + &state, + DISTANCE_TABLE_SIZE_50, + current, + )); + assert!(should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(2), + &state, + DISTANCE_TABLE_SIZE_50, + current, + )); +} + +#[test] +fn lazy_parser_charges_for_skipped_literals() { + let pos = 160; + let mut input: Vec = (0..240u16) + .map(|value| value.wrapping_mul(91) as u8) + .collect(); + input[pos - 30..pos - 22].copy_from_slice(b"ABCDEFGH"); + input[pos - 80..pos - 71].copy_from_slice(b"CDEFGHIJK"); + input[pos..pos + 12].copy_from_slice(b"ABCDEFGHIJKL"); + + let mut finder = Rar50MatchFinder::new(input.len()); + for candidate in 0..pos { + finder.insert(&input, candidate); + } + let state = EncoderMatchState::default(); + let current = best_match( + &input, + pos, + input.len(), + &finder, + EncodeOptions::default(), + &state, + DISTANCE_TABLE_SIZE_50, + ) + .unwrap(); + + let next = best_match( + &input, + pos + 2, + input.len(), + &finder, + EncodeOptions::default(), + &state, + DISTANCE_TABLE_SIZE_50, + ) + .unwrap(); + + assert!(next.score > current.score); + assert!(next.score <= current.score + 16); + assert!(!should_lazy_emit_literal( + &input, + pos, + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(2), + &state, + DISTANCE_TABLE_SIZE_50, + current, + )); +} + +#[test] +fn lazy_match_lookahead_stops_at_the_member_boundary() { + let input = b"abcdef"; + let mut finder = Rar50MatchFinder::new(input.len()); + for pos in 0..4 { + finder.insert(input, pos); + } + let current = MatchCandidate { + length: 4, + distance: 1, + score: 1000, + }; + + assert_eq!( + lazy_match_decision( + input, + 4, + input.len(), + &finder, + EncodeOptions::default() + .with_lazy_matching(true) + .with_lazy_lookahead(4), + &EncoderMatchState::default(), + DISTANCE_TABLE_SIZE_50, + current, + ), + (false, None) + ); +} + +fn encode_lz_member_with_filter(data: &[u8], kind: crate::FilterKind) -> Result> { + Unpack50Encoder::new().encode_member_with_filter(data, 0, crate::FilterSpec::whole(kind)) +} + +#[test] +fn encodes_lz_member_with_delta_filter_record() { + let data: Vec = (0..96).map(|index| (index * 7 + index / 3) as u8).collect(); + let input = + encode_lz_member_with_filter(&data, crate::FilterKind::Delta { channels: 3 }).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[256], 0); +} + +#[test] +fn rejects_invalid_delta_filter_channel_count() { + assert_eq!( + encode_lz_member_with_filter(b"abc", crate::FilterKind::Delta { channels: 0 }), + Err(Error::InvalidData( + "RAR 5 DELTA filter channel count is invalid" + )) + ); + assert_eq!( + encode_lz_member_with_filter(b"abc", crate::FilterKind::Delta { channels: 33 }), + Err(Error::InvalidData( + "RAR 5 DELTA filter channel count is invalid" + )) + ); +} + +#[test] +fn filter_record_integers_round_trip_at_every_encoded_width() { + for value in [0, 0xff, 0x100, 0xffff, 0x1_0000, 0xff_ffff, 0x100_0000] { + let mut writer = BitWriter::new(); + try_write_filter_data(&mut writer, value).unwrap(); + let encoded = writer.finish(); + assert_eq!( + read_filter_data(&mut BitReader::new(&encoded)).unwrap(), + value + ); + } +} + +#[test] +fn truncated_filter_fields_and_overflowing_start_fail() { + assert_eq!( + read_filter_data(&mut BitReader::new(&[])), + Err(Error::NeedMoreInput) + ); + assert_eq!( + read_filter_data(&mut BitReader::new(&[0])), + Err(Error::NeedMoreInput) + ); + assert_eq!( + read_filter(&mut BitReader::new(&[]), 0), + Err(Error::NeedMoreInput) + ); + assert_eq!( + read_filter(&mut BitReader::new(&[0, 0]), 0), + Err(Error::NeedMoreInput) + ); + + let mut type_missing = BitWriter::new(); + type_missing.write_bits(0, 4); // The preceding Huffman code's tail. + try_write_filter_data(&mut type_missing, 0).unwrap(); + try_write_filter_data(&mut type_missing, 1).unwrap(); + let data = type_missing.finish(); + let mut bits = BitReader::new(&data); + bits.bit_pos = 4; + assert_eq!(read_filter(&mut bits, 0), Err(Error::NeedMoreInput)); + + let mut channels_missing = BitWriter::new(); + try_write_filter_data(&mut channels_missing, 0).unwrap(); + try_write_filter_data(&mut channels_missing, 1).unwrap(); + channels_missing.write_bits(0, 3); // DELTA, without its channel field. + assert_eq!( + read_filter(&mut BitReader::new(&channels_missing.finish()), 0), + Err(Error::NeedMoreInput) + ); + + let mut start_overflow = BitWriter::new(); + try_write_filter( + &mut start_overflow, + EncodeFilter { + offset: 1, + length: 1, + filter_type: FilterType::E8, + channels: 0, + }, + ) + .unwrap(); + assert_eq!( + read_filter(&mut BitReader::new(&start_overflow.finish()), usize::MAX), + Err(Error::InvalidData("RAR 5 filter start overflows")) + ); +} + +#[test] +fn filter_record_writer_rejects_invalid_delta_channels() { + for channels in [0, MAX_DELTA_CHANNELS + 1] { + let mut writer = BitWriter::new(); + assert_eq!( + try_write_filter( + &mut writer, + EncodeFilter { + offset: 0, + length: 1, + filter_type: FilterType::Delta, + channels, + }, + ), + Err(Error::InvalidData( + "RAR 5 DELTA filter channel count is invalid" + )) + ); + } +} + +#[cfg(target_pointer_width = "64")] +#[test] +fn filter_record_writer_rejects_fields_beyond_u32() { + for (offset, length, message) in [ + (u32::MAX as usize + 1, 1, "RAR 5 filter offset is too large"), + (0, u32::MAX as usize + 1, "RAR 5 filter length is too large"), + ] { + let mut writer = BitWriter::new(); + assert_eq!( + try_write_filter( + &mut writer, + EncodeFilter { + offset, + length, + filter_type: FilterType::E8, + channels: 0, + }, + ), + Err(Error::InvalidData(message)) + ); + } +} + +#[cfg(target_pointer_width = "64")] +#[test] +fn filter_transform_rejects_offset_beyond_record_width() { + let mut data = [0xe8, 0, 0, 0, 0]; + assert_eq!( + encode_filter_data( + Rar50Filter::E8, + &mut data, + u32::MAX as usize + 1, + &Allowance::default(), + ), + Err(Error::InvalidData("RAR 5 filter offset is too large")) + ); + assert_eq!(data, [0xe8, 0, 0, 0, 0]); +} + +#[test] +fn encodes_lz_member_with_e8_filter_record() { + let mut data = b"\xe8\0\0\0\0plain text after call".to_vec(); + data.extend_from_slice(&[0xe8, 3, 0, 0, 0, b'X']); + let input = encode_lz_member_with_filter(&data, crate::FilterKind::E8).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[256], 0); +} + +#[test] +fn short_e8_filter_range_round_trips_without_rewriting_bytes() { + let data = [0xe8, 0, 0, 0]; + let packed = encode_lz_member_with_filter(&data, crate::FilterKind::E8).unwrap(); + assert_eq!(decode_lz(&packed, 0, data.len()).unwrap(), data); +} + +#[test] +fn rar50_e8_filter_wraps_file_offset_modulo_16m() { + let file_offset = 0x0110_0000; + let mut encoded = vec![0xe8]; + encoded.extend_from_slice(&0x0010_0c08u32.to_le_bytes()); + + let mut decoded = encoded.clone(); + e8e9_decode(&mut decoded, file_offset, false); + + assert_eq!(&decoded[1..5], &0x0000_0c07u32.to_le_bytes()); + e8e9_encode(&mut decoded, file_offset, false); + assert_eq!(decoded, encoded); +} + +#[test] +fn streaming_decode_reports_filtered_member_with_typed_sentinel() { + let data = b"\xe8\0\0\0\0plain text after call".to_vec(); + let input = encode_lz_member_with_filter(&data, crate::FilterKind::E8).unwrap(); + let mut reader = input.as_slice(); + let mut decoder = Unpack50Decoder::new(); + + let error = decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut reader, + 0, + data.len(), + 128 * 1024, + false, + |_chunk| Ok::<_, std::convert::Infallible>(()), + ) + .unwrap_err(); + + assert!(matches!(error, StreamDecodeError::FilteredMember)); +} + +#[test] +fn streaming_filter_records_reconstruct_buffered_output() { + let cases = [ + ( + (0..96).map(|index| (index * 7 + index / 3) as u8).collect(), + crate::FilterKind::Delta { channels: 3 }, + ), + ( + b"\xe8\0\0\0\0plain text after call".to_vec(), + crate::FilterKind::E8, + ), + ( + b"\xe9\0\0\0\0jump target through e9".to_vec(), + crate::FilterKind::E8E9, + ), + ( + vec![0x04, 0x00, 0x00, 0xeb, b'A', b'R', b'M', b'!'], + crate::FilterKind::Arm, + ), + ]; + + for (expected, kind) in cases { + let packed = encode_lz_member_with_filter(&expected, kind).unwrap(); + let mut raw = Vec::new(); + let mut filters = Vec::new(); + Unpack50Decoder::new() + .decode_to_sink_with_filters( + &mut packed.as_slice(), + 0, + expected.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => raw.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + raw.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + Some(&mut |filter| { + filters.push(filter); + Ok::<(), std::convert::Infallible>(()) + }), + ) + .unwrap(); + + assert_eq!(filters.len(), 1); + apply_filters_with_control( + &mut raw, + &filters, + &crate::read_control::ReadControl::default(), + ) + .unwrap(); + assert_eq!(raw, expected); + } +} + +#[test] +fn encodes_lz_member_with_e8e9_filter_record() { + let data = b"\xe9\0\0\0\0jump target through e9".to_vec(); + let input = encode_lz_member_with_filter(&data, crate::FilterKind::E8E9).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[256], 0); +} + +#[test] +fn encodes_lz_member_with_ranged_e8e9_filter_record() { + let mut data = b"\xe8\0\0\0\0plain prefix outside filter range".to_vec(); + let range_start = data.len(); + for _ in 0..16 { + let operand_pos = data.len() + 1; + data.push(0xe8); + let relative = 0x7000u32.wrapping_sub(operand_pos as u32); + data.extend_from_slice(&relative.to_le_bytes()); + data.extend_from_slice(b" code "); + } + let range = range_start..data.len(); + data.extend_from_slice(b"\xe9\0\0\0\0plain suffix outside filter range"); + + let input = Unpack50Encoder::new() + .encode_member_with_filter( + &data, + 0, + crate::FilterSpec::range(crate::FilterKind::E8E9, range), + ) + .unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[256], 0); +} + +#[test] +fn encodes_lz_member_with_multiple_filter_records() { + let mut data = b"\xe8\0\0\0\0plain prefix outside filters".to_vec(); + let first_start = data.len(); + data.extend_from_slice(b"\xe8\0\0\0\0first filtered cluster"); + let first_end = data.len(); + data.extend_from_slice(b"large plain middle outside filters"); + let second_start = data.len(); + data.extend_from_slice(b"\xe8\0\0\0\0second filtered cluster"); + let second_end = data.len(); + + let input = Unpack50Encoder::new() + .encode_member_with_filters( + &data, + 0, + &[ + crate::FilterSpec::range(crate::FilterKind::E8, first_start..first_end), + crate::FilterSpec::range(crate::FilterKind::E8, second_start..second_end), + ], + ) + .unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, table_bits) = read_table_lengths(&input[block.payload.clone()], 0).unwrap(); + let tables = DecodeTables::from_lengths(&lengths).unwrap(); + let mut bits = BitReader { + input: &input[block.payload], + bit_pos: table_bits, + }; + assert_eq!(tables.main.decode(&mut bits).unwrap(), 256); + let first = read_filter(&mut bits, 0).unwrap(); + assert_eq!(tables.main.decode(&mut bits).unwrap(), 256); + let second = read_filter(&mut bits, 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_eq!(first.start, first_start); + assert_eq!(second.start, second_start); +} + +#[test] +fn encodes_lz_member_with_arm_filter_record() { + let data = [0x04, 0x00, 0x00, 0xeb, b'A', b'R', b'M', b'!']; + let input = encode_lz_member_with_filter(&data, crate::FilterKind::Arm).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[256], 0); +} + +#[test] +fn arm_filter_uses_wrapping_address_arithmetic_at_u32_boundary() { + let original = [0x04, 0x00, 0x00, 0xeb, 0x08, 0x00, 0x00, 0xeb]; + let mut filtered = original; + + arm_encode(&mut filtered, u32::MAX - 3); + assert_ne!(filtered, original); + arm_decode(&mut filtered, u32::MAX - 3); + + assert_eq!(filtered, original); +} + +#[test] +fn solid_encoder_emits_rar50_matches_against_previous_member_history() { + let first = b"RAR5 solid shared phrase alpha beta gamma\n".repeat(16); + let second = b"RAR5 solid shared phrase alpha beta gamma\nsecond\n".repeat(4); + let solid = encode_lz_member_with_history(&second, &first, 0).unwrap(); + let standalone = encode_lz_member(&second, 0).unwrap(); + let mut decoder = Unpack50Decoder::new(); + + assert_eq!( + decoder + .decode_member( + &encode_lz_member(&first, 0).unwrap(), + 0, + first.len(), + false, + DecodeMode::Lz + ) + .unwrap(), + first + ); + assert_eq!( + decoder + .decode_member(&solid, 0, second.len(), true, DecodeMode::Lz) + .unwrap(), + second + ); + assert!(solid.len() < standalone.len()); +} + +#[test] +fn public_decoder_clone_keeps_independent_solid_history_and_tables() { + let first = b"RAR5 independent decoder history ".repeat(32); + let second = b"RAR5 independent decoder history ".repeat(8); + let packed_first = encode_lz_member(&first, 0).unwrap(); + let packed_second = encode_lz_member_with_history(&second, &first, 0).unwrap(); + let mut original = Unpack50Decoder::new(); + assert_eq!( + original + .decode_member(&packed_first, 0, first.len(), false, DecodeMode::Lz) + .unwrap(), + first + ); + let mut copied = original.clone(); + let other = b"a different non-solid member"; + assert_eq!( + original + .decode_member( + &encode_lz_member(other, 0).unwrap(), + 0, + other.len(), + false, + DecodeMode::Lz + ) + .unwrap(), + other + ); + drop(original); + assert_eq!( + copied + .decode_member(&packed_second, 0, second.len(), true, DecodeMode::Lz) + .unwrap(), + second + ); +} + +#[test] +fn large_lz_members_are_split_into_multiple_compressed_blocks() { + // Two halves that do not look alike, so the second cannot be spelled + // with the first's tables and gets its own block. + let mut data = wordy_text(LZ_BLOCK_SIZE); + data.extend((0..LZ_BLOCK_SIZE).map(|index| (index as u8).wrapping_mul(37))); + let encoded = encode_lz_member_with_options(&data, 0, EncodeOptions::new(16)).unwrap(); + let mut cursor = std::io::Cursor::new(encoded.as_slice()); + let first = read_compressed_block(&mut cursor).unwrap(); + let second = read_compressed_block(&mut cursor).unwrap(); + let mut decoder = Unpack50Decoder::new(); + + assert!(!first.header.is_last); + assert!(second.header.is_last); + assert_eq!( + decoder + .decode_member(&encoded, 0, data.len(), false, DecodeMode::Lz) + .unwrap(), + data + ); +} + +#[test] +fn a_member_that_does_not_move_is_left_in_one_block() { + // Every chunk of this has the same byte distribution, so a fresh table + // set per chunk would describe nothing the first one did not. + let data = vec![0u8; LZ_BLOCK_SIZE * 4]; + let encoded = encode_lz_member_with_options(&data, 0, EncodeOptions::new(16)).unwrap(); + let mut cursor = std::io::Cursor::new(encoded.as_slice()); + let only = read_compressed_block(&mut cursor).unwrap(); + let mut decoder = Unpack50Decoder::new(); + + assert!(only.header.is_last, "a still member was cut up anyway"); + assert_eq!( + decoder + .decode_member(&encoded, 0, data.len(), false, DecodeMode::Lz) + .unwrap(), + data + ); +} + +#[test] +fn a_block_never_grows_past_the_cap() { + let data = vec![0u8; MAX_LZ_BLOCK_SIZE * 2 + LZ_BLOCK_SIZE]; + let encoded = encode_lz_member_with_options(&data, 0, EncodeOptions::new(16)).unwrap(); + let mut cursor = std::io::Cursor::new(encoded.as_slice()); + let mut blocks = 0; + loop { + let block = read_compressed_block(&mut cursor).unwrap(); + blocks += 1; + if block.header.is_last { + break; + } + } + + // Uniform to the last byte, so only the cap can be ending these. + assert_eq!(blocks, 3, "the cap stopped ending blocks"); +} + +#[test] +fn splitter_refuses_to_extend_an_empty_block_or_with_an_empty_chunk() { + let mut splitter = BlockSplitter::new(); + assert!(!splitter.extends(b"AAAA")); + splitter.accept(b"AAAA"); + assert!(!splitter.extends(b"")); + assert!(splitter.extends(b"AAAA")); +} + +#[test] +fn the_splitter_reads_only_what_both_writers_can_see() { + // The streaming writer decides with the open block's bytes and the next + // chunk, and nothing else. Same bytes in, same answer, however the + // chunks were handed over. + let mut whole = BlockSplitter::new(); + whole.accept(&vec![7u8; 4096]); + let mut piecemeal = BlockSplitter::new(); + for _ in 0..4 { + piecemeal.accept(&vec![7u8; 1024]); + } + + let next = vec![7u8; 4096]; + assert!(whole.extends(&next)); + assert_eq!(whole.extends(&next), piecemeal.extends(&next)); + + let moved: Vec = (0..4096u32).map(|index| index as u8).collect(); + assert!(!whole.extends(&moved), "a block swallowed unlike data"); + assert_eq!(whole.extends(&moved), piecemeal.extends(&moved)); +} + +/// Words drawn from a small vocabulary in a repeating-but-not-periodic +/// order. Every position has several matches at different distances and +/// lengths, which is the case where taking the longest one and checking +/// two bytes ahead leaves bits on the floor. +fn wordy_text(len: usize) -> Vec { + const WORDS: [&str; 12] = [ + "the ", "quick ", "brown ", "fox ", "jumps ", "over ", "lazy ", "dog ", "and ", "then ", + "runs ", "away ", + ]; + let mut out = Vec::with_capacity(len + 16); + let mut noise = 0x2545_f491_4f6c_dd1du64; + while out.len() < len { + noise ^= noise << 13; + noise ^= noise >> 7; + noise ^= noise << 17; + out.extend_from_slice(WORDS[(noise >> 40) as usize % WORDS.len()].as_bytes()); + if (noise >> 20).is_multiple_of(11) { + out.push(b'\n'); + } + } + out.truncate(len); + out +} + +#[test] +fn the_optimal_parse_round_trips() { + for data in [ + Vec::new(), + b"a".to_vec(), + b"abcabcabcabc".to_vec(), + wordy_text(3), + wordy_text(LZ_BLOCK_SIZE + 4096), + vec![0u8; LZ_BLOCK_SIZE * 2], + ] { + let options = EncodeOptions::new(64).with_optimal_parse(true); + let encoded = encode_lz_member_with_options(&data, 0, options).unwrap(); + let decoded = Unpack50Decoder::new() + .decode_member(&encoded, 0, data.len(), false, DecodeMode::Lz) + .unwrap(); + assert_eq!(decoded, data, "{} bytes did not round trip", data.len()); + } +} + +#[test] +fn optimal_parse_with_matching_disabled_emits_literals() { + let data = b"ABABABAB"; + let tokens = collected_optimal_tokens( + data, + EncodeOptions::new(0).with_optimal_parse(true), + DISTANCE_TABLE_SIZE_50, + None, + ); + + assert_eq!( + tokens, + data.iter() + .copied() + .map(EncodeToken::Literal) + .collect::>() + ); +} + +#[test] +fn optimal_long_match_commitment_prunes_shorter_candidate_endpoints() { + let history = 2; + let span = NICE_MATCH_LENGTH + 8; + let combined = vec![0; history + span]; + let mut price = vec![u32::MAX; span + 1]; + let mut arrive_length = vec![0; span + 1]; + let mut arrive_distance = vec![0; span + 1]; + let mut arrive_reps = vec![[0; 4]; span + 1]; + let mut arrive_last_length = vec![0; span + 1]; + price[0] = 0; + arrive_reps[0] = [0, (history + 1) as u32, 0, 0]; + let runs = [(4, 1), (NICE_MATCH_LENGTH as u32, 2)]; + let mut starts = vec![2; span + 1]; + starts[0] = 0; + let mut reaches = [(0, 0, 0); 8]; + + price_optimal_paths( + &combined, + history..history + span, + EncodeOptions::new(32).with_optimal_parse(true), + DISTANCE_TABLE_SIZE_50, + None, + &runs, + &starts, + OptimalSlices { + price: &mut price, + arrive_length: &mut arrive_length, + arrive_distance: &mut arrive_distance, + arrive_reps: &mut arrive_reps, + arrive_last_length: &mut arrive_last_length, + }, + &mut reaches, + ); + + assert_eq!(price[4], u32::MAX); + assert_ne!(price[NICE_MATCH_LENGTH], u32::MAX); + assert_eq!(arrive_length[NICE_MATCH_LENGTH], NICE_MATCH_LENGTH as u32); + assert_eq!(arrive_distance[NICE_MATCH_LENGTH], 2); +} + +#[test] +fn the_optimal_parse_beats_lazy_matching_at_the_same_depth() { + let data = wordy_text(256 * 1024); + let base = EncodeOptions::new(64); + let lazy = encode_lz_member_with_options( + &data, + 0, + base.with_lazy_matching(true).with_lazy_lookahead(2), + ) + .unwrap(); + let optimal = encode_lz_member_with_options(&data, 0, base.with_optimal_parse(true)).unwrap(); + + assert!( + optimal.len() < lazy.len(), + "optimal parse packed {} against lazy matching's {}", + optimal.len(), + lazy.len(), + ); +} + +/// One chunk, copied once per round with fresh literals in between, so +/// every match after the first sits at the same distance and every one of +/// them is separated from the last by literals. +fn strided_repeats(gap: usize, rounds: usize) -> Vec { + let mut noise = 0x1234_5678u32; + let mut byte = move || { + noise = noise.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (noise >> 24) as u8 + }; + let chunk: Vec = (0..48).map(|_| byte()).collect(); + let mut data = chunk.clone(); + for _ in 0..rounds { + data.extend((0..gap).map(|_| byte())); + data.extend_from_slice(&chunk); + } + data +} + +#[test] +fn the_optimal_parse_reuses_a_distance_across_the_literals_between_matches() { + let data = strided_repeats(8, 3000); + let options = EncodeOptions::new(64).with_optimal_parse(true); + let distance_size = DISTANCE_TABLE_SIZE_50; + let tokens = collected_optimal_tokens(&data, options, distance_size, None); + + let mut state = EncoderMatchState::default(); + let (mut repeated, mut fresh) = (0, 0); + for token in &tokens { + if let EncodeToken::Match { length, distance } = *token { + match state.encode_match(length, distance, distance_size).unwrap() { + EncodedMatch::New { .. } => fresh += 1, + _ => repeated += 1, + } + state.remember(length, distance); + } + } + + // Every match here is at the one distance the data repeats at, so all + // but the first should be priced against what the path remembers. + // Carrying only the arriving match instead left this at 244 repeated + // against 2,756 fresh, because a literal wiped the distance before the + // next match could be priced against it. + assert!( + fresh * 10 < repeated, + "{repeated} matches reused a distance against {fresh} that did not", + ); +} + +#[test] +fn reusing_a_remembered_distance_packs_strided_data_smaller() { + let data = strided_repeats(8, 3000); + let options = EncodeOptions::new(64).with_optimal_parse(true); + let packed = encode_lz_member_with_options(&data, 0, options).unwrap(); + + // 26,178 bytes when the path carries its remembered distances, 28,447 + // when it does not. The bound sits between the two. + assert!( + packed.len() < 27_000, + "{} bytes packed from {}", + packed.len(), + data.len(), + ); + let decoded = decode_lz(&packed, 0, data.len()).unwrap(); + assert_eq!(decoded, data); +} + +/// Once the parse commits to a match it steps over the bytes that match +/// covers, so a block that repeats is emitted as whole matches back to back +/// rather than as the cheapest split of each one. That is the difference +/// between the parse pricing 4096 positions per match and pricing one, which +/// is worth 53.41s against 1.19s on a mebibyte of this. +#[test] +fn the_optimal_parse_steps_over_a_match_it_has_committed_to() { + let block: Vec = (0..4096u32) + .map(|index| (index * 7 + (index >> 5)) as u8) + .collect(); + let data = block.repeat(16); + let options = EncodeOptions::new(64).with_optimal_parse(true); + let tokens = collected_optimal_tokens(&data, options, DISTANCE_TABLE_SIZE_50, None); + + let first = tokens + .iter() + .position(|token| { + matches!(token, EncodeToken::Match { length, .. } if *length >= NICE_MATCH_LENGTH) + }) + .expect("no match reached the length the parse commits at"); + for token in &tokens[first..] { + let EncodeToken::Match { length, .. } = *token else { + panic!("{token:?} interrupts the committed matches"); + }; + assert!( + length >= NICE_MATCH_LENGTH, + "a {length}-byte match interrupts the committed ones", + ); + } + // The first block is the only one with nothing behind it to match. + assert_eq!(tokens.len() - first, data.len() / block.len() - 1); + + let packed = encode_lz_member_with_options(&data, 0, options).unwrap(); + assert_eq!(decode_lz(&packed, 0, data.len()).unwrap(), data); +} + +#[test] +fn repricing_against_the_first_pass_beats_the_flat_guess() { + let data = wordy_text(256 * 1024); + let options = EncodeOptions::new(64).with_optimal_parse(true); + let distance_size = DISTANCE_TABLE_SIZE_50; + let guessed = collected_optimal_tokens(&data, options, distance_size, None); + let lengths = table_lengths_for_tokens(&guessed, distance_size).unwrap(); + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let repriced = collected_optimal_tokens(&data, options, distance_size, Some(&prices)); + + let bits = |tokens: &[EncodeToken]| -> usize { + let lengths = table_lengths_for_tokens(tokens, distance_size).unwrap(); + let prices = TokenPrices { + lengths: lengths.slices(), + }; + let mut state = EncoderMatchState::default(); + let mut total = 0; + for token in tokens { + match *token { + EncodeToken::Filter(_) => {} + EncodeToken::Literal(byte) => total += prices.literal(byte), + EncodeToken::Match { length, distance } => { + total += prices + .match_cost(&state, length, distance, distance_size) + .unwrap(); + state.remember(length, distance); + } + } + } + total + }; + + assert!( + bits(&repriced) < bits(&guessed), + "repriced {} bits against the guess's {}", + bits(&repriced), + bits(&guessed), + ); +} + +#[test] +fn blocks_are_short_enough_to_refit_the_tables_when_the_data_changes() { + // Four stretches, one block each, every one drawing from its own + // sixteen bytes. A table per block codes sixteen symbols; one table + // over the member codes sixty-four. Raising LZ_BLOCK_SIZE trades the + // first for the second, which is what cost the corpus 6.4% until the + // block came down from a mebibyte. + let stretch_len = 64 * 1024; + let mut data = Vec::with_capacity(stretch_len * 4); + let mut noise = 0x2545_f491_4f6c_dd1du64; + for stretch in 0..4u8 { + for _ in 0..stretch_len { + noise ^= noise << 13; + noise ^= noise >> 7; + noise ^= noise << 17; + data.push(stretch * 16 + (noise >> 40) as u8 % 16); + } + } + let options = EncodeOptions::new(0); + + let blocked = encode_lz_member_with_options(&data, 0, options).unwrap(); + let single = encode_lz_block(&data, &[], 0, &[], options, true, None).unwrap(); + + assert!( + blocked.len() * 100 < single.len() * 90, + "member blocks {} did not beat one block over the lot {single}", + blocked.len(), + single = single.len(), + ); +} + +#[test] +fn large_filtered_lz_members_split_filter_records_by_block() { + let last_block_start = FILTERED_LZ_BLOCK_SIZE * 2; + let mut data: Vec<_> = (0..last_block_start + 512) + .map(|index| index as u8) + .collect(); + data[256] = 0xe8; + data[257..261].copy_from_slice(&0x20u32.to_le_bytes()); + data[last_block_start + 64] = 0xe8; + data[last_block_start + 65..last_block_start + 69].copy_from_slice(&0x40u32.to_le_bytes()); + + let encoded = Unpack50Encoder::with_options(EncodeOptions::new(0)) + .encode_member_with_filter( + &data, + 0, + crate::FilterSpec::range(crate::FilterKind::E8, 0..data.len()), + ) + .unwrap(); + let mut cursor = std::io::Cursor::new(encoded.as_slice()); + let first = read_compressed_block(&mut cursor).unwrap(); + let mut blocks = 1usize; + let mut last_is_last = first.header.is_last; + while cursor.position() < encoded.len() as u64 { + last_is_last = read_compressed_block(&mut cursor).unwrap().header.is_last; + blocks += 1; + } + let mut decoder = Unpack50Decoder::new(); + + assert!(!first.header.is_last); + assert!(last_is_last); + assert!(blocks > 2); + assert_eq!( + decoder + .decode_member(&encoded, 0, data.len(), false, DecodeMode::Lz) + .unwrap(), + data + ); +} + +/// The window a filtered member is parsed in reaches back into the +/// history the solid stream carries, and keeps reaching for every block +/// of it rather than only the first. Each block used to be handed its own +/// copy of that history and its own finder rebuilt from it, which cost +/// the member a re-insert per block and reached exactly this far. +#[test] +fn a_solid_filtered_member_matches_history_from_every_block() { + // Bytes that do not compress on their own, so matching the history is + // the only way this member gets small. + let mut state = 0x2545_f491_4f6c_dd1du64; + let mut earlier = Vec::with_capacity(FILTERED_LZ_BLOCK_SIZE * 3); + while earlier.len() < FILTERED_LZ_BLOCK_SIZE * 3 { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + earlier.extend_from_slice(&state.to_le_bytes()); + } + earlier[512] = 0xe8; + earlier[513..517].copy_from_slice(&0x30u32.to_le_bytes()); + // Repeating what came before means every block of this member, not + // just its first, has something to match against the history. + let data = earlier.clone(); + let filter = crate::FilterSpec::range(crate::FilterKind::E8, 0..data.len()); + + let mut solid = Unpack50Encoder::with_options(EncodeOptions::new(16)); + solid + .state + .history + .remember(&earlier, solid.state.options.max_match_distance) + .unwrap(); + let against_history = solid + .encode_member_with_filter(&data, 0, filter.clone()) + .unwrap(); + let alone = Unpack50Encoder::with_options(EncodeOptions::new(16)) + .encode_member_with_filter(&data, 0, filter) + .unwrap(); + + assert!( + against_history.len() * 20 < alone.len(), + "a member repeating its history packed to {} against {alone} on its own", + against_history.len(), + alone = alone.len(), + ); +} + +#[test] +fn filters_are_split_before_rar_reader_filter_limit() { + let data = vec![0u8; FILTERED_LZ_BLOCK_SIZE + 1]; + let encoded = + Unpack50Encoder::with_options(EncodeOptions::new(0).with_max_match_distance(128 * 1024)) + .encode_member_with_filter( + &data, + 0, + crate::FilterSpec::whole(crate::FilterKind::Delta { channels: 4 }), + ) + .unwrap(); + let mut cursor = std::io::Cursor::new(encoded.as_slice()); + let first = read_compressed_block(&mut cursor).unwrap(); + let second = read_compressed_block(&mut cursor).unwrap(); + let mut decoder = Unpack50Decoder::new(); + + assert!(!first.header.is_last); + assert!(second.header.is_last); + assert_eq!( + decoder + .decode_member(&encoded, 0, data.len(), false, DecodeMode::Lz) + .unwrap(), + data + ); +} + +#[test] +fn solid_encoder_history_limit_follows_encode_options_dictionary() { + let mut encoder = Unpack50Encoder::with_options( + EncodeOptions::new(0).with_max_match_distance(DEFAULT_DICTIONARY_SIZE + 1024), + ); + encoder + .state + .history + .remember( + &vec![0x41; DEFAULT_DICTIONARY_SIZE + 512], + encoder.state.options.max_match_distance, + ) + .unwrap(); + + assert_eq!(encoder.state.history.len(), DEFAULT_DICTIONARY_SIZE + 512); + + let mut capped = + Unpack50Encoder::with_options(EncodeOptions::new(0).with_max_match_distance(1024)); + capped + .state + .history + .remember(&vec![0x42; 4096], capped.state.options.max_match_distance) + .unwrap(); + + assert_eq!(capped.state.history.len(), 1024); +} + +#[test] +fn cloned_encoder_keeps_an_independent_solid_history() { + let first = b"prefix repeated across solid members"; + let second = b"prefix repeated across solid members with a suffix"; + let mut original = Unpack50Encoder::with_options(EncodeOptions::new(16)); + let packed_first = original.encode_member(first, 0).unwrap(); + let mut cloned = original.clone(); + let packed_original = original.encode_member(second, 0).unwrap(); + let packed_clone = cloned.encode_member(second, 0).unwrap(); + assert_eq!(packed_clone, packed_original); + + let mut decoder = Unpack50Decoder::new(); + assert_eq!( + decoder + .decode_member(&packed_first, 0, first.len(), false, DecodeMode::Lz) + .unwrap(), + first + ); + assert_eq!( + decoder + .decode_member(&packed_clone, 0, second.len(), true, DecodeMode::Lz) + .unwrap(), + second + ); + + let clone_history = cloned.state.history.to_vec(); + original + .encode_member(b"a divergent third member", 0) + .unwrap(); + assert_eq!(cloned.state.history.to_vec(), clone_history); +} + +#[test] +fn encodes_lz_member_with_last_length_repeat_symbols() { + let data = b"abcdXabcdYabcdZabcd"; + let input = encode_lz_member(data, 0).unwrap(); + let block = parse_compressed_block(&input).unwrap(); + let (lengths, _) = read_table_lengths(&input[block.payload], 0).unwrap(); + + let output = decode_lz(&input, 0, data.len()).unwrap(); + + assert_eq!(output, data); + assert_ne!(lengths.main[257], 0); +} + +#[test] +fn encodes_lz_member_using_rar70_distance_table_shape() { + let data = b"RAR7-compatible repeated phrase repeated phrase repeated phrase"; + let input = encode_lz_member(data, 1).unwrap(); + + let output = decode_lz(&input, 1, data.len()).unwrap(); + + assert_eq!(output, data); +} + +#[test] +fn decode_member_from_reader_accepts_incremental_input() { + struct OneByteReader<'a> { + data: &'a [u8], + pos: usize, + } + + impl Read for OneByteReader<'_> { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if self.pos >= self.data.len() { + return Ok(0); + } + out[0] = self.data[self.pos]; + self.pos += 1; + Ok(1) + } + } + + let payload = literal_only_payload(b"ABBA"); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + let mut reader = OneByteReader { + data: &input, + pos: 0, + }; + let mut decoder = Unpack50Decoder::new(); + + let output = decoder + .decode_member_from_reader(&mut reader, 0, 4, false, DecodeMode::LiteralOnly) + .unwrap(); + + assert_eq!(output, b"ABBA"); +} + +#[test] +fn decoders_stop_at_declared_size_before_a_nonfinal_block() { + let payload = literal_only_payload(b"AB"); + let block = encode_compressed_block(&payload, payload.len() * 8, true, false).unwrap(); + let mut input = block.clone(); + input.extend_from_slice(b"not another block"); + + assert_eq!(decode_literal_only(&input, 0, 2).unwrap(), b"AB"); + let mut reader = input.as_slice(); + let mut streamed = Vec::new(); + Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut reader, + 0, + 2, + DEFAULT_DICTIONARY_SIZE, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => streamed.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + streamed.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(streamed, b"AB"); + assert_eq!(reader, &input[block.len()..]); +} + +#[test] +fn decodes_synthetic_new_match_block() { + let payload = new_match_payload(); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + + let output = decode_lz(&input, 0, 4).unwrap(); + + assert_eq!(output, b"ABAB"); +} + +#[test] +fn decodes_synthetic_last_length_match_block() { + let payload = repeat_payload(257); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + + let output = decode_lz(&input, 0, 6).unwrap(); + + assert_eq!(output, b"ABABAB"); +} + +#[test] +fn decodes_synthetic_repeat_distance_match_block() { + let payload = repeat_payload(258); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + + let output = decode_lz(&input, 0, 6).unwrap(); + + assert_eq!(output, b"ABABAB"); +} + +#[test] +fn rejects_literal_only_block_without_tables() { + let input = encode_compressed_block(&[0], 8, false, true).unwrap(); + + assert_eq!( + decode_literal_only(&input, 0, 1), + Err(Error::InvalidData("RAR 5 block reuses missing tables")) + ); +} + +#[test] +fn decoders_propagate_malformed_table_errors() { + let mut incomplete = BitWriter::new(); + for _ in 0..LEVEL_TABLE_SIZE { + incomplete.write_bits(5, 4); + } + let incomplete = incomplete.finish(); + + let mut invalid = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + invalid.main[..3].fill(1); // Three one-bit codes overfill the tree. + let (invalid, invalid_bits) = encode_table_lengths_with_bit_count(&invalid, 0).unwrap(); + + for (payload, payload_bits, expected) in [ + ( + incomplete.as_slice(), + incomplete.len() * 8, + Error::NeedMoreInput, + ), + ( + invalid.as_slice(), + invalid_bits, + Error::InvalidData("RAR 5 oversubscribed Huffman table"), + ), + ] { + let input = encode_compressed_block(payload, payload_bits, true, true).unwrap(); + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::LiteralOnly, + ), + Err(expected.clone()) + ); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!(result, Err(StreamDecodeError::Decode(error)) if error == expected)); + } +} + +#[test] +fn decoders_reject_invalid_packed_huffman_symbol() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; // Only the zero bit names a symbol. + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(0x7fff, 15); // No prefix can name 'A'. + let payload_bits = writer.bit_pos; + let input = encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap(); + let expected = Error::InvalidData("RAR 5 invalid Huffman code"); + + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::LiteralOnly, + ), + Err(expected.clone()) + ); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!(result, Err(StreamDecodeError::Decode(error)) if error == expected)); +} + +#[test] +fn decoders_report_truncated_match_extra_bits() { + for (length_slot, distance_slot, packed) in [ + // Seven literals and a new match. Main symbol 270 means length + // slot 8, which needs one more bit. + (8, 0, 0b0000_0001), + // Six literals, a new match, and distance slot 4. Its extra bit + // is absent after the one-bit distance code. + (0, 4, 0b0000_0010), + ] { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[262 + length_slot] = 1; + lengths.distance[distance_slot] = 1; + let (tables, table_bits) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut input = encode_compressed_block(&tables, table_bits, true, false).unwrap(); + input.extend(encode_compressed_block(&[packed], 8, false, true).unwrap()); + + let mut buffered = Unpack50Decoder::new(); + let mut cursor = std::io::Cursor::new(&input); + assert_eq!( + buffered.decode_member_from_reader_with_dictionary( + &mut cursor, + 0, + 12, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::NeedMoreInput), + "length slot {length_slot}, distance slot {distance_slot}" + ); + assert!(buffered.state.tables.is_none()); // Error occurred before the block completed. + let mut streaming = Unpack50Decoder::new(); + let result = streaming.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 12, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::NeedMoreInput)) + )); + assert!(streaming.state.tables.is_none()); + } +} + +#[test] +fn decoders_reject_rar7_distance_slot_above_bit_limit() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_70], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[262] = 1; // New match with length slot 0. + lengths.distance[66] = 1; // (66 - 2) / 2 = 32 extra bits. + let (tables, table_bits) = encode_table_lengths_with_bit_count(&lengths, 1).unwrap(); + let mut input = encode_compressed_block(&tables, table_bits, true, false).unwrap(); + input.extend(encode_compressed_block(&[0], 2, false, true).unwrap()); + let expected = Error::InvalidData("RAR 5 distance slot is too large"); + + let mut buffered = Unpack50Decoder::new(); + assert_eq!( + buffered.decode_member_with_dictionary( + &input, + 1, + 2, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(expected.clone()) + ); + assert!(buffered.state.tables.is_none()); + let mut streaming = Unpack50Decoder::new(); + let result = streaming.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 1, + 2, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!(result, Err(StreamDecodeError::Decode(error)) if error == expected)); + assert!(streaming.state.tables.is_none()); +} + +#[test] +fn solid_decoders_report_truncated_repeat_length() { + let bootstrap = new_match_payload(); + let bootstrap = encode_compressed_block(&bootstrap, bootstrap.len() * 8, true, true).unwrap(); + + for (length_slot, packed) in [ + (0, 0b0000_0001), // Seven literals and a repeat, without its length code. + (8, 0b0000_0010), // Six literals, repeat, length slot 8; extra bit absent. + ] { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[258] = 1; + lengths.length[length_slot] = 1; + let (tables, table_bits) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut input = encode_compressed_block(&tables, table_bits, true, false).unwrap(); + input.extend(encode_compressed_block(&[packed], 8, false, true).unwrap()); + + let mut buffered = Unpack50Decoder::new(); + assert_eq!( + buffered + .decode_member_with_dictionary( + &bootstrap, + 0, + 4, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ) + .unwrap(), + b"ABAB" + ); + assert_eq!( + buffered.decode_member_with_dictionary( + &input, + 0, + 20, + DEFAULT_DICTIONARY_SIZE, + true, + DecodeMode::Lz, + ), + Err(Error::NeedMoreInput) + ); + assert!(buffered.state.tables.is_none()); + + let mut streaming = Unpack50Decoder::new(); + streaming + .decode_member_from_reader_with_dictionary_to_sink( + &mut bootstrap.as_slice(), + 0, + 4, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ) + .unwrap(); + let result = streaming.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 20, + DEFAULT_DICTIONARY_SIZE, + true, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::NeedMoreInput)) + )); + assert!(streaming.state.tables.is_none()); + } +} + +#[test] +fn decoders_report_malformed_new_match_distance_fields() { + let mut invalid_align = BitWriter::new(); + invalid_align.write_bits(0, 1); // New match, length slot 0. + invalid_align.write_bits(0, 1); // Distance slot 10. + invalid_align.write_bits(0x7fff, 15); // No alignment prefix names a symbol. + let cases = [ + ( + None, + false, + 0, + vec![0], + 1, + Error::InvalidData("RAR 5 empty Huffman table"), + ), + ( + Some(12), + true, + 6, + vec![0b0000_0010], + 8, + Error::NeedMoreInput, + ), + ( + Some(10), + true, + 0, + invalid_align.finish(), + 17, + Error::InvalidData("RAR 5 invalid Huffman code"), + ), + ]; + + for (distance_slot, align_mode, literal_count, packed, packed_bits, expected) in cases { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[262] = 1; + if literal_count != 0 { + lengths.main[b'A' as usize] = 1; + } + if let Some(slot) = distance_slot { + lengths.distance[slot] = 1; + } + if align_mode { + lengths.align[0] = 1; + } + let (tables, table_bits) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut input = encode_compressed_block(&tables, table_bits, true, false).unwrap(); + input.extend(encode_compressed_block(&packed, packed_bits, false, true).unwrap()); + + let mut buffered = Unpack50Decoder::new(); + assert_eq!( + buffered.decode_member_with_dictionary( + &input, + 0, + 20, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(expected.clone()), + "distance slot {distance_slot:?}" + ); + assert!(buffered.state.tables.is_none()); + let mut streaming = Unpack50Decoder::new(); + let result = streaming.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 20, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!(result, Err(StreamDecodeError::Decode(error)) if error == expected)); + assert!(streaming.state.tables.is_none()); + } +} + +#[test] +fn decodes_length_slots() { + assert_eq!(slot_to_length(0, 0).unwrap(), 2); + assert_eq!(slot_to_length(7, 0).unwrap(), 9); + assert_eq!(slot_to_length(8, 0).unwrap(), 10); + assert_eq!(slot_to_length(8, 1).unwrap(), 11); + assert_eq!(slot_to_length(11, 1).unwrap(), 17); + assert_eq!(slot_to_length(12, 3).unwrap(), 21); + assert_eq!(length_slot_extra_bits(43), 9); +} + +#[test] +fn rejects_out_of_range_length_slots_and_extras() { + assert!(slot_to_length(103, (1 << 24) - 1).is_ok()); + assert_eq!( + slot_to_length(8, 2), + Err(Error::InvalidData("RAR 5 length extra bits exceed slot")) + ); + assert_eq!( + slot_to_length(104, 0), + Err(Error::InvalidData("RAR 5 length slot is too large")) + ); +} + +#[test] +fn encoder_code_table_rejects_oversubscribed_lengths() { + assert_eq!( + EncoderCodeTable::from_lengths(&[1, 1, 1], &Allowance::default()).err(), + Some(Error::InvalidData("RAR 5 oversubscribed Huffman table")) + ); +} + +#[test] +fn decodes_distance_slots() { + assert_eq!(slot_to_distance(0, 0).unwrap(), 1); + assert_eq!(slot_to_distance(3, 0).unwrap(), 4); + assert_eq!(distance_slot_bit_count(4).unwrap(), 1); + assert_eq!(slot_to_distance(4, 0).unwrap(), 5); + assert_eq!(slot_to_distance(4, 1).unwrap(), 6); + assert_eq!(distance_slot_bit_count(10).unwrap(), 4); + assert_eq!(slot_to_distance(10, 15).unwrap(), 48); +} + +#[cfg(target_pointer_width = "64")] +#[test] +fn encoder_rejects_distance_beyond_rar50_table() { + // A caller may raise max_match_distance beyond the RAR 5.0 table's + // range. Such a match must fail before indexing the frequency table. + assert_eq!( + EncoderMatchState::default().encode_match(4, 1usize << 40, DISTANCE_TABLE_SIZE_50), + Err(Error::InvalidData("RAR 5 match distance is too large")) + ); +} + +#[test] +fn match_pricing_and_encoding_reject_invalid_internal_candidates() { + let mut repeated = EncoderMatchState::default(); + repeated.reps[0] = 1; + repeated.last_length = 2; + let too_short = Error::InvalidData("RAR 5 match length is too short"); + assert_eq!( + repeated + .encode_match(1, 1, DISTANCE_TABLE_SIZE_50) + .unwrap_err(), + too_short + ); + assert_eq!( + estimated_match_cost(&repeated, 1, 1, DISTANCE_TABLE_SIZE_50).unwrap_err(), + too_short + ); + + let fresh = EncoderMatchState::default(); + let zero_distance = Error::InvalidData("RAR 5 match distance is zero"); + assert_eq!( + fresh + .encode_match(4, 0, DISTANCE_TABLE_SIZE_50) + .unwrap_err(), + zero_distance + ); + assert_eq!( + estimated_match_cost(&fresh, 4, 0, DISTANCE_TABLE_SIZE_50).unwrap_err(), + zero_distance + ); + let underflow = Error::InvalidData("RAR 5 adjusted match length underflows"); + assert_eq!( + fresh + .encode_match(2, 0x40001, DISTANCE_TABLE_SIZE_50) + .unwrap_err(), + underflow + ); + assert_eq!( + estimated_match_cost(&fresh, 2, 0x40001, DISTANCE_TABLE_SIZE_50).unwrap_err(), + underflow + ); + + #[cfg(target_pointer_width = "64")] + { + let too_distant = Error::InvalidData("RAR 5 match distance is too large"); + assert_eq!( + estimated_match_cost(&fresh, 4, 1usize << 40, DISTANCE_TABLE_SIZE_50).unwrap_err(), + too_distant + ); + let invalid_slot = Error::InvalidData("RAR 5 distance slot is too large"); + assert_eq!( + fresh + .encode_match(5, (1usize << 33) + 1, DISTANCE_TABLE_SIZE_70) + .unwrap_err(), + invalid_slot + ); + assert_eq!( + estimated_match_cost(&fresh, 5, (1usize << 33) + 1, DISTANCE_TABLE_SIZE_70) + .unwrap_err(), + invalid_slot + ); + } +} + +#[test] +fn table_construction_and_stream_pricing_reject_invalid_tokens() { + let invalid = [EncodeToken::Match { + length: 1, + distance: 1, + }]; + assert_eq!( + table_lengths_for_tokens(&invalid, DISTANCE_TABLE_SIZE_50).err(), + Some(Error::InvalidData("RAR 5 match length is too short")) + ); + + let lengths = + table_lengths_for_tokens(&[EncodeToken::Literal(b'A')], DISTANCE_TABLE_SIZE_50).unwrap(); + assert_eq!( + token_stream_bits(&invalid, &[], &lengths, DISTANCE_TABLE_SIZE_50), + Err(Error::InvalidData("RAR 5 match length is too short")) + ); +} + +#[test] +fn optimal_match_collection_grows_beyond_one_run_per_position() { + let mut noise = 0x2545_f491_4f6c_dd1du64; + let data: Vec = (0..4096) + .map(|_| { + noise ^= noise << 13; + noise ^= noise >> 7; + noise ^= noise << 17; + b'A' + ((noise >> 40) as u8 & 1) + }) + .collect(); + let options = EncodeOptions::new(64).with_optimal_parse(true); + let baseline = RefusingBudget::new(usize::MAX); + let mut collector = OptimalCollector::with_allowance(&data, 0, options, &baseline).unwrap(); + let matches = collector.collect(&data, 0..data.len(), options).unwrap(); + assert!(matches.runs.len() > data.len()); + drop(matches); + drop(collector); + assert_eq!(baseline.used(), 0); + + assert_each_allocation_refusal(|budget| { + let mut collector = OptimalCollector::with_allowance(&data, 0, options, budget)?; + collector.collect(&data, 0..data.len(), options) + }); + + let start = data.len() / 2; + let baseline = RefusingBudget::new(usize::MAX); + let mut collector = OptimalCollector::with_allowance(&data, start, options, &baseline).unwrap(); + let matches = collector + .collect(&data, start..data.len(), options) + .unwrap(); + assert!(matches.runs.len() > data.len() - start); + drop(matches); + drop(collector); + assert_eq!(baseline.used(), 0); + + assert_each_allocation_refusal(|budget| { + let mut collector = OptimalCollector::with_allowance(&data, start, options, budget)?; + collector.collect(&data, start..data.len(), options) + }); +} + +#[test] +fn distance_slots_beyond_native_address_width_use_out_of_window_sentinel() { + for (slot, extra, distance) in [ + (63, (1u32 << 30) - 1, 1u64 << 32), + (65, (1u32 << 31) - 1, 1u64 << 33), + ] { + assert_eq!( + slot_to_distance(slot, extra).unwrap(), + usize::try_from(distance).unwrap_or(usize::MAX) + ); + } +} + +#[test] +fn rejects_out_of_range_distance_slots_and_extras() { + #[cfg(target_pointer_width = "64")] + assert!(slot_to_distance(65, (1 << 31) - 1).is_ok()); + assert_eq!( + slot_to_distance(4, 2), + Err(Error::InvalidData("RAR 5 distance extra bits exceed slot")) + ); + assert_eq!( + slot_to_distance(66, 0), + Err(Error::InvalidData("RAR 5 distance slot is too large")) + ); +} + +#[test] +fn bit_reader_accepts_large_rar5_distance_extras() { + let mut bits = BitReader::new(&[0xff, 0x00, 0xaa, 0x55]); + + assert_eq!(bits.read_bits(32).unwrap(), 0xff00_aa55); + assert_eq!( + bits.read_bits(1), + Err(Error::NeedMoreInput), + "32-bit reads must not leave a partial cursor state" + ); +} + +#[test] +fn copies_lz_matches_with_overlap() { + let decoder = Unpack50Decoder::new(); + let mut output = b"AB".to_vec(); + + decoder + .copy_match(&mut output, 2, 6, 8, DEFAULT_DICTIONARY_SIZE) + .unwrap(); + + assert_eq!(output, b"ABABABAB"); +} + +#[test] +fn zero_fills_a_match_that_reaches_past_the_window() { + let decoder = Unpack50Decoder::new(); + let mut output = b"AB".to_vec(); + + decoder + .copy_match(&mut output, 3, 1, 3, DEFAULT_DICTIONARY_SIZE) + .unwrap(); + + assert_eq!(output, b"AB\0"); +} + +#[test] +fn zero_fills_a_zero_distance_match_in_both_outputs() { + let decoder = Unpack50Decoder::new(); + let mut buffered = b"A".to_vec(); + decoder + .copy_match(&mut buffered, 0, 3, 4, DEFAULT_DICTIONARY_SIZE) + .unwrap(); + assert_eq!(buffered, b"A\0\0\0"); + + let mut streaming = StreamingOutput::new(Buffer::from_vec(b"A".to_vec()), 3, 1, 1).unwrap(); + let mut decoded = Vec::new(); + streaming + .copy_match(0, 3, &mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }) + .unwrap(); + streaming + .finish(&mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }) + .unwrap(); + assert_eq!(decoded, b"\0\0\0"); +} + +#[test] +fn rejects_a_match_that_runs_past_the_output_limit() { + let decoder = Unpack50Decoder::new(); + let mut output = b"AB".to_vec(); + + assert_eq!( + decoder.copy_match(&mut output, 1, 2, 3, DEFAULT_DICTIONARY_SIZE), + Err(Error::InvalidData("RAR 5 match exceeds output limit")) + ); + assert_eq!(output, b"AB"); +} + +#[test] +fn zero_fills_a_match_distance_beyond_the_dictionary() { + let decoder = Unpack50Decoder::new(); + let mut output = b"ABCD".to_vec(); + + decoder.copy_match(&mut output, 4, 1, 5, 3).unwrap(); + + assert_eq!(output, b"ABCD\0"); +} + +#[test] +fn buffered_reader_history_capacity_follows_the_active_dictionary() { + let data = b"ABBA".repeat(4096); + let packed = encode_literal_only(&data, 0).unwrap(); + let mut decoder = Unpack50Decoder::new(); + assert_eq!( + decoder + .decode_member_with_dictionary( + &packed, + 0, + data.len(), + 1024, + false, + DecodeMode::LiteralOnly + ) + .unwrap(), + data + ); + assert_eq!(&*decoder.state.history, &data[data.len() - 1024..][..]); + assert!( + decoder.state.history.capacity() <= 1024, + "retained {} bytes for a 1024-byte dictionary", + decoder.state.history.capacity() + ); + let next = b"next solid member"; + let packed = encode_literal_only(next, 0).unwrap(); + decoder + .decode_member_with_dictionary(&packed, 0, next.len(), 1024, true, DecodeMode::LiteralOnly) + .unwrap(); + let expected = [&data[data.len() - (1024 - next.len())..], next.as_slice()].concat(); + assert_eq!(decoder.state.history, expected); + assert!(decoder.state.history.capacity() <= 1024); + decoder + .decode_member_with_dictionary(&packed, 0, next.len(), 8, true, DecodeMode::LiteralOnly) + .unwrap(); + assert_eq!(&*decoder.state.history, &next[next.len() - 8..][..]); + assert!(decoder.state.history.capacity() <= 8); +} + +#[test] +fn filtered_reader_history_retains_only_the_raw_dictionary_tail() { + let data = b"\xe8\0\0\0\0abcdefgh".repeat(256); + let packed = encode_lz_member_with_filter(&data, crate::FilterKind::E8).unwrap(); + let raw = Unpack50Decoder::new() + .decode_member_with_dictionary(&packed, 0, data.len(), 64, false, DecodeMode::LzNoFilters) + .unwrap(); + let mut decoder = Unpack50Decoder::new(); + let decoded = decoder + .decode_member_with_dictionary(&packed, 0, data.len(), 64, false, DecodeMode::Lz) + .unwrap(); + assert_ne!(decoded, raw, "fixture must actually transform bytes"); + assert_eq!(&*decoder.state.history, &raw[raw.len() - 64..][..]); + assert!(decoder.state.history.capacity() <= 64); +} + +#[test] +fn failed_buffered_filter_preserves_previous_solid_history() { + let data = b"\xe8\0\0\0\0abcdefghijklmnop".to_vec(); + let packed = encode_lz_member_with_filter(&data, crate::FilterKind::E8).unwrap(); + let mut decoder = Unpack50Decoder::new(); + decoder.state.history = Buffer::from_vec(b"old raw history".to_vec()); + let history = decoder.state.history.to_vec(); + // The record spans the full member, but the advertised output stops + // one byte earlier: the failure happens during filter application. + assert_eq!( + decoder.decode_member_with_dictionary(&packed, 0, data.len() - 1, 64, true, DecodeMode::Lz), + Err(Error::InvalidData("RAR 5 filter range exceeds output")) + ); + assert_eq!(decoder.state.history, history); +} + +#[test] +fn solid_history_is_capped_to_dictionary_size() { + let mut decoder = Unpack50Decoder::new(); + let first_payload = literal_only_payload(b"ABBA"); + let first = + encode_compressed_block(&first_payload, first_payload.len() * 8, true, true).unwrap(); + let second_payload = literal_only_payload(b"BAAB"); + let second = + encode_compressed_block(&second_payload, second_payload.len() * 8, true, true).unwrap(); + + assert_eq!( + decoder + .decode_member_with_dictionary(&first, 0, 4, 6, false, DecodeMode::LiteralOnly) + .unwrap(), + b"ABBA" + ); + assert_eq!(&*decoder.state.history, &b"ABBA"[..]); + + assert_eq!( + decoder + .decode_member_with_dictionary(&second, 0, 4, 6, true, DecodeMode::LiteralOnly) + .unwrap(), + b"BAAB" + ); + assert_eq!(&*decoder.state.history, &b"BABAAB"[..]); +} + +#[test] +fn streaming_reader_history_capacity_follows_the_active_dictionary() { + let data = b"ABBA".repeat(65536); + let packed = encode_literal_only(&data, 0).unwrap(); + let mut decoder = Unpack50Decoder::new(); + let mut decoded = Vec::new(); + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + data.len(), + 1024, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)) + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(decoded, data); + assert_eq!(&*decoder.state.history, &data[data.len() - 1024..][..]); + assert!(decoder.state.history.capacity() <= 1024); + let next = b"next solid member"; + let packed = encode_literal_only(next, 0).unwrap(); + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + next.len(), + 8, + true, + |_| Ok::<(), std::convert::Infallible>(()), + ) + .unwrap(); + assert_eq!(&*decoder.state.history, &next[next.len() - 8..][..]); + assert!(decoder.state.history.capacity() <= 8); +} + +#[test] +fn streaming_decoder_history_is_capped_without_reordering() { + let mut decoder = Unpack50Decoder::new(); + let first_payload = literal_only_payload(b"ABBA"); + let first = + encode_compressed_block(&first_payload, first_payload.len() * 8, true, true).unwrap(); + let second_payload = literal_only_payload(b"BAAB"); + let second = + encode_compressed_block(&second_payload, second_payload.len() * 8, true, true).unwrap(); + let mut decoded = Vec::new(); + + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut std::io::Cursor::new(&first), + 0, + 4, + 6, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }, + ) + .unwrap(); + assert_eq!(decoded, b"ABBA"); + assert_eq!(&*decoder.state.history, &b"ABBA"[..]); + + decoded.clear(); + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut std::io::Cursor::new(&second), + 0, + 4, + 6, + true, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }, + ) + .unwrap(); + assert_eq!(decoded, b"BAAB"); + assert_eq!(&*decoder.state.history, &b"BABAAB"[..]); +} + +#[test] +fn solid_streaming_decoder_trims_inherited_history_before_member() { + let payload = literal_only_payload(b"AB"); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + let mut decoder = Unpack50Decoder::new(); + decoder.state.history.extend_from_slice(b"123456").unwrap(); + let mut decoded = Vec::new(); + + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 2, + 4, + true, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + + assert_eq!(decoded, b"AB"); + assert_eq!(&*decoder.state.history, &b"56AB"[..]); +} + +#[test] +fn streaming_decoder_handles_each_match_control() { + for (payload, expected) in [ + (new_match_payload(), b"ABAB".as_slice()), + (repeat_payload(257), b"ABABAB".as_slice()), + (repeat_payload(258), b"ABABAB".as_slice()), + ] { + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + let mut decoded = Vec::new(); + Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + expected.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(decoded, expected); + } +} + +#[test] +fn buffered_and_streaming_decoders_reuse_tables_after_table_only_block() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[b'B' as usize] = 1; + let (tables, table_bits) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut input = encode_compressed_block(&tables, table_bits, true, false).unwrap(); + // A = 0, B = 1 with the two one-bit codes above. + input.extend(encode_compressed_block(&[0b0110_0000], 4, false, true).unwrap()); + + let buffered = Unpack50Decoder::new() + .decode_member_with_dictionary( + &input, + 0, + 4, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::LiteralOnly, + ) + .unwrap(); + assert_eq!(buffered, b"ABBA"); + + let mut streamed = Vec::new(); + Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 4, + DEFAULT_DICTIONARY_SIZE, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => streamed.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + streamed.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(streamed, buffered); +} + +#[test] +fn compressed_block_reader_accepts_empty_final_marker_and_checks_header() { + let empty = encode_compressed_block(&[], 0, false, true).unwrap(); + let parsed = parse_compressed_block(&empty).unwrap(); + let streamed = read_compressed_block(&mut empty.as_slice()).unwrap(); + assert!(parsed.header.is_last); + assert_eq!(parsed.header.payload_bits, 0); + assert!(streamed.header.is_last); + assert_eq!(streamed.header.payload_bits, 0); + assert!(streamed.payload.is_empty()); + + assert!(matches!( + read_compressed_block(&mut empty[..2].as_ref()), + Err(Error::NeedMoreInput) + )); + + let mut bad_checksum = empty.clone(); + bad_checksum[1] ^= 1; + assert!(matches!( + read_compressed_block(&mut bad_checksum.as_slice()), + Err(Error::InvalidData("RAR 5 block header checksum mismatch")) + )); + assert_eq!( + parse_compressed_block(&bad_checksum), + Err(Error::InvalidData("RAR 5 block header checksum mismatch")) + ); + let mut invalid_size_width = empty; + invalid_size_width[0] |= 0b11 << 3; + assert!(matches!( + read_compressed_block(&mut invalid_size_width.as_slice()), + Err(Error::InvalidData("RAR 5 block size length is invalid")) + )); + assert_eq!( + parse_compressed_block(&invalid_size_width), + Err(Error::InvalidData("RAR 5 block size length is invalid")) + ); +} + +#[test] +fn parser_handles_largest_declared_block_size_without_overflow() { + let flags = 0b10 << 3; // three size bytes + let checksum = 0x5a ^ flags ^ 0xff ^ 0xff ^ 0xff; + let header = [flags, checksum, 0xff, 0xff, 0xff]; + assert_eq!(parse_compressed_block(&header), Err(Error::NeedMoreInput)); +} + +#[test] +fn reader_block_admits_capacity_before_reading_payload_and_releases_failures() { + let packed = encode_compressed_block(&[0x31; 8], 64, false, true).unwrap(); + let header_len = parse_compressed_block(&packed).unwrap().header_len; + let denied = Allowance::limited(7); + let mut input = std::io::Cursor::new(&packed); + let error = match read_compressed_block_with_allowance(&mut input, &denied) { + Ok(_) => panic!("payload must exceed the allowance"), + Err(error) => error, + }; + assert!(matches!(error, Error::WorkspaceLimitExceeded(ref details) + if details.limit == 7 && details.required == 8 && details.used == 0)); + assert_eq!(input.position(), header_len as u64); + assert_eq!(denied.used(), 0); + + let allowance = Allowance::limited(8); + let block = read_compressed_block_with_allowance(&mut packed.as_slice(), &allowance).unwrap(); + assert_eq!(&*block.payload, &[0x31; 8]); + assert_eq!(allowance.used(), 8); + drop(block); + assert_eq!(allowance.used(), 0); + + struct FailingPayload<'a> { + header: &'a [u8], + } + impl Read for FailingPayload<'_> { + fn read(&mut self, output: &mut [u8]) -> std::io::Result { + if self.header.is_empty() { + return Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "payload read denied", + )); + } + self.header.read(output) + } + } + let mut failing = FailingPayload { + header: &packed[..header_len], + }; + let error = match read_compressed_block_with_allowance(&mut failing, &allowance) { + Ok(_) => panic!("payload read must fail"), + Err(error) => error, + }; + assert!(matches!(error, Error::Io(ref source) + if matches!(**source, crate::Error::Io(ref io) + if io.kind == std::io::ErrorKind::PermissionDenied))); + assert_eq!(allowance.used(), 0); + + let mut truncated = &packed[..packed.len() - 1]; + assert!(matches!( + read_compressed_block_with_allowance(&mut truncated, &allowance), + Err(Error::NeedMoreInput) + )); + assert_eq!(allowance.used(), 0); +} + +#[test] +fn reader_block_keeps_its_worker_charge_after_reservation_retirement() { + use crate::codec::workspace::RESERVATION_BYTES; + let packed = encode_compressed_block(&[0x31; 8], 64, false, true).unwrap(); + let ledger = Allowance::limited(128 + RESERVATION_BYTES); + let mut reservation = ledger.reserve(16).unwrap(); + let allowance = reservation.allowance(); + reservation.start(); + let block = read_compressed_block_with_allowance(&mut packed.as_slice(), &allowance).unwrap(); + let larger = encode_compressed_block(&[0x31; 9], 72, false, true).unwrap(); + assert!(matches!( + read_compressed_block_with_allowance(&mut larger.as_slice(), &allowance), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(allowance.used(), 8); + reservation.retire(); + assert_eq!(ledger.used(), 8 + RESERVATION_BYTES); + drop(block); + assert_eq!(ledger.used(), RESERVATION_BYTES); + drop(allowance); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn parser_rejects_truncated_block_header_and_payload() { + // A two-byte size field requires a fourth header byte. + assert_eq!( + parse_compressed_block(&[1 << 3, 0, 0]), + Err(Error::NeedMoreInput) + ); + let block = encode_compressed_block(&[0xaa, 0xbb], 16, false, true).unwrap(); + for length in 0..block.len() { + assert_eq!( + parse_compressed_block(&block[..length]), + Err(Error::NeedMoreInput), + "truncated at byte {length}" + ); + } + assert_eq!( + parse_compressed_block(&block).unwrap().payload, + 3..block.len() + ); +} + +#[test] +fn decoders_handle_uninitialized_match_controls() { + for (symbol, buffered_error, streaming_error) in [ + (257, Error::NeedMoreInput, Error::NeedMoreInput), + ( + 258, + Error::InvalidData("RAR 5 repeat distance is not initialized"), + Error::InvalidData("RAR 5 repeat distance is not initialized"), + ), + ] { + let input = control_only_block(symbol); + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(buffered_error) + ); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!( + matches!(result, Err(StreamDecodeError::Decode(error)) if error == streaming_error) + ); + } +} + +#[test] +fn decoders_reject_match_that_exceeds_declared_output() { + for (payload, declared_size) in [ + (new_match_payload(), 3), // AB, then a two-byte match. + (repeat_payload(257), 5), // ABAB, then the previous match. + (repeat_payload(258), 5), // ABAB, then a repeat distance. + ] { + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + declared_size, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::InvalidData("RAR 5 match exceeds output limit")) + ); + let result = Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + declared_size, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 match exceeds output limit" + ))) + )); + } +} + +#[test] +fn literal_only_decoder_rejects_every_lz_control_class() { + for symbol in [256, 257, 258, 262] { + let input = control_only_block(symbol); + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::LiteralOnly, + ), + Err(Error::InvalidData( + "RAR 5 literal-only decoder encountered non-literal symbol" + )), + "control symbol {symbol}" + ); + } +} + +#[test] +fn decoder_defaults_match_fresh_state() { + assert_eq!(BlockSplitter::default().counts, BlockSplitter::new().counts); + assert_eq!(BlockSplitter::default().total, BlockSplitter::new().total); + + let default = Unpack50Decoder::default(); + let fresh = Unpack50Decoder::new(); + assert!(default.state.tables.is_none()); + assert!(fresh.state.tables.is_none()); + assert_eq!(default.state.reps, fresh.state.reps); + assert_eq!(default.state.last_length, fresh.state.last_length); + assert_eq!(default.state.history, fresh.state.history); +} + +#[test] +fn decoders_reject_unsupported_filter_type() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[256] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(1, 1); // filter control symbol + writer.write_bits(0, 2); // one-byte offset + writer.write_bits(0, 8); + writer.write_bits(0, 2); // one-byte length + writer.write_bits(1, 8); + writer.write_bits(7, 3); // unsupported filter type + let payload_bits = writer.bit_pos; + let input = encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap(); + + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::InvalidData("RAR 5 filter type is unsupported")) + ); + let result = Unpack50Decoder::new().decode_to_sink_with_filters( + &mut input.as_slice(), + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + Some(&mut |_filter| Ok::<(), std::convert::Infallible>(())), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 filter type is unsupported" + ))) + )); +} + +#[test] +fn streaming_decoder_rejects_missing_tables_and_invalid_dictionary() { + let input = encode_compressed_block(&[0], 8, false, true).unwrap(); + assert_eq!( + Unpack50Decoder::new().decode_member_with_dictionary( + &input, + 0, + 1, + 0, + false, + DecodeMode::LiteralOnly, + ), + Err(Error::InvalidData("RAR 5 dictionary size is zero")) + ); + let decode = |dictionary_size| { + Unpack50Decoder::new().decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 1, + dictionary_size, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ) + }; + assert!(matches!( + decode(1), + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 block reuses missing tables" + ))) + )); + assert!(matches!( + decode(0), + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 dictionary size is zero" + ))) + )); +} + +#[test] +fn streaming_decoder_propagates_sink_failure() { + let payload = literal_only_payload(b"AB"); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + let error = Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 2, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Err("sink failed"), + ) + .unwrap_err(); + assert!(matches!(error, StreamDecodeError::Sink("sink failed"))); +} + +#[test] +fn streaming_decoder_propagates_sink_failure_during_literal_flush() { + let data = vec![b'A'; STREAM_FLUSH_THRESHOLD]; + let input = encode_literal_only(&data, 0).unwrap(); + let mut decoder = Unpack50Decoder::new(); + let mut calls = 0; + let error = decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + data.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| { + calls += 1; + Err("sink failed") + }, + ) + .unwrap_err(); + assert!(matches!(error, StreamDecodeError::Sink("sink failed"))); + assert_eq!(calls, 1); + assert!(decoder.state.tables.is_none()); // The flush failed inside the literal loop. +} + +#[test] +fn streaming_decoder_observes_cancellation_after_literal_flush() { + let data = vec![b'A'; STREAM_FLUSH_THRESHOLD + 1]; + let input = encode_literal_only(&data, 0).unwrap(); + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack50Decoder::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + let mut calls = 0; + + let result = decoder.decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + data.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| { + calls += 1; + token.cancel(); + Ok::<(), std::convert::Infallible>(()) + }, + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::Cancelled)) + )); + assert_eq!(calls, 1); + assert!(decoder.state.tables.is_none()); // The next symbol observed cancellation. +} + +#[test] +fn streaming_match_output_propagates_sink_failures() { + let mut repeated = StreamingOutput::new( + Buffer::new(&Allowance::default()), + STREAM_FLUSH_THRESHOLD, + 2, + 2, + ) + .unwrap(); + assert!(matches!( + repeated.push_repeated(b'A', STREAM_FLUSH_THRESHOLD, &mut |_chunk| Err("sink")), + Err(StreamDecodeError::Sink("sink")) + )); + + let mut zero_flush = StreamingOutput::new(Buffer::new(&Allowance::default()), 2, 2, 2).unwrap(); + zero_flush + .push(b'A', &mut |_chunk| Ok::<(), &str>(())) + .unwrap(); + assert!(matches!( + zero_flush.push_zeroes(1, &mut |_chunk| Err("sink")), + Err(StreamDecodeError::Sink("sink")) + )); + + let mut zero_chunk = StreamingOutput::new(Buffer::from_vec(vec![0]), 1, 2, 2).unwrap(); + assert!(matches!( + zero_chunk.push_zeroes(1, &mut |_chunk| Err("sink")), + Err(StreamDecodeError::Sink("sink")) + )); + + let mut copied = StreamingOutput::new( + Buffer::new(&Allowance::default()), + STREAM_FLUSH_THRESHOLD, + 2, + 2, + ) + .unwrap(); + copied + .push_repeated(b'A', STREAM_FLUSH_THRESHOLD - 1, &mut |_chunk| { + Ok::<(), &str>(()) + }) + .unwrap(); + assert!(matches!( + copied.copy_match(2, 1, &mut |_chunk| Err("sink")), + Err(StreamDecodeError::Sink("sink")) + )); +} + +#[test] +fn decoder_reader_entry_points_observe_existing_cancellation() { + let token = crate::ReadCancellation::new(); + token.cancel(); + let control = crate::read_control::ReadControl::new(Some(&token)); + let mut buffered = Unpack50Decoder::new(); + buffered.read_control = control.clone(); + assert_eq!( + buffered.decode_member_from_reader_with_dictionary( + &mut &[][..], + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::Cancelled) + ); + + let mut streaming = Unpack50Decoder::new(); + streaming.read_control = control; + let result = streaming.decode_member_from_reader_with_dictionary_to_sink( + &mut &[][..], + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ); + assert!(matches!( + result, + Err(StreamDecodeError::Decode(Error::Cancelled)) + )); +} + +#[test] +fn buffered_decoder_wrappers_observe_existing_cancellation() { + let token = crate::ReadCancellation::new(); + token.cancel(); + let control = crate::read_control::ReadControl::new(Some(&token)); + let mut decoder = Unpack50Decoder::new(); + decoder.read_control = control.clone(); + assert_eq!( + decoder.decode_member(&[], 0, 1, false, DecodeMode::Lz), + Err(Error::Cancelled) + ); + + decoder.read_control = control.clone(); + assert_eq!( + decoder.decode_member_with_dictionary( + &[], + 0, + 1, + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::Cancelled) + ); + + decoder.read_control = control; + assert_eq!( + decoder.decode_member_from_reader(&mut &[][..], 0, 1, false, DecodeMode::Lz), + Err(Error::Cancelled) + ); +} + +#[test] +fn buffered_decoder_observes_cancellation_before_and_during_filters() { + let data: Vec = (0..96).map(|index| (index * 7 + index / 3) as u8).collect(); + let input = + encode_lz_member_with_filter(&data, crate::FilterKind::Delta { channels: 3 }).unwrap(); + assert_eq!(decode_lz(&input, 0, data.len()).unwrap(), data); + + for successful_checks in [5, 6] { + let token = crate::ReadCancellation::new(); + let mut decoder = Unpack50Decoder::new(); + decoder.read_control = crate::read_control::ReadControl::new(Some(&token)); + decoder.read_control.cancel_after_checks(successful_checks); + assert_eq!( + decoder.decode_member_from_reader_with_dictionary( + &mut input.as_slice(), + 0, + data.len(), + DEFAULT_DICTIONARY_SIZE, + false, + DecodeMode::Lz, + ), + Err(Error::Cancelled), + "after {successful_checks} checks" + ); + assert!(decoder.state.tables.is_some()); // All packed symbols decoded first. + assert!(decoder.state.history.is_empty()); // Filtered output was not committed. + } +} + +#[test] +fn streaming_decoder_rejects_filter_beyond_declared_output() { + let data = b"\xe8\0\0\0\0plain text after call"; + let input = encode_lz_member_with_filter(data, crate::FilterKind::E8).unwrap(); + let mut record_count = 0; + let error = Unpack50Decoder::new() + .decode_to_sink_with_filters( + &mut input.as_slice(), + 0, + data.len() - 1, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + Some(&mut |_filter| { + record_count += 1; + Ok::<(), std::convert::Infallible>(()) + }), + ) + .unwrap_err(); + assert!(matches!( + error, + StreamDecodeError::Decode(Error::InvalidData("RAR 5 filter range exceeds output")) + )); + assert_eq!(record_count, 0); +} + +#[test] +fn streaming_decoder_propagates_filter_record_failure() { + let data = b"\xe8\0\0\0\0plain text after call"; + let input = encode_lz_member_with_filter(data, crate::FilterKind::E8).unwrap(); + let error = Unpack50Decoder::new() + .decode_to_sink_with_filters( + &mut input.as_slice(), + 0, + data.len(), + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), &str>(()), + Some(&mut |_filter| Err("filter failed")), + ) + .unwrap_err(); + assert!(matches!(error, StreamDecodeError::Sink("filter failed"))); +} + +#[test] +fn streaming_decoder_reports_truncated_block_and_incomplete_output() { + let payload = literal_only_payload(b"AB"); + let input = encode_compressed_block(&payload, payload.len() * 8, true, true).unwrap(); + for truncated in [&input[..1], &input[..input.len() - 1]] { + let mut reader = truncated; + let error = Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut reader, + 0, + 2, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ) + .unwrap_err(); + assert!(matches!( + error, + StreamDecodeError::Decode(Error::NeedMoreInput) + )); + } + let error = Unpack50Decoder::new() + .decode_member_from_reader_with_dictionary_to_sink( + &mut input.as_slice(), + 0, + 3, + DEFAULT_DICTIONARY_SIZE, + false, + |_chunk| Ok::<(), std::convert::Infallible>(()), + ) + .unwrap_err(); + assert!(matches!( + error, + StreamDecodeError::Decode(Error::NeedMoreInput) + )); +} + +#[test] +fn streaming_output_rejects_overruns_without_partial_emission() { + let emitted = std::cell::RefCell::new(Vec::new()); + let mut sink = |chunk: DecodedChunk<'_>| { + match chunk { + DecodedChunk::Bytes(bytes) => emitted.borrow_mut().extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + emitted.borrow_mut().extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }; + + let mut literal = StreamingOutput::new(Buffer::new(&Allowance::default()), 1, 1, 1).unwrap(); + literal.push(b'A', &mut sink).unwrap(); + assert!(matches!( + literal.push(b'B', &mut sink), + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 match exceeds output limit" + ))) + )); + literal.finish(&mut sink).unwrap(); + assert_eq!(&*emitted.borrow(), b"A"); + + emitted.borrow_mut().clear(); + let mut repeated = StreamingOutput::new(Buffer::new(&Allowance::default()), 1, 1, 1).unwrap(); + assert!(matches!( + repeated.push_repeated(b'B', 2, &mut sink), + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 match exceeds output limit" + ))) + )); + assert_eq!(repeated.written(), 0); + assert!(emitted.borrow().is_empty()); + + let mut zeroes = StreamingOutput::new(Buffer::from_vec(vec![0]), 1, 1, 1).unwrap(); + assert!(matches!( + zeroes.push_zeroes(2, &mut sink), + Err(StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 match exceeds output limit" + ))) + )); + assert_eq!(zeroes.written(), 0); + assert!(emitted.borrow().is_empty()); + zeroes.push_zeroes(1, &mut sink).unwrap(); + assert_eq!(&*emitted.borrow(), &[0]); + assert_eq!(zeroes.into_history().into_vec(), [0]); +} + +#[test] +fn virtual_zero_history_does_not_overallocate_a_tiny_dictionary() { + let mut output = StreamingOutput::new(Buffer::from_vec(vec![0]), 100_000, 1, 1).unwrap(); + let mut emitted = 0; + output + .copy_match(1, 100_000, &mut |chunk| { + let DecodedChunk::Repeated { byte: 0, len } = chunk else { + panic!("expected virtual zeros") + }; + emitted += len; + Ok::<(), std::convert::Infallible>(()) + }) + .unwrap(); + assert_eq!(emitted, 100_000); + assert_eq!(output.history.iter().copied().collect::>(), [0]); + assert_eq!(output.history.capacity(), 1); +} + +#[test] +fn virtual_zero_history_flush_refusal_releases_streaming_charge() { + let budget = RefusingBudget::new(1); + { + let mut output = StreamingOutput::new(Buffer::new(&budget), 3, 1, 1).unwrap(); + output + .push(0, &mut |_| Ok::<(), std::convert::Infallible>(())) + .unwrap(); + let mut emitted = Vec::new(); + let error = output + .copy_match(1, 2, &mut |chunk| { + let DecodedChunk::Bytes(bytes) = chunk else { + panic!("expected initial literal") + }; + emitted.extend_from_slice(bytes); + Ok::<(), std::convert::Infallible>(()) + }) + .unwrap_err(); + assert!(matches!(error, StreamDecodeError::Decode(Error::Cancelled))); + // The initial literal is streamed before retaining its history fails. + assert_eq!(emitted, [0]); + assert_eq!(output.written(), 1); + assert!(output.history.is_empty()); + assert_eq!(budget.attempts(), 2); + } + assert_eq!(budget.used(), 0); +} + +#[test] +fn streaming_flush_preserves_dictionary_tail_with_excess_allocation_capacity() { + let mut output = StreamingOutput::new(Buffer::from_vec(b"ABC".to_vec()), 1, 3, 3).unwrap(); + // Model an allocator returning more capacity than requested. Vec's + // public contract permits this even though this host allocates exactly. + let mut history = Vec::with_capacity(8); + history.extend_from_slice(b"ABC"); + output.history = crate::codec::workspace::Deque::from_buffer(Buffer::from_vec(history)); + assert!(output.history.capacity() > output.history_limit); + let mut emitted = Vec::new(); + let mut sink = |chunk: DecodedChunk<'_>| { + let DecodedChunk::Bytes(bytes) = chunk else { + panic!("expected bytes") + }; + emitted.extend_from_slice(bytes); + Ok::<(), std::convert::Infallible>(()) + }; + output.push(b'D', &mut sink).unwrap(); + output.finish(&mut sink).unwrap(); + assert_eq!(emitted, b"D"); + assert_eq!(output.history.iter().copied().collect::>(), b"BCD"); +} + +#[test] +fn initial_repeat_distance_zero_is_rejected_before_streaming_output() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[258] = 1; + lengths.length[0] = 1; + lengths.length[1] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(1, 1); // Repeat the still-zero first distance. + writer.write_bits(0, 1); // Length two. + let payload_bits = writer.bit_pos; + let packed = encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap(); + assert_eq!( + decode_lz(&packed, 0, 2), + Err(Error::InvalidData( + "RAR 5 repeat distance is not initialized" + )) + ); + let mut decoder = Unpack50Decoder::new(); + let mut emitted = Vec::new(); + let error = decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + 2, + 1, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => emitted.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + emitted.extend(std::iter::repeat_n(byte, len)) + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap_err(); + assert!(matches!( + error, + StreamDecodeError::Decode(Error::InvalidData( + "RAR 5 repeat distance is not initialized" + )) + )); + assert!(emitted.is_empty()); +} + +#[test] +fn zero_literal_and_initialized_matches_stream_virtual_zero_history() { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[0] = 1; + lengths.main[258] = 2; + lengths.main[262] = 2; + lengths.distance[0] = 1; + lengths.distance[1] = 1; + lengths.length[0] = 1; + lengths.length[1] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(0, 1); // Zero literal. + writer.write_bits(3, 2); // New match: length two. + writer.write_bits(0, 1); // Distance one. + writer.write_bits(2, 2); // Repeat distance one. + writer.write_bits(0, 1); // Length two. + let payload_bits = writer.bit_pos; + let packed = encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap(); + assert_eq!(decode_lz(&packed, 0, 5).unwrap(), [0; 5]); + let mut decoder = Unpack50Decoder::new(); + let mut bytes = Vec::new(); + let mut virtual_bytes = 0; + decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed.as_slice(), + 0, + 5, + 1, + false, + |chunk| { + match chunk { + DecodedChunk::Bytes(literals) => bytes.extend_from_slice(literals), + DecodedChunk::Repeated { byte, len } => { + assert_eq!(byte, 0); + virtual_bytes += len; + bytes.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }, + ) + .unwrap(); + assert_eq!(bytes, [0; 5]); + assert_eq!(virtual_bytes, 4); +} + +#[test] +fn streaming_zero_history_emits_large_match_without_materializing_it() { + let mut output = StreamingOutput::new(Buffer::from_vec(vec![0, 0]), 100_000, 2, 2).unwrap(); + let mut chunks = Vec::new(); + output + .copy_match(2, 100_000, &mut |chunk| { + chunks.push(match chunk { + DecodedChunk::Bytes(bytes) => (bytes[0], bytes.len()), + DecodedChunk::Repeated { byte, len } => (byte, len), + }); + Ok::<(), std::convert::Infallible>(()) + }) + .unwrap(); + assert_eq!(chunks, [(0, 100_000)]); + assert_eq!(output.written(), 100_000); + assert_eq!(output.into_history().into_vec(), [0, 0]); +} + +#[test] +fn streaming_match_keeps_its_window_across_flushes() { + let count = STREAM_FLUSH_THRESHOLD + 11; + let mut output = StreamingOutput::new(Buffer::from_vec(b"abc".to_vec()), count, 3, 3).unwrap(); + let mut decoded = Vec::new(); + let mut sink = |chunk: DecodedChunk<'_>| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::convert::Infallible>(()) + }; + output.copy_match(3, count, &mut sink).unwrap(); + output.finish(&mut sink).unwrap(); + assert_eq!( + decoded, + b"abc" + .iter() + .copied() + .cycle() + .take(count) + .collect::>() + ); + assert!(output.history.capacity() <= 3); + assert_eq!(output.into_history().into_vec(), b"abc"); +} + +#[test] +fn streaming_window_accepts_match_beyond_old_64_mib_cap() { + const OLD_STREAM_HISTORY_LIMIT: usize = 64 * 1024 * 1024; + let distance = OLD_STREAM_HISTORY_LIMIT + 1; + let history = vec![b'A'; distance]; + let mut output = + StreamingOutput::new(Buffer::from_vec(history), 1, distance, distance).unwrap(); + let mut decoded = Vec::new(); + + output + .copy_match(distance, 1, &mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }) + .unwrap(); + output + .finish(&mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }) + .unwrap(); + + assert_eq!(decoded, b"A"); +} + +#[test] +fn streaming_window_zero_fills_match_beyond_declared_dictionary() { + let mut output = StreamingOutput::new(Buffer::from_vec(vec![b'A'; 8]), 1, 7, 8).unwrap(); + let mut decoded = Vec::new(); + + output + .copy_match(8, 1, &mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }) + .unwrap(); + output + .flush(&mut |chunk| { + match chunk { + DecodedChunk::Bytes(bytes) => decoded.extend_from_slice(bytes), + DecodedChunk::Repeated { byte, len } => { + decoded.extend(std::iter::repeat_n(byte, len)); + } + } + Ok::<(), std::io::Error>(()) + }) + .unwrap(); + + assert_eq!(decoded, b"\0"); +} + +fn literal_only_payload(data: &[u8]) -> Vec { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[b'B' as usize] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + for &byte in data { + match byte { + b'A' => writer.write_bits(0, 1), + b'B' => writer.write_bits(1, 1), + _ => panic!("test helper only encodes A/B"), + } + } + writer.finish() +} + +fn new_match_payload() -> Vec { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 2; + lengths.main[b'B' as usize] = 2; + lengths.main[262] = 2; + lengths.distance[1] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + + writer.write_bits(0b00, 2); // 'A' + writer.write_bits(0b01, 2); // 'B' + writer.write_bits(0b10, 2); // match length 2 + writer.write_bits(0, 1); // distance slot 1 + writer.finish() +} + +fn repeat_payload(repeat_symbol: usize) -> Vec { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 2; + lengths.main[b'B' as usize] = 2; + lengths.main[repeat_symbol] = 2; + lengths.main[262] = 2; + lengths.distance[1] = 1; + lengths.length[0] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + + writer.write_bits(0b00, 2); // 'A' + writer.write_bits(0b01, 2); // 'B' + writer.write_bits(0b11, 2); // match length 2 + writer.write_bits(0, 1); // distance slot 1 + writer.write_bits(0b10, 2); // repeat control symbol + if repeat_symbol == 258 { + writer.write_bits(0, 1); // length slot 0 + } + writer.finish() +} + +fn control_only_block(symbol: usize) -> Vec { + let mut lengths = TableLengths { + main: vec![0; MAIN_TABLE_SIZE], + distance: vec![0; DISTANCE_TABLE_SIZE_50], + align: vec![0; ALIGN_TABLE_SIZE], + length: vec![0; LENGTH_TABLE_SIZE], + }; + lengths.main[b'A' as usize] = 1; + lengths.main[symbol] = 1; + let (bytes, bit_pos) = encode_table_lengths_with_bit_count(&lengths, 0).unwrap(); + let mut writer = BitWriter { + bytes: Buffer::from_vec(bytes), + bit_pos, + }; + writer.write_bits(1, 1); + let payload_bits = writer.bit_pos; + encode_compressed_block(&writer.finish(), payload_bits, true, true).unwrap() +} diff --git a/arca-rar/vendor/rars/src/codec/rarvm.rs b/arca-rar/vendor/rars/src/codec/rarvm.rs new file mode 100644 index 00000000..f1b5e683 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rarvm.rs @@ -0,0 +1,1093 @@ +use super::workspace::{Allowance, Budget, Buffer}; +use super::{Error, Result}; + +const MEMORY_SIZE: usize = 0x40000; +const MEMORY_MASK: u32 = 0x3ffff; +const GLOBAL_BASE: usize = 0x3c000; +const SYSTEM_GLOBAL_SIZE: usize = 64; +const MAX_USER_GLOBAL: usize = 0x2000 - SYSTEM_GLOBAL_SIZE; +const MAX_STATIC_DATA: usize = MEMORY_SIZE - GLOBAL_BASE; +const MAX_INSTRUCTIONS: usize = 25_000_000; +const FLAG_C: u32 = 1; +const FLAG_Z: u32 = 2; +const FLAG_S: u32 = 0x8000_0000; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Program { + pub static_data: Vec, + pub instructions: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Instruction { + pub opcode: Opcode, + pub byte_mode: bool, + pub operands: Vec, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u8)] +pub enum Opcode { + Mov = 0, + Cmp = 1, + Add = 2, + Sub = 3, + Jz = 4, + Jnz = 5, + Inc = 6, + Dec = 7, + Jmp = 8, + Xor = 9, + And = 10, + Or = 11, + Test = 12, + Js = 13, + Jns = 14, + Jb = 15, + Jbe = 16, + Ja = 17, + Jae = 18, + Push = 19, + Pop = 20, + Call = 21, + Ret = 22, + Not = 23, + Shl = 24, + Shr = 25, + Sar = 26, + Neg = 27, + Pusha = 28, + Popa = 29, + Pushf = 30, + Popf = 31, + Movzx = 32, + Movsx = 33, + Xchg = 34, + Mul = 35, + Div = 36, + Adc = 37, + Sbb = 38, + Print = 39, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Operand { + Register(u8), + Immediate(u32), + RegisterIndirect(u8), + Indexed { register: u8, base: u32 }, + Absolute(u32), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Invocation<'a> { + pub input: &'a [u8], + pub regs: [u32; 7], + pub global_data: &'a [u8], + pub file_offset: u64, + pub exec_count: u32, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ExecutionResult { + pub output: Vec, + pub globals: Vec, + pub regs: [u32; 8], +} + +impl Program { + pub fn parse(blob: &[u8]) -> Result { + OwnedProgram::parse(blob, &Allowance::default()).map(OwnedProgram::into_public) + } + + pub fn execute(&self, invocation: Invocation<'_>) -> Result { + self.execute_with_control(invocation, &crate::read_control::ReadControl::default()) + } + + pub(crate) fn execute_with_control( + &self, + invocation: Invocation<'_>, + control: &crate::read_control::ReadControl, + ) -> Result { + control.check_codec()?; + let mut vm = Vm::with_allowance(self, invocation, &Allowance::default())?; + vm.run(self, control).map(OwnedExecutionResult::into_public) + } +} + +#[derive(Debug)] +pub(crate) struct OwnedProgram { + static_data: Buffer, + instructions: Buffer, B>, +} +#[derive(Debug)] +struct OwnedInstruction { + opcode: Opcode, + byte_mode: bool, + operands: Buffer, +} +impl OwnedProgram { + pub(crate) fn try_clone(&self) -> Result { + let allowance = self.static_data.allowance(); + Ok(Self { + static_data: Buffer::copied(&self.static_data, &allowance)?, + instructions: Buffer::try_collect( + self.instructions.iter().map(|instruction| { + Ok(OwnedInstruction { + opcode: instruction.opcode, + byte_mode: instruction.byte_mode, + operands: Buffer::copied(&instruction.operands, &allowance)?, + }) + }), + &allowance, + )?, + }) + } + pub(crate) fn execute_with_control( + &self, + invocation: Invocation<'_>, + control: &crate::read_control::ReadControl, + ) -> Result> { + control.check_codec()?; + let mut vm = Vm::with_allowance(self, invocation, &self.static_data.allowance())?; + vm.run(self, control) + } + pub(crate) fn parse(blob: &[u8], allowance: &B) -> Result { + if blob.is_empty() { + return Err(Error::InvalidData("RARVM program blob is empty")); + } + if blob.iter().fold(0u8, |acc, &byte| acc ^ byte) != 0 { + return Err(Error::InvalidData("RARVM program checksum mismatch")); + } + + let mut bits = BitReader::new(&blob[1..]); + let mut static_data = Buffer::new(allowance); + if bits.read_bit()? != 0 { + let size = bits + .read_vm_number()? + .checked_add(1) + .ok_or(Error::InvalidData("RARVM static data size overflows"))? + as usize; + if size > MAX_STATIC_DATA { + return Err(Error::InvalidData("RARVM static data is too large")); + } + static_data = Buffer::with_capacity(size, allowance)?; + for _ in 0..size { + static_data.push_admitted(bits.read_bits(8)? as u8); + } + } + + let mut instructions = Buffer::new(allowance); + while bits.remaining_bits() >= 8 { + match parse_instruction_with_allowance(&mut bits, instructions.len(), allowance) { + Ok(instruction) => instructions.try_push(instruction)?, + // Instruction decoding only performs bounded bit reads. An + // incomplete final instruction is ignored for compatibility. + Err(Error::NeedMoreInput | Error::InvalidData(_)) => break, + Err(error) => return Err(error), + } + } + + if instructions + .last() + .is_none_or(|instruction| !instruction.opcode.is_unconditional_control_transfer()) + { + instructions.try_push(OwnedInstruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Buffer::new(allowance), + })?; + } + + Ok(Self { + static_data, + instructions, + }) + } +} +#[cfg(test)] +impl From for OwnedProgram { + fn from(program: Program) -> Self { + Self { + static_data: program.static_data.into(), + instructions: program + .instructions + .into_iter() + .map(|instruction| OwnedInstruction { + opcode: instruction.opcode, + byte_mode: instruction.byte_mode, + operands: instruction.operands.into(), + }) + .collect::>() + .into(), + } + } +} +impl OwnedProgram { + fn into_public(self) -> Program { + Program { + static_data: self.static_data.into_vec(), + instructions: self + .instructions + .into_vec() + .into_iter() + .map(|instruction| Instruction { + opcode: instruction.opcode, + byte_mode: instruction.byte_mode, + operands: instruction.operands.into_vec(), + }) + .collect(), + } + } +} +struct InstructionRef<'a> { + opcode: Opcode, + byte_mode: bool, + operands: &'a [Operand], +} +trait ProgramCode { + fn static_data(&self) -> &[u8]; + fn instruction(&self, index: usize) -> Option>; + fn instruction_count(&self) -> usize; +} +impl ProgramCode for Program { + fn static_data(&self) -> &[u8] { + &self.static_data + } + fn instruction(&self, index: usize) -> Option> { + self.instructions + .get(index) + .map(|instruction| InstructionRef { + opcode: instruction.opcode, + byte_mode: instruction.byte_mode, + operands: &instruction.operands, + }) + } + fn instruction_count(&self) -> usize { + self.instructions.len() + } +} +impl ProgramCode for OwnedProgram { + fn static_data(&self) -> &[u8] { + &self.static_data + } + fn instruction(&self, index: usize) -> Option> { + self.instructions + .get(index) + .map(|instruction| InstructionRef { + opcode: instruction.opcode, + byte_mode: instruction.byte_mode, + operands: &instruction.operands, + }) + } + fn instruction_count(&self) -> usize { + self.instructions.len() + } +} +#[derive(Debug)] +pub(crate) struct OwnedExecutionResult { + pub(crate) output: Buffer, + pub(crate) globals: Buffer, + pub(crate) regs: [u32; 8], +} +impl OwnedExecutionResult { + fn into_public(self) -> ExecutionResult { + ExecutionResult { + output: self.output.into_vec(), + globals: self.globals.into_vec(), + regs: self.regs, + } + } +} + +impl Opcode { + fn from_encoded(value: u8) -> Self { + const OPCODES: [Opcode; 40] = [ + Opcode::Mov, + Opcode::Cmp, + Opcode::Add, + Opcode::Sub, + Opcode::Jz, + Opcode::Jnz, + Opcode::Inc, + Opcode::Dec, + Opcode::Jmp, + Opcode::Xor, + Opcode::And, + Opcode::Or, + Opcode::Test, + Opcode::Js, + Opcode::Jns, + Opcode::Jb, + Opcode::Jbe, + Opcode::Ja, + Opcode::Jae, + Opcode::Push, + Opcode::Pop, + Opcode::Call, + Opcode::Ret, + Opcode::Not, + Opcode::Shl, + Opcode::Shr, + Opcode::Sar, + Opcode::Neg, + Opcode::Pusha, + Opcode::Popa, + Opcode::Pushf, + Opcode::Popf, + Opcode::Movzx, + Opcode::Movsx, + Opcode::Xchg, + Opcode::Mul, + Opcode::Div, + Opcode::Adc, + Opcode::Sbb, + Opcode::Print, + ]; + // The short form is three bits and the long form is five bits plus + // eight, so the wire representation can only produce 0..=39. + OPCODES[usize::from(value)] + } + + fn operand_count(self) -> usize { + match self { + Self::Ret | Self::Pusha | Self::Popa | Self::Pushf | Self::Popf | Self::Print => 0, + Self::Jz + | Self::Jnz + | Self::Inc + | Self::Dec + | Self::Jmp + | Self::Js + | Self::Jns + | Self::Jb + | Self::Jbe + | Self::Ja + | Self::Jae + | Self::Push + | Self::Pop + | Self::Call + | Self::Not + | Self::Neg => 1, + Self::Mov + | Self::Cmp + | Self::Add + | Self::Sub + | Self::Xor + | Self::And + | Self::Or + | Self::Test + | Self::Shl + | Self::Shr + | Self::Sar + | Self::Movzx + | Self::Movsx + | Self::Xchg + | Self::Mul + | Self::Div + | Self::Adc + | Self::Sbb => 2, + } + } + + fn supports_byte_mode(self) -> bool { + matches!( + self, + Self::Mov + | Self::Cmp + | Self::Add + | Self::Sub + | Self::Inc + | Self::Dec + | Self::Xor + | Self::And + | Self::Or + | Self::Test + | Self::Not + | Self::Shl + | Self::Shr + | Self::Sar + | Self::Neg + | Self::Xchg + | Self::Mul + | Self::Div + | Self::Adc + | Self::Sbb + ) + } + + fn is_jump_or_call(self) -> bool { + matches!( + self, + Self::Jz + | Self::Jnz + | Self::Jmp + | Self::Js + | Self::Jns + | Self::Jb + | Self::Jbe + | Self::Ja + | Self::Jae + | Self::Call + ) + } + + fn is_unconditional_control_transfer(self) -> bool { + matches!(self, Self::Jmp | Self::Ret) + } +} + +fn parse_instruction_with_allowance( + bits: &mut BitReader<'_>, + instruction_index: usize, + allowance: &B, +) -> Result> { + let opcode = if bits.read_bit()? == 0 { + Opcode::from_encoded(bits.read_bits(3)? as u8) + } else { + Opcode::from_encoded(bits.read_bits(5)? as u8 + 8) + }; + let byte_mode = opcode.supports_byte_mode() && bits.read_bit()? != 0; + let mut operands = Buffer::with_capacity(opcode.operand_count(), allowance)?; + for operand_index in 0..opcode.operand_count() { + let mut operand = parse_operand(bits, byte_mode)?; + if operand_index == 0 && opcode.is_jump_or_call() { + if let Operand::Immediate(value) = operand { + operand = Operand::Immediate(remap_jump_target(value, instruction_index)); + } + } + operands.push_admitted(operand); + } + Ok(OwnedInstruction { + opcode, + byte_mode, + operands, + }) +} + +fn parse_operand(bits: &mut BitReader<'_>, byte_mode: bool) -> Result { + if bits.read_bit()? != 0 { + return Ok(Operand::Register(bits.read_bits(3)? as u8)); + } + if bits.read_bit()? == 0 { + return if byte_mode { + Ok(Operand::Immediate(bits.read_bits(8)?)) + } else { + Ok(Operand::Immediate(bits.read_vm_number()?)) + }; + } + if bits.read_bit()? == 0 { + return Ok(Operand::RegisterIndirect(bits.read_bits(3)? as u8)); + } + if bits.read_bit()? == 0 { + Ok(Operand::Indexed { + register: bits.read_bits(3)? as u8, + base: bits.read_vm_number()?, + }) + } else { + Ok(Operand::Absolute(bits.read_vm_number()?)) + } +} + +fn remap_jump_target(value: u32, instruction_index: usize) -> u32 { + if value >= 256 { + return value - 256; + } + + let mut distance = value as i64; + if distance >= 136 { + distance -= 264; + } else if distance >= 16 { + distance -= 8; + } else if distance >= 8 { + distance -= 16; + } + (instruction_index as i64).wrapping_add(distance) as u32 +} + +struct Vm { + memory: Buffer, + regs: [u32; 8], + flags: u32, +} + +#[derive(Clone, Copy)] +enum ShiftKind { + Left, + Right, + ArithmeticRight, +} + +impl Vm { + fn with_allowance( + program: &impl ProgramCode, + invocation: Invocation<'_>, + allowance: &B, + ) -> Result { + if invocation.input.len() > GLOBAL_BASE { + return Err(Error::InvalidData("RARVM filter input is too large")); + } + + let mut memory = Buffer::filled(MEMORY_SIZE, 0, allowance)?; + memory[..invocation.input.len()].copy_from_slice(invocation.input); + let global_len = invocation.global_data.len().min(0x2000); + memory[GLOBAL_BASE..GLOBAL_BASE + global_len] + .copy_from_slice(&invocation.global_data[..global_len]); + let static_start = GLOBAL_BASE + global_len; + let static_len = program + .static_data() + .len() + .min(MEMORY_SIZE.saturating_sub(static_start)); + memory[static_start..static_start + static_len] + .copy_from_slice(&program.static_data()[..static_len]); + + write_u32( + &mut memory, + GLOBAL_BASE + 0x1c, + invocation.input.len() as u32, + ); + write_u32(&mut memory, GLOBAL_BASE + 0x20, 0); + write_u32( + &mut memory, + GLOBAL_BASE + 0x24, + invocation.file_offset as u32, + ); + write_u32( + &mut memory, + GLOBAL_BASE + 0x28, + (invocation.file_offset >> 32) as u32, + ); + write_u32(&mut memory, GLOBAL_BASE + 0x2c, invocation.exec_count); + + let mut regs = [0u32; 8]; + regs[..7].copy_from_slice(&invocation.regs); + regs[3] = GLOBAL_BASE as u32; + regs[4] = invocation.input.len() as u32; + regs[5] = invocation.exec_count; + regs[6] = invocation.file_offset as u32; + regs[7] = MEMORY_SIZE as u32; + + Ok(Self { + memory, + regs, + flags: 0, + }) + } + + fn run( + &mut self, + program: &impl ProgramCode, + control: &crate::read_control::ReadControl, + ) -> Result> { + self.run_with_limit(program, control, MAX_INSTRUCTIONS) + } + + fn run_with_limit( + &mut self, + program: &impl ProgramCode, + control: &crate::read_control::ReadControl, + instruction_limit: usize, + ) -> Result> { + let mut poller = control.poller(); + let mut ip = 0usize; + let mut terminated = false; + for _ in 0..instruction_limit { + poller.check_codec(0)?; + let Some(instruction) = program.instruction(ip) else { + terminated = true; + break; + }; + ip += 1; + if let Some(next_ip) = self.execute_instruction(&instruction, ip)? { + if next_ip >= program.instruction_count() { + terminated = true; + break; + } + ip = next_ip; + } + if instruction.opcode == Opcode::Ret && self.regs[7] >= MEMORY_SIZE as u32 { + terminated = true; + break; + } + } + if !terminated { + return Err(Error::InvalidData("RARVM instruction limit exceeded")); + } + + let mut output_pos = self.read_u32(GLOBAL_BASE + 0x20) as usize & MEMORY_MASK as usize; + let mut output_size = self.read_u32(GLOBAL_BASE + 0x1c) as usize & MEMORY_MASK as usize; + if output_pos + .checked_add(output_size) + .is_none_or(|end| end > MEMORY_SIZE) + { + output_pos = 0; + output_size = 0; + } + let output = Buffer::copied( + &self.memory[output_pos..output_pos + output_size], + &self.memory.allowance(), + )?; + + let user_global = (self.read_u32(GLOBAL_BASE + 0x30) as usize).min(MAX_USER_GLOBAL); + let globals = Buffer::copied( + &self.memory[GLOBAL_BASE..GLOBAL_BASE + SYSTEM_GLOBAL_SIZE + user_global], + &self.memory.allowance(), + )?; + Ok(OwnedExecutionResult { + output, + globals, + regs: self.regs, + }) + } + + fn execute_instruction( + &mut self, + instruction: &InstructionRef<'_>, + ip: usize, + ) -> Result> { + let byte_mode = instruction.byte_mode; + let op = |index| { + instruction + .operands + .get(index) + .ok_or(Error::InvalidData("RARVM instruction operand is missing")) + }; + match instruction.opcode { + Opcode::Mov => { + let value = self.read_operand(op(1)?, byte_mode); + self.write_operand(op(0)?, value, byte_mode)?; + } + Opcode::Cmp => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + self.set_sub_flags(a, b, 0, byte_mode); + } + Opcode::Add => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + let result = self.mask_width(a.wrapping_add(b), byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + self.set_add_flags(a, b, 0, result, byte_mode); + } + Opcode::Sub => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + let result = self.mask_width(a.wrapping_sub(b), byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + self.set_sub_flags(a, b, 0, byte_mode); + } + Opcode::Jz => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_Z != 0)), + Opcode::Jnz => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_Z == 0)), + Opcode::Inc => { + let value = self.read_operand(op(0)?, byte_mode).wrapping_add(1); + let result = self.mask_width(value, byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + self.set_zs(result, byte_mode); + } + Opcode::Dec => { + let value = self.read_operand(op(0)?, byte_mode).wrapping_sub(1); + let result = self.mask_width(value, byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + self.set_zs(result, byte_mode); + } + Opcode::Jmp => return Ok(Some(self.read_operand(op(0)?, false) as usize)), + Opcode::Xor | Opcode::And | Opcode::Or | Opcode::Test => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + let result = if instruction.opcode == Opcode::Xor { + a ^ b + } else if instruction.opcode == Opcode::Or { + a | b + } else { + a & b + }; + let result = self.mask_width(result, byte_mode); + if instruction.opcode != Opcode::Test { + self.write_operand(op(0)?, result, byte_mode)?; + } + self.set_zs(result, byte_mode); + } + Opcode::Js => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_S != 0)), + Opcode::Jns => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_S == 0)), + Opcode::Jb => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_C != 0)), + Opcode::Jbe => { + return Ok(self.conditional_jump(op(0)?, self.flags & (FLAG_C | FLAG_Z) != 0)); + } + Opcode::Ja => { + return Ok(self.conditional_jump(op(0)?, self.flags & (FLAG_C | FLAG_Z) == 0)); + } + Opcode::Jae => return Ok(self.conditional_jump(op(0)?, self.flags & FLAG_C == 0)), + Opcode::Push => self.push(self.read_operand(op(0)?, false)), + Opcode::Pop => { + let value = self.pop(); + self.write_operand(op(0)?, value, false)?; + } + Opcode::Call => { + self.push(ip as u32); + return Ok(Some(self.read_operand(op(0)?, false) as usize)); + } + Opcode::Ret => { + if self.regs[7] >= MEMORY_SIZE as u32 { + return Ok(Some(usize::MAX)); + } + return Ok(Some(self.pop() as usize)); + } + Opcode::Not => { + let result = self.mask_width(!self.read_operand(op(0)?, byte_mode), byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + } + Opcode::Shl => { + self.shift( + ShiftKind::Left, + op(0)?, + self.read_operand(op(1)?, byte_mode), + byte_mode, + )?; + } + Opcode::Shr => { + self.shift( + ShiftKind::Right, + op(0)?, + self.read_operand(op(1)?, byte_mode), + byte_mode, + )?; + } + Opcode::Sar => { + self.shift( + ShiftKind::ArithmeticRight, + op(0)?, + self.read_operand(op(1)?, byte_mode), + byte_mode, + )?; + } + Opcode::Neg => { + let value = self.read_operand(op(0)?, byte_mode); + let result = self.mask_width(0u32.wrapping_sub(value), byte_mode); + self.write_operand(op(0)?, result, byte_mode)?; + if result == 0 { + self.flags = FLAG_Z; + } else { + self.flags = FLAG_C | (result & self.sign_bit(byte_mode)); + } + } + Opcode::Pusha => { + let regs = self.regs; + for value in regs { + self.push(value); + } + } + Opcode::Popa => { + let mut stack = self.regs[7]; + for index in (0..8).rev() { + self.regs[index] = self.read_mem(stack, false); + stack = stack.wrapping_add(4); + } + } + Opcode::Pushf => self.push(self.flags), + Opcode::Popf => self.flags = self.pop(), + Opcode::Movzx => { + let value = self.read_operand(op(1)?, true) & 0xff; + self.write_operand(op(0)?, value, false)?; + } + Opcode::Movsx => { + let value = self.read_operand(op(1)?, true) as u8 as i8 as i32 as u32; + self.write_operand(op(0)?, value, false)?; + } + Opcode::Xchg => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + self.write_operand(op(0)?, b, byte_mode)?; + self.write_operand(op(1)?, a, byte_mode)?; + } + Opcode::Mul => { + let result = self + .read_operand(op(0)?, byte_mode) + .wrapping_mul(self.read_operand(op(1)?, byte_mode)); + self.write_operand(op(0)?, self.mask_width(result, byte_mode), byte_mode)?; + } + Opcode::Div => { + let divisor = self.read_operand(op(1)?, byte_mode); + if let Some(result) = self.read_operand(op(0)?, byte_mode).checked_div(divisor) { + self.write_operand(op(0)?, result, byte_mode)?; + } + } + Opcode::Adc | Opcode::Sbb => { + let a = self.read_operand(op(0)?, byte_mode); + let b = self.read_operand(op(1)?, byte_mode); + let carry = u32::from(self.flags & FLAG_C != 0); + let result = if instruction.opcode == Opcode::Adc { + self.mask_width(a.wrapping_add(b).wrapping_add(carry), byte_mode) + } else { + self.mask_width(a.wrapping_sub(b).wrapping_sub(carry), byte_mode) + }; + self.write_operand(op(0)?, result, byte_mode)?; + if instruction.opcode == Opcode::Adc { + self.set_add_flags(a, b, carry, result, byte_mode); + } else { + self.set_sub_flags(a, b, carry, byte_mode); + } + } + Opcode::Print => {} + } + Ok(None) + } + + fn conditional_jump(&self, operand: &Operand, condition: bool) -> Option { + condition.then_some(self.read_operand(operand, false) as usize) + } + + fn read_operand(&self, operand: &Operand, byte_mode: bool) -> u32 { + match *operand { + Operand::Register(index) => { + let value = self.regs[index as usize]; + if byte_mode { + value & 0xff + } else { + value + } + } + Operand::Immediate(value) => self.mask_width(value, byte_mode), + Operand::RegisterIndirect(index) => self.read_mem(self.regs[index as usize], byte_mode), + Operand::Indexed { register, base } => { + self.read_mem(base.wrapping_add(self.regs[register as usize]), byte_mode) + } + Operand::Absolute(address) => self.read_mem(address, byte_mode), + } + } + + fn write_operand(&mut self, operand: &Operand, value: u32, byte_mode: bool) -> Result<()> { + match *operand { + Operand::Register(index) => { + let slot = &mut self.regs[index as usize]; + if byte_mode { + *slot = (*slot & 0xffff_ff00) | (value & 0xff); + } else { + *slot = value; + } + } + Operand::RegisterIndirect(index) => { + self.write_mem(self.regs[index as usize], value, byte_mode) + } + Operand::Indexed { register, base } => { + self.write_mem( + base.wrapping_add(self.regs[register as usize]), + value, + byte_mode, + ); + } + Operand::Absolute(address) => self.write_mem(address, value, byte_mode), + Operand::Immediate(_) => { + return Err(Error::InvalidData("RARVM write to immediate operand")) + } + } + Ok(()) + } + + fn read_mem(&self, address: u32, byte_mode: bool) -> u32 { + let address = address & MEMORY_MASK; + if byte_mode { + u32::from(self.memory[address as usize]) + } else { + self.read_u32(address as usize) + } + } + + fn write_mem(&mut self, address: u32, value: u32, byte_mode: bool) { + let address = address & MEMORY_MASK; + if byte_mode { + self.memory[address as usize] = value as u8; + } else { + write_u32(&mut self.memory, address as usize, value); + } + } + + fn read_u32(&self, address: usize) -> u32 { + let address = address as u32; + u32::from_le_bytes([ + self.memory[(address & MEMORY_MASK) as usize], + self.memory[(address.wrapping_add(1) & MEMORY_MASK) as usize], + self.memory[(address.wrapping_add(2) & MEMORY_MASK) as usize], + self.memory[(address.wrapping_add(3) & MEMORY_MASK) as usize], + ]) + } + + fn push(&mut self, value: u32) { + self.regs[7] = self.regs[7].wrapping_sub(4); + self.write_mem(self.regs[7], value, false); + } + + fn pop(&mut self) -> u32 { + let value = self.read_mem(self.regs[7], false); + self.regs[7] = self.regs[7].wrapping_add(4); + value + } + + fn shift(&mut self, kind: ShiftKind, dst: &Operand, count: u32, byte_mode: bool) -> Result<()> { + if count == 0 { + return Ok(()); + } + let width = if byte_mode { 8 } else { 32 }; + let count = count.min(width); + let value = self.read_operand(dst, byte_mode); + let result = match kind { + ShiftKind::Left => { + if count == width { + 0 + } else { + value.wrapping_shl(count) + } + } + ShiftKind::Right => { + if count == width { + 0 + } else { + value.wrapping_shr(count) + } + } + ShiftKind::ArithmeticRight => { + if byte_mode { + if count >= 8 { + if value & 0x80 != 0 { + 0xff + } else { + 0 + } + } else { + ((value as u8 as i8) >> count) as u8 as u32 + } + } else if count >= 32 { + if value & 0x8000_0000 != 0 { + u32::MAX + } else { + 0 + } + } else { + ((value as i32) >> count) as u32 + } + } + }; + let carry = match kind { + ShiftKind::Left => value & (1 << (width - count)) != 0, + ShiftKind::Right | ShiftKind::ArithmeticRight => value & (1 << (count - 1)) != 0, + }; + let result = self.mask_width(result, byte_mode); + self.write_operand(dst, result, byte_mode)?; + self.set_zsc(result, carry, byte_mode); + Ok(()) + } + + fn set_add_flags(&mut self, a: u32, b: u32, carry: u32, result: u32, byte_mode: bool) { + let mask = self.value_mask(byte_mode) as u64; + let sum = (a as u64 & mask) + (b as u64 & mask) + u64::from(carry); + self.set_zsc(result, sum > mask, byte_mode); + } + + fn set_sub_flags(&mut self, a: u32, b: u32, borrow: u32, byte_mode: bool) { + let mask = self.value_mask(byte_mode) as u64; + let a = a as u64 & mask; + let subtrahend = (b as u64 & mask) + u64::from(borrow); + let result = self.mask_width((a as u32).wrapping_sub(subtrahend as u32), byte_mode); + self.set_zsc(result, a < subtrahend, byte_mode); + } + + fn set_zs(&mut self, result: u32, byte_mode: bool) { + self.flags = if result == 0 { + FLAG_Z + } else { + result & self.sign_bit(byte_mode) + }; + } + + fn set_zsc(&mut self, result: u32, carry: bool, byte_mode: bool) { + self.set_zs(result, byte_mode); + if carry { + self.flags |= FLAG_C; + } + } + + fn mask_width(&self, value: u32, byte_mode: bool) -> u32 { + value & self.value_mask(byte_mode) + } + + fn value_mask(&self, byte_mode: bool) -> u32 { + if byte_mode { + 0xff + } else { + u32::MAX + } + } + + fn sign_bit(&self, byte_mode: bool) -> u32 { + if byte_mode { + 0x80 + } else { + FLAG_S + } + } +} + +fn write_u32(memory: &mut [u8], address: usize, value: u32) { + let address = address as u32; + for (offset, byte) in value.to_le_bytes().into_iter().enumerate() { + memory[(address.wrapping_add(offset as u32) & MEMORY_MASK) as usize] = byte; + } +} + +#[cfg(test)] +impl Vm { + fn new(program: &impl ProgramCode, invocation: Invocation<'_>) -> Result { + Self::with_allowance(program, invocation, &Allowance::default()) + } +} + +#[derive(Debug, Clone)] +struct BitReader<'a> { + input: &'a [u8], + bit_pos: usize, +} + +impl<'a> BitReader<'a> { + fn new(input: &'a [u8]) -> Self { + Self { input, bit_pos: 0 } + } + + fn remaining_bits(&self) -> usize { + self.input.len() * 8 - self.bit_pos + } + + fn read_bit(&mut self) -> Result { + self.read_bits(1) + } + + fn read_bits(&mut self, count: usize) -> Result { + if self.remaining_bits() < count { + return Err(Error::NeedMoreInput); + } + let mut value = 0; + for _ in 0..count { + let byte = self.input[self.bit_pos / 8]; + let bit = (byte >> (7 - (self.bit_pos % 8))) & 1; + value = (value << 1) | u32::from(bit); + self.bit_pos += 1; + } + Ok(value) + } + + fn read_vm_number(&mut self) -> Result { + match self.read_bits(2)? { + 0 => self.read_bits(4), + 1 => { + let high = self.read_bits(8)?; + if high >= 16 { + Ok(high) + } else { + Ok(0xffff_ff00 | (high << 4) | self.read_bits(4)?) + } + } + 2 => self.read_bits(16), + _ => self.read_bits(32), + } + } +} + +#[cfg(test)] +mod tests; diff --git a/arca-rar/vendor/rars/src/codec/rarvm/tests.rs b/arca-rar/vendor/rars/src/codec/rarvm/tests.rs new file mode 100644 index 00000000..db824f72 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/rarvm/tests.rs @@ -0,0 +1,1273 @@ +fn reader_vm_blob() -> Vec { + let mut bits = BitWriter::new(); + bits.write_bits(1, 1); + write_vm_number(&mut bits, 2); + for byte in [0xaa, 0xbb, 0xcc] { + bits.write_bits(byte, 8); + } + for (address, value) in [(0, 0x41), (GLOBAL_BASE as u32 + 0x30, 8)] { + write_opcode(&mut bits, Opcode::Mov); + bits.write_bits(0, 1); + write_absolute(&mut bits, address); + write_number_immediate(&mut bits, value); + } + write_opcode(&mut bits, Opcode::Ret); + with_xor(bits.finish()) +} +fn reader_vm_invocation() -> Invocation<'static> { + Invocation { + input: &[1, 2, 3, 4], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + } +} + +#[test] +fn reader_vm_workspace_refusals_release_program_operands_memory_and_results() { + use crate::codec::workspace::RefusingBudget; + let blob = reader_vm_blob(); + let run = |budget: &RefusingBudget| -> Result<()> { + let program = OwnedProgram::parse(&blob, budget)?; + let mut vm = Vm::with_allowance(&program, reader_vm_invocation(), budget)?; + let result = vm.run(&program, &crate::read_control::ReadControl::default())?; + assert_eq!(&*result.output, b"A\0\0\0"); + assert_eq!(result.globals.len(), SYSTEM_GLOBAL_SIZE + 8); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts >= 7); + assert_eq!(baseline.used(), 0); + for index in 0..attempts { + let budget = RefusingBudget::new(index); + assert!( + matches!(run(&budget), Err(Error::Cancelled)), + "allocation {index}" + ); + assert_eq!(budget.used(), 0); + } +} + +#[test] +fn reader_vm_workspace_results_remain_charged_after_worker_retirement() { + use crate::codec::workspace::RESERVATION_BYTES; + let ledger = Allowance::limited(1024 * 1024 + RESERVATION_BYTES); + let mut reservation = ledger.reserve(1024 * 1024).unwrap(); + let budget = reservation.allowance(); + reservation.start(); + let program = OwnedProgram::parse(&reader_vm_blob(), &budget).unwrap(); + let mut vm = Vm::with_allowance(&program, reader_vm_invocation(), &budget).unwrap(); + let result = vm + .run(&program, &crate::read_control::ReadControl::default()) + .unwrap(); + reservation.retire(); + assert!(ledger.used() >= MEMORY_SIZE as u64 + RESERVATION_BYTES); + drop(vm); + drop(program); + assert_eq!( + ledger.used(), + (result.output.capacity() + result.globals.capacity()) as u64 + RESERVATION_BYTES + ); + drop(result); + assert_eq!(ledger.used(), RESERVATION_BYTES); + drop(budget); + assert_eq!(ledger.used(), 0); +} + +#[test] +fn cancellation_interrupts_vm_work_without_output() { + let program = Program { + static_data: vec![], + instructions: vec![instr(Opcode::Jmp, false, vec![Operand::Immediate(0)])], + }; + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(2); + let err = program + .execute_with_control( + Invocation { + input: &[], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }, + &control, + ) + .unwrap_err(); + assert_eq!(err, Error::Cancelled); +} + +#[test] +fn rejects_a_program_that_exhausts_its_instruction_allowance() { + let program = Program { + static_data: vec![], + instructions: vec![instr(Opcode::Jmp, false, vec![Operand::Immediate(0)])], + }; + let invocation = Invocation { + input: &[], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }; + let mut vm = Vm::new(&program, invocation).unwrap(); + + assert!(matches!( + vm.run_with_limit(&program, &crate::read_control::ReadControl::default(), 3), + Err(Error::InvalidData("RARVM instruction limit exceeded")) + )); +} +use super::*; + +#[test] +fn rejects_bad_xor_checksum() { + assert_eq!( + Program::parse(&[0x12, 0x34]), + Err(Error::InvalidData("RARVM program checksum mismatch")) + ); +} + +#[test] +fn rejects_an_empty_program_blob() { + assert_eq!( + Program::parse(&[]), + Err(Error::InvalidData("RARVM program blob is empty")) + ); +} + +#[test] +fn an_explicitly_empty_program_terminates_without_changing_its_input() { + let result = Program { + static_data: Vec::new(), + instructions: Vec::new(), + } + .execute(Invocation { + input: b"unchanged", + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, b"unchanged"); +} + +#[test] +fn parses_static_data_and_appends_implicit_ret() { + let mut bits = BitWriter::new(); + bits.write_bits(1, 1); + write_vm_number(&mut bits, 2); + bits.write_bits(0xaa, 8); + bits.write_bits(0xbb, 8); + bits.write_bits(0xcc, 8); + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + + assert_eq!(program.static_data, [0xaa, 0xbb, 0xcc]); + assert_eq!( + program.instructions, + [Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }] + ); +} + +#[test] +fn parses_register_immediate_and_memory_operands() { + let mut bits = BitWriter::new(); + bits.write_bits(0, 1); + write_opcode(&mut bits, Opcode::Mov); + bits.write_bits(0, 1); + write_reg(&mut bits, 2); + write_number_immediate(&mut bits, 0x1234); + write_opcode(&mut bits, Opcode::Add); + bits.write_bits(1, 1); + write_reg_indirect(&mut bits, 3); + write_byte_immediate(&mut bits, 0x7f); + write_opcode(&mut bits, Opcode::Sub); + bits.write_bits(0, 1); + write_indexed(&mut bits, 1, 0x44); + write_absolute(&mut bits, 0x3c000); + write_opcode(&mut bits, Opcode::Ret); + + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + assert!(program.static_data.is_empty()); + assert_eq!(program.instructions.len(), 4); + assert_eq!(program.instructions[0].opcode, Opcode::Mov); + assert!(!program.instructions[0].byte_mode); + assert_eq!( + program.instructions[0].operands, + [Operand::Register(2), Operand::Immediate(0x1234)] + ); + assert_eq!(program.instructions[1].opcode, Opcode::Add); + assert!(program.instructions[1].byte_mode); + assert_eq!( + program.instructions[1].operands, + [Operand::RegisterIndirect(3), Operand::Immediate(0x7f)] + ); + assert_eq!( + program.instructions[2].operands, + [ + Operand::Indexed { + register: 1, + base: 0x44, + }, + Operand::Absolute(0x3c000), + ] + ); + assert_eq!(program.instructions[3].opcode, Opcode::Ret); +} + +#[test] +fn parses_every_long_opcode_used_by_generic_programs() { + for opcode in [ + Opcode::Xor, + Opcode::Sar, + Opcode::Pushf, + Opcode::Popf, + Opcode::Div, + Opcode::Adc, + Opcode::Sbb, + ] { + let mut bits = BitWriter::new(); + bits.write_bits(0, 1); // no static data + write_opcode(&mut bits, opcode); + if opcode.supports_byte_mode() { + bits.write_bits(0, 1); + } + for index in 0..opcode.operand_count() { + write_reg(&mut bits, index as u8); + } + write_opcode(&mut bits, Opcode::Ret); + + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + assert_eq!(program.instructions[0].opcode, opcode); + } +} + +#[test] +fn parses_runtime_and_absolute_jump_targets() { + let mut runtime = BitWriter::new(); + runtime.write_bits(0, 1); // no static data + write_opcode(&mut runtime, Opcode::Jmp); + write_reg(&mut runtime, 3); + let program = Program::parse(&with_xor(runtime.finish())).unwrap(); + assert_eq!(program.instructions[0].operands, [Operand::Register(3)]); + + let mut absolute = BitWriter::new(); + absolute.write_bits(0, 1); // no static data + write_opcode(&mut absolute, Opcode::Jmp); + write_number_immediate(&mut absolute, 300); + let program = Program::parse(&with_xor(absolute.finish())).unwrap(); + assert_eq!(program.instructions[0].operands, [Operand::Immediate(44)]); +} + +#[test] +fn ignores_a_trailing_partial_instruction() { + let mut bits = BitWriter::new(); + bits.write_bits(0, 1); // no static data + write_opcode(&mut bits, Opcode::Mov); + bits.write_bits(0, 1); // word mode + write_reg(&mut bits, 0); // second operand is absent + + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + assert_eq!( + program.instructions, + [instr(Opcode::Ret, false, Vec::new())] + ); +} + +#[test] +fn remaps_jump_immediates_to_instruction_indices() { + let mut bits = BitWriter::new(); + bits.write_bits(0, 1); + write_opcode(&mut bits, Opcode::Print); + write_opcode(&mut bits, Opcode::Jmp); + write_number_immediate(&mut bits, 15); + + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + assert_eq!(program.instructions.len(), 2); + assert_eq!( + program.instructions[1], + Instruction { + opcode: Opcode::Jmp, + byte_mode: false, + operands: vec![Operand::Immediate(0)], + } + ); +} + +#[test] +fn executes_arithmetic_and_memory_writes() { + let program = Program { + static_data: Vec::new(), + instructions: vec![ + Instruction { + opcode: Opcode::Mov, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(7)], + }, + Instruction { + opcode: Opcode::Add, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(5)], + }, + Instruction { + opcode: Opcode::Mov, + byte_mode: true, + operands: vec![Operand::Absolute(0), Operand::Register(0)], + }, + Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }, + ], + }; + + let result = program + .execute(Invocation { + input: &[0], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, [12]); + assert_eq!(result.regs[0], 12); +} + +#[test] +fn executes_conditional_jump_and_stack_call() { + let program = Program { + static_data: Vec::new(), + instructions: vec![ + Instruction { + opcode: Opcode::Mov, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(1)], + }, + Instruction { + opcode: Opcode::Cmp, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(1)], + }, + Instruction { + opcode: Opcode::Jz, + byte_mode: false, + operands: vec![Operand::Immediate(4)], + }, + Instruction { + opcode: Opcode::Mov, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(99)], + }, + Instruction { + opcode: Opcode::Call, + byte_mode: false, + operands: vec![Operand::Immediate(6)], + }, + Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }, + Instruction { + opcode: Opcode::Add, + byte_mode: false, + operands: vec![Operand::Register(0), Operand::Immediate(41)], + }, + Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }, + ], + }; + + let result = program + .execute(Invocation { + input: &[0], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.regs[0], 42); +} + +#[test] +fn nested_calls_return_through_each_stack_frame() { + let result = execute_instructions(vec![ + instr(Opcode::Call, false, vec![Operand::Immediate(3)]), + instr(Opcode::Ret, false, Vec::new()), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(99)], + ), + instr(Opcode::Call, false, vec![Operand::Immediate(6)]), + instr( + Opcode::Add, + false, + vec![Operand::Register(0), Operand::Immediate(2)], + ), + instr(Opcode::Ret, false, Vec::new()), + instr( + Opcode::Add, + false, + vec![Operand::Register(0), Operand::Immediate(40)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 42); +} + +#[test] +fn executes_unconditional_jumps_and_mutating_unary_ops() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(1)], + ), + instr(Opcode::Inc, false, vec![Operand::Register(0)]), + instr(Opcode::Dec, false, vec![Operand::Register(0)]), + instr(Opcode::Not, false, vec![Operand::Register(0)]), + instr(Opcode::Neg, false, vec![Operand::Register(0)]), + instr(Opcode::Jmp, false, vec![Operand::Immediate(7)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(99)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 2); +} + +#[test] +fn executes_logic_ops_and_test_without_writing_destination() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0b1010)], + ), + instr( + Opcode::Xor, + false, + vec![Operand::Register(0), Operand::Immediate(0b1100)], + ), + instr( + Opcode::And, + false, + vec![Operand::Register(0), Operand::Immediate(0b0110)], + ), + instr( + Opcode::Or, + false, + vec![Operand::Register(0), Operand::Immediate(0b0001)], + ), + instr( + Opcode::Test, + false, + vec![Operand::Register(0), Operand::Immediate(0b0100)], + ), + instr(Opcode::Jnz, false, vec![Operand::Immediate(7)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(99)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0b0111); +} + +#[test] +fn executes_unsigned_conditional_jumps() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(1), Operand::Immediate(2)], + ), + instr(Opcode::Jb, false, vec![Operand::Immediate(5)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(99)], + ), + instr(Opcode::Ret, false, Vec::new()), + instr(Opcode::Jbe, false, vec![Operand::Immediate(7)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(98)], + ), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(3), Operand::Immediate(2)], + ), + instr(Opcode::Ja, false, vec![Operand::Immediate(10)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(97)], + ), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(3), Operand::Immediate(2)], + ), + instr(Opcode::Jae, false, vec![Operand::Immediate(13)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(96)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(42)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 42); +} + +#[test] +fn executes_signed_conditional_jumps() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr( + Opcode::Sub, + false, + vec![Operand::Register(0), Operand::Immediate(1)], + ), + instr(Opcode::Js, false, vec![Operand::Immediate(5)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(99)], + ), + instr(Opcode::Ret, false, Vec::new()), + instr( + Opcode::Add, + false, + vec![Operand::Register(0), Operand::Immediate(1)], + ), + instr(Opcode::Jns, false, vec![Operand::Immediate(8)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(98)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(42)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0); + assert_eq!(result.regs[1], 42); +} + +#[test] +fn executes_stack_register_and_flag_round_trips() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(10)], + ), + instr(Opcode::Push, false, vec![Operand::Register(0)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr(Opcode::Pop, false, vec![Operand::Register(1)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(10)], + ), + instr(Opcode::Pusha, false, Vec::new()), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(99)], + ), + instr(Opcode::Popa, false, Vec::new()), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(1), Operand::Immediate(2)], + ), + instr(Opcode::Pushf, false, Vec::new()), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(2), Operand::Immediate(2)], + ), + instr(Opcode::Popf, false, Vec::new()), + instr(Opcode::Jb, false, vec![Operand::Immediate(14)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(99)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 10); + assert_eq!(result.regs[1], 10); +} + +#[test] +fn executes_shifts_with_byte_and_word_modes() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0x81)], + ), + instr( + Opcode::Shl, + false, + vec![Operand::Register(0), Operand::Immediate(1)], + ), + instr( + Opcode::Shr, + false, + vec![Operand::Register(0), Operand::Immediate(2)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0x80)], + ), + instr( + Opcode::Sar, + true, + vec![Operand::Register(1), Operand::Immediate(1)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0x40); + assert_eq!(result.regs[1], 0xc0); +} + +#[test] +fn byte_mode_sar_accepts_shift_count_equal_to_width() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0x80)], + ), + instr( + Opcode::Sar, + true, + vec![Operand::Register(0), Operand::Immediate(8)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0x7f)], + ), + instr( + Opcode::Sar, + true, + vec![Operand::Register(1), Operand::Immediate(8)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0xff); + assert_eq!(result.regs[1], 0); +} + +#[test] +fn word_mode_sar_sign_extends_at_ordinary_and_full_width_counts() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0x8000_0000)], + ), + instr( + Opcode::Sar, + false, + vec![Operand::Register(0), Operand::Immediate(1)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0x8000_0000)], + ), + instr( + Opcode::Sar, + false, + vec![Operand::Register(1), Operand::Immediate(32)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(2), Operand::Immediate(1)], + ), + instr( + Opcode::Sar, + false, + vec![Operand::Register(2), Operand::Immediate(32)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0xc000_0000); + assert_eq!(result.regs[1], u32::MAX); + assert_eq!(result.regs[2], 0); +} + +#[test] +fn neg_zero_sets_zero_and_divide_by_zero_keeps_the_destination() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr(Opcode::Neg, false, vec![Operand::Register(0)]), + instr(Opcode::Jz, false, vec![Operand::Immediate(4)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(99)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(42)], + ), + instr( + Opcode::Div, + false, + vec![Operand::Register(1), Operand::Immediate(0)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0); + assert_eq!(result.regs[1], 42); +} + +#[test] +fn full_width_shl_and_shr_clear_destination() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0x1234_5678)], + ), + instr( + Opcode::Shl, + false, + vec![Operand::Register(0), Operand::Immediate(32)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0x8765_4321)], + ), + instr( + Opcode::Shr, + false, + vec![Operand::Register(1), Operand::Immediate(32)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(2), Operand::Immediate(0xff)], + ), + instr( + Opcode::Shl, + true, + vec![Operand::Register(2), Operand::Immediate(8)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(3), Operand::Immediate(0xff)], + ), + instr( + Opcode::Shr, + true, + vec![Operand::Register(3), Operand::Immediate(8)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0); + assert_eq!(result.regs[1], 0); + assert_eq!(result.regs[2] & 0xff, 0); + assert_eq!(result.regs[3] & 0xff, 0); +} + +#[test] +fn sbb_sets_borrow_flag_when_subtrahend_plus_carry_wraps_byte_width() { + let result = execute_instructions(vec![ + instr( + Opcode::Cmp, + true, + vec![Operand::Immediate(0), Operand::Immediate(1)], + ), + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr( + Opcode::Sbb, + true, + vec![Operand::Register(0), Operand::Immediate(0xff)], + ), + instr(Opcode::Jb, false, vec![Operand::Immediate(6)]), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0xdead)], + ), + instr(Opcode::Ret, false, Vec::new()), + instr( + Opcode::Mov, + false, + vec![Operand::Register(1), Operand::Immediate(0xbeef)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0] & 0xff, 0); + assert_eq!(result.regs[1], 0xbeef); +} + +#[test] +fn zero_count_shifts_are_noops() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Register(0), Operand::Immediate(0x1234_5678)], + ), + instr( + Opcode::Shl, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr( + Opcode::Shr, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr( + Opcode::Sar, + false, + vec![Operand::Register(0), Operand::Immediate(0)], + ), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0x1234_5678); +} + +#[test] +fn output_range_accepts_exclusive_memory_end() { + let program = Program { + static_data: Vec::new(), + instructions: vec![ + instr( + Opcode::Mov, + false, + vec![ + Operand::Absolute((GLOBAL_BASE + 0x20) as u32), + Operand::Immediate((MEMORY_SIZE - 1) as u32), + ], + ), + instr( + Opcode::Mov, + false, + vec![ + Operand::Absolute((GLOBAL_BASE + 0x1c) as u32), + Operand::Immediate(1), + ], + ), + instr( + Opcode::Mov, + true, + vec![ + Operand::Absolute((MEMORY_SIZE - 1) as u32), + Operand::Immediate(0x5a), + ], + ), + instr(Opcode::Ret, false, Vec::new()), + ], + }; + + let result = program + .execute(Invocation { + input: &[0], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + + assert_eq!(result.output, [0x5a]); +} + +#[test] +fn output_range_past_memory_is_discarded() { + let program = Program { + static_data: Vec::new(), + instructions: vec![ + instr( + Opcode::Mov, + false, + vec![ + Operand::Absolute((GLOBAL_BASE + 0x20) as u32), + Operand::Immediate((MEMORY_SIZE - 1) as u32), + ], + ), + instr( + Opcode::Mov, + false, + vec![ + Operand::Absolute((GLOBAL_BASE + 0x1c) as u32), + Operand::Immediate(2), + ], + ), + instr(Opcode::Ret, false, Vec::new()), + ], + }; + + let result = program + .execute(Invocation { + input: &[0x5a], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap(); + assert!(result.output.is_empty()); +} + +#[test] +fn rejects_a_program_that_writes_to_an_immediate() { + let program = Program { + static_data: Vec::new(), + instructions: vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Immediate(0), Operand::Immediate(1)], + ), + instr(Opcode::Ret, false, Vec::new()), + ], + }; + + assert_eq!( + program.execute(Invocation { + input: &[], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }), + Err(Error::InvalidData("RARVM write to immediate operand")) + ); +} + +#[test] +fn parsed_shifts_reject_an_immediate_destination() { + for opcode in [Opcode::Shl, Opcode::Shr, Opcode::Sar] { + let mut bits = BitWriter::new(); + bits.write_bits(0, 1); // no static data + write_opcode(&mut bits, opcode); + bits.write_bits(0, 1); // word mode + write_number_immediate(&mut bits, 1); // destination + write_number_immediate(&mut bits, 1); // nonzero shift count + write_opcode(&mut bits, Opcode::Ret); + + let program = Program::parse(&with_xor(bits.finish())).unwrap(); + assert_eq!(program.instructions[0].opcode, opcode); + assert_eq!( + program.execute(Invocation { + input: &[], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }), + Err(Error::InvalidData("RARVM write to immediate operand")), + "{opcode:?} should reject an immediate destination", + ); + } +} + +#[test] +fn executes_extension_exchange_multiply_divide_and_carry_arithmetic() { + let result = execute_instructions(vec![ + instr( + Opcode::Mov, + false, + vec![Operand::Absolute(0), Operand::Immediate(0x80)], + ), + instr( + Opcode::Movzx, + false, + vec![Operand::Register(0), Operand::Absolute(0)], + ), + instr( + Opcode::Movsx, + false, + vec![Operand::Register(1), Operand::Absolute(0)], + ), + instr( + Opcode::Xchg, + false, + vec![Operand::Register(0), Operand::Register(1)], + ), + instr( + Opcode::Mul, + false, + vec![Operand::Register(1), Operand::Immediate(3)], + ), + instr( + Opcode::Div, + false, + vec![Operand::Register(1), Operand::Immediate(2)], + ), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(1), Operand::Immediate(2)], + ), + instr( + Opcode::Adc, + false, + vec![Operand::Register(1), Operand::Immediate(1)], + ), + instr( + Opcode::Cmp, + false, + vec![Operand::Immediate(1), Operand::Immediate(2)], + ), + instr( + Opcode::Sbb, + false, + vec![Operand::Register(1), Operand::Immediate(2)], + ), + instr(Opcode::Print, false, Vec::new()), + instr(Opcode::Ret, false, Vec::new()), + ]); + + assert_eq!(result.regs[0], 0xffff_ff80); + assert_eq!(result.regs[1], 0xbf); +} + +#[test] +fn preserves_requested_user_globals() { + let program = Program { + static_data: b"static".to_vec(), + instructions: vec![ + Instruction { + opcode: Opcode::Mov, + byte_mode: false, + operands: vec![Operand::Absolute(0x3c030), Operand::Immediate(4)], + }, + Instruction { + opcode: Opcode::Ret, + byte_mode: false, + operands: Vec::new(), + }, + ], + }; + + let result = program + .execute(Invocation { + input: &[1, 2, 3], + regs: [0; 7], + global_data: &[0; 64], + file_offset: 0x1_0000_0002, + exec_count: 9, + }) + .unwrap(); + + assert_eq!(result.output, [1, 2, 3]); + assert_eq!(result.globals.len(), 68); + assert_eq!(&result.globals[64..], b"stat"); +} + +#[test] +fn parse_rejects_huge_static_data_size_without_preallocating() { + let err = Program::parse(&[0xff, 0xff, 0xff, 0xff, 0, 0]).unwrap_err(); + assert_eq!(err, Error::InvalidData("RARVM static data is too large")); +} + +#[test] +fn parse_rejects_static_data_larger_than_vm_memory() { + let mut bits = BitWriter::new(); + bits.write_bits(1, 1); + write_vm_number(&mut bits, MAX_STATIC_DATA as u32); + + let err = Program::parse(&with_xor(bits.finish())).unwrap_err(); + assert_eq!(err, Error::InvalidData("RARVM static data is too large")); +} + +fn instr(opcode: Opcode, byte_mode: bool, operands: Vec) -> Instruction { + Instruction { + opcode, + byte_mode, + operands, + } +} + +fn execute_instructions(instructions: Vec) -> ExecutionResult { + Program { + static_data: Vec::new(), + instructions, + } + .execute(Invocation { + input: &[0], + regs: [0; 7], + global_data: &[], + file_offset: 0, + exec_count: 0, + }) + .unwrap() +} + +struct BitWriter { + output: Vec, + bit_pos: usize, +} + +impl BitWriter { + fn new() -> Self { + Self { + output: Vec::new(), + bit_pos: 0, + } + } + + fn write_bits(&mut self, value: u32, count: usize) { + for i in (0..count).rev() { + if self.bit_pos.is_multiple_of(8) { + self.output.push(0); + } + if (value >> i) & 1 != 0 { + let idx = self.output.len() - 1; + self.output[idx] |= 1 << (7 - (self.bit_pos % 8)); + } + self.bit_pos += 1; + } + } + + fn finish(self) -> Vec { + self.output + } +} + +fn with_xor(mut payload: Vec) -> Vec { + let checksum = payload.iter().fold(0u8, |acc, &byte| acc ^ byte); + payload.insert(0, checksum); + payload +} + +fn write_opcode(bits: &mut BitWriter, opcode: Opcode) { + let value = opcode as u8; + if value <= 7 { + bits.write_bits(0, 1); + bits.write_bits(u32::from(value), 3); + } else { + bits.write_bits(1, 1); + bits.write_bits(u32::from(value - 8), 5); + } +} + +fn write_reg(bits: &mut BitWriter, reg: u8) { + bits.write_bits(1, 1); + bits.write_bits(u32::from(reg), 3); +} + +fn write_number_immediate(bits: &mut BitWriter, value: u32) { + bits.write_bits(0, 2); + write_vm_number(bits, value); +} + +fn write_byte_immediate(bits: &mut BitWriter, value: u8) { + bits.write_bits(0, 2); + bits.write_bits(u32::from(value), 8); +} + +fn write_reg_indirect(bits: &mut BitWriter, reg: u8) { + bits.write_bits(0b010, 3); + bits.write_bits(u32::from(reg), 3); +} + +fn write_indexed(bits: &mut BitWriter, reg: u8, base: u32) { + bits.write_bits(0b0110, 4); + bits.write_bits(u32::from(reg), 3); + write_vm_number(bits, base); +} + +fn write_absolute(bits: &mut BitWriter, address: u32) { + bits.write_bits(0b0111, 4); + write_vm_number(bits, address); +} + +fn write_vm_number(bits: &mut BitWriter, value: u32) { + if value <= 15 { + bits.write_bits(0, 2); + bits.write_bits(value, 4); + } else if value <= 255 { + bits.write_bits(1, 2); + bits.write_bits(value, 8); + } else if value <= 0xffff { + bits.write_bits(2, 2); + bits.write_bits(value, 16); + } else { + bits.write_bits(3, 2); + bits.write_bits(value, 32); + } +} diff --git a/arca-rar/vendor/rars/src/codec/workspace.rs b/arca-rar/vendor/rars/src/codec/workspace.rs new file mode 100644 index 00000000..be297ecc --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/workspace.rs @@ -0,0 +1,869 @@ +//! Fallible ownership of codec allocation capacity. A local allowance never +//! reaches into a sibling worker's spare bytes. Internal admission tests connect +//! these owners to coordinator reservations; unlimited handles preserve behaviour. +use super::{Error, Result}; +pub(crate) mod coordinator; +mod ledger; +pub(crate) use ledger::{Charge, Limited, Reservation, RESERVATION_BYTES}; + +/// A zero-sized policy: its buffers have exactly Vec's layout and no ledger +/// branch in their hot operations. Limited buffers are a separate instantiation. +#[derive(Clone, Debug, Default)] +pub(crate) struct Allowance { + _unlimited: (), +} +impl Allowance { + pub(crate) fn limited(limit: u64) -> Limited { + Limited::new(limit) + } +} + +pub(crate) trait Budget: Clone + std::fmt::Debug { + type Charge: std::fmt::Debug; + type Failure: Into; + fn grow( + values: &mut Vec, + charge: &mut Self::Charge, + additional: usize, + ) -> std::result::Result<(), Self::Failure>; + const LIMITED: bool; + fn charge(&self) -> Self::Charge; + fn allowance(charge: &Self::Charge) -> Self; + fn resize(charge: &mut Self::Charge, bytes: u64) -> Result<()>; +} + +/// Admit a boxed value before constructing it. Its storage is freed before +/// the charge, including when construction fails or a decoder is replaced. +#[derive(Debug)] +pub(crate) struct Boxed { + value: Box, + _charge: B::Charge, +} +impl Boxed { + pub(crate) fn try_new>( + make: impl FnOnce() -> std::result::Result, + allowance: &B, + ) -> std::result::Result { + let mut charge = allowance.charge(); + B::resize(&mut charge, allocation_size::(1)?)?; + let value = make()?; + Ok(Self { + value: Box::new(value), + _charge: charge, + }) + } +} +impl std::ops::Deref for Boxed { + type Target = T; + fn deref(&self) -> &T { + &self.value + } +} +impl std::ops::DerefMut for Boxed { + fn deref_mut(&mut self) -> &mut T { + &mut self.value + } +} +impl Budget for Allowance { + type Charge = (); + type Failure = std::convert::Infallible; + fn grow( + values: &mut Vec, + _: &mut (), + additional: usize, + ) -> std::result::Result<(), Self::Failure> { + values.reserve(additional); + Ok(()) + } + const LIMITED: bool = false; + fn charge(&self) {} + fn allowance(_: &()) -> Self { + Self::default() + } + fn resize(_: &mut (), _: u64) -> Result<()> { + Ok(()) + } +} + +impl Budget for Limited { + type Charge = Charge; + type Failure = Error; + fn grow(values: &mut Vec, charge: &mut Charge, additional: usize) -> Result<()> { + let end = values + .len() + .checked_add(additional) + .ok_or(Error::InvalidData("codec capacity overflows"))?; + if end <= values.capacity() { + return Ok(()); + } + let capacity = end.max(values.capacity().saturating_mul(2)).max(4); + let bytes = allocation_size::(capacity)?; + let peak = bytes + .checked_add(charge.bytes) + .ok_or(Error::InvalidData("codec capacity overflows"))?; + Self::resize(charge, peak)?; + let mut replacement = Vec::with_capacity(capacity); + replacement.append(values); + *values = replacement; + Self::resize(charge, bytes)?; + Ok(()) + } + const LIMITED: bool = true; + fn charge(&self) -> Charge { + Charge { + allowance: self.clone(), + bytes: 0, + } + } + fn allowance(charge: &Charge) -> Self { + charge.allowance.clone() + } + fn resize(charge: &mut Charge, bytes: u64) -> Result<()> { + charge.resize(bytes) + } +} + +/// Test policy that uses the production ledger but can refuse one chosen +/// growth operation. Keeping the policy beside [`Budget`] lets coverage count +/// its monomorphizations as tests of production generic code rather than as +/// test-module functions. +#[cfg(test)] +#[derive(Clone, Debug)] +pub(crate) struct RefusingBudget { + inner: Limited, + attempts: std::sync::Arc, + fail_at: usize, +} + +#[cfg(test)] +#[derive(Debug)] +pub(crate) struct RefusingCharge { + inner: Charge, + attempts: std::sync::Arc, + fail_at: usize, +} + +#[cfg(test)] +impl RefusingBudget { + pub(crate) fn new(fail_at: usize) -> Self { + Self { + inner: Allowance::limited(64 * 1024 * 1024), + attempts: std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)), + fail_at, + } + } + + pub(crate) fn attempts(&self) -> usize { + self.attempts.load(std::sync::atomic::Ordering::Relaxed) + } + + pub(crate) fn used(&self) -> u64 { + self.inner.used() + } +} + +#[cfg(test)] +fn refuse_once(attempts: &std::sync::atomic::AtomicUsize, fail_at: usize) -> Result<()> { + if attempts.fetch_add(1, std::sync::atomic::Ordering::Relaxed) == fail_at { + Err(Error::Cancelled) + } else { + Ok(()) + } +} + +#[cfg(test)] +impl Budget for RefusingBudget { + type Charge = RefusingCharge; + type Failure = Error; + const LIMITED: bool = true; + + fn grow(values: &mut Vec, charge: &mut Self::Charge, additional: usize) -> Result<()> { + refuse_once(&charge.attempts, charge.fail_at)?; + ::grow(values, &mut charge.inner, additional) + } + + fn charge(&self) -> Self::Charge { + RefusingCharge { + inner: ::charge(&self.inner), + attempts: self.attempts.clone(), + fail_at: self.fail_at, + } + } + + fn allowance(charge: &Self::Charge) -> Self { + Self { + inner: ::allowance(&charge.inner), + attempts: charge.attempts.clone(), + fail_at: charge.fail_at, + } + } + + fn resize(charge: &mut Self::Charge, bytes: u64) -> Result<()> { + if bytes > charge.inner.bytes() { + refuse_once(&charge.attempts, charge.fail_at)?; + } + ::resize(&mut charge.inner, bytes) + } +} + +/// Storage is dropped before its charge. Slice access cannot grow an allocation +/// behind the ledger's back; growth and ownership transfer are explicit. +#[derive(Debug)] +pub(crate) struct Buffer { + values: Vec, + charge: B::Charge, +} +impl Buffer { + pub(crate) fn new(allowance: &B) -> Self { + Self { + values: Vec::new(), + charge: allowance.charge(), + } + } + pub(crate) fn with_capacity(capacity: usize, allowance: &B) -> Result { + let bytes = allocation_size::(capacity)?; + let mut out = Self::new(allowance); + B::resize(&mut out.charge, bytes)?; + out.values = Vec::with_capacity(capacity); + Ok(out) + } + pub(crate) fn filled(len: usize, value: T, allowance: &B) -> Result + where + T: Clone, + { + // Keep vec![0; n]'s zeroed allocation fast path for finder links. + let bytes = allocation_size::(len)?; + let mut out = Self::new(allowance); + B::resize(&mut out.charge, bytes)?; + out.values = vec![value; len]; + Ok(out) + } + /// Admit one exact allocation before copying slices that form a buffer. + /// The total is checked first, so none of the copies can grow past its + /// charged capacity. + #[cfg(feature = "write")] + pub(crate) fn from_slices(slices: &[&[T]], allowance: &B) -> Result + where + T: Copy, + { + let len = slices.iter().try_fold(0usize, |total, slice| { + total + .checked_add(slice.len()) + .ok_or(Error::InvalidData("codec capacity overflows")) + })?; + let mut out = Self::with_capacity(len, allowance)?; + for slice in slices { + out.values.extend_from_slice(slice); + } + Ok(out) + } + pub(crate) fn capacity(&self) -> usize { + self.values.capacity() + } + pub(crate) fn discard_prefix(&mut self, count: usize) { + self.values.drain(..count); + } + pub(crate) fn extend_from_within(&mut self, range: std::ops::Range) -> Result<()> + where + T: Copy, + { + if B::LIMITED { + self.reserve(range.len())?; + } + self.values.extend_from_within(range); + Ok(()) + } + pub(crate) fn allowance(&self) -> B { + B::allowance(&self.charge) + } + fn reserve(&mut self, additional: usize) -> Result<()> { + B::grow(&mut self.values, &mut self.charge, additional).map_err(Into::into) + } + #[cfg(feature = "write")] + pub(crate) fn reserve_total_capacity(&mut self, total: usize) -> Result<()> { + if total > self.values.capacity() { + self.reserve(total.saturating_sub(self.values.len()))?; + } + debug_assert!(self.values.capacity() >= total); + Ok(()) + } + #[inline] + pub(crate) fn push(&mut self, value: T) -> std::result::Result<(), B::Failure> { + if B::LIMITED && self.values.len() == self.values.capacity() { + B::grow(&mut self.values, &mut self.charge, 1)?; + } + self.values.push(value); + Ok(()) + } + /// Append after the caller has admitted enough capacity for the complete + /// collection. This cannot grow the allocation or change its charge. + pub(crate) fn push_admitted(&mut self, value: T) { + debug_assert!(self.values.len() < self.values.capacity()); + self.values.push(value); + } + pub(crate) fn try_push(&mut self, value: T) -> Result<()> { + self.push(value).map_err(Into::into) + } + pub(crate) fn collect(values: impl IntoIterator, allowance: &B) -> Result { + let values = values.into_iter(); + let mut out = Self::with_capacity(values.size_hint().0, allowance)?; + for value in values { + out.try_push(value)?; + } + Ok(out) + } + pub(crate) fn retain(&mut self, keep: impl FnMut(&T) -> bool) { + self.values.retain(keep); + } + #[cfg(any(test, feature = "write", feature = "encryption"))] + pub(crate) fn truncate(&mut self, len: usize) { + self.values.truncate(len); + } + pub(crate) fn resize(&mut self, len: usize, value: T) -> Result<()> + where + T: Clone, + { + if B::LIMITED && len > self.values.capacity() { + self.reserve(len - self.values.len())?; + } + self.values.resize(len, value); + Ok(()) + } + #[cfg(all(test, feature = "write"))] + pub(crate) fn resize_with(&mut self, len: usize, make: impl FnMut() -> T) -> Result<()> { + if B::LIMITED && len > self.values.capacity() { + self.reserve(len - self.values.len())?; + } + self.values.resize_with(len, make); + Ok(()) + } + pub(crate) fn clear(&mut self) { + self.values.clear(); + } + pub(crate) fn insert(&mut self, index: usize, value: T) -> Result<()> { + if B::LIMITED { + self.reserve(1)?; + } + self.values.insert(index, value); + Ok(()) + } + pub(crate) fn remove(&mut self, index: usize) -> T { + self.values.remove(index) + } + pub(crate) fn try_collect( + values: impl ExactSizeIterator>, + allowance: &B, + ) -> Result { + let mut out = Self::with_capacity(values.len(), allowance)?; + for value in values { + out.push_admitted(value?); + } + Ok(out) + } + pub(crate) fn pop(&mut self) -> Option { + self.values.pop() + } + pub(crate) fn copied(values: &[T], allowance: &B) -> Result + where + T: Copy, + { + let mut out = Self::with_capacity(values.len(), allowance)?; + out.extend_from_slice(values).map_err(Into::into)?; + Ok(out) + } + /// Admit the final window before modifying it. A refusal keeps the old + /// history intact, and input larger than the window is never copied in full. + #[cfg(any(test, feature = "write"))] + pub(crate) fn remember(&mut self, input: &[T], limit: usize) -> Result<()> + where + T: Copy, + { + let input = &input[input.len().saturating_sub(limit)..]; + let keep = self.len().min(limit - input.len()); + self.reserve((keep + input.len()).saturating_sub(self.len()))?; + let start = self.len() - keep; + self.values.copy_within(start.., 0); + self.values.truncate(keep); + self.extend_from_slice(input).map_err(Into::into) + } + pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> std::result::Result<(), B::Failure> + where + T: Copy, + { + if B::LIMITED && values.len() > self.values.capacity() - self.values.len() { + B::grow(&mut self.values, &mut self.charge, values.len())?; + } + self.values.extend_from_slice(values); + Ok(()) + } + #[cfg(any(test, feature = "write"))] + pub(crate) fn prepend(&mut self, prefix: impl ExactSizeIterator) -> Result<()> { + self.reserve(prefix.len())?; + let old_len = self.values.len(); + for value in prefix { + self.push(value).map_err(Into::into)?; + } + let inserted = self.values.len() - old_len; + self.values.rotate_right(inserted); + Ok(()) + } +} +/// A charged ring keeps its allocation ownership when converted to or from a +/// contiguous history. Neither conversion allocates new storage. +#[derive(Debug)] +pub(crate) struct Deque { + values: std::collections::VecDeque, + charge: B::Charge, +} +impl Deque { + pub(crate) fn from_buffer(buffer: Buffer) -> Self { + Self { + values: buffer.values.into(), + charge: buffer.charge, + } + } + pub(crate) fn into_buffer(self) -> Buffer { + Buffer { + values: self.values.into(), + charge: self.charge, + } + } + pub(crate) fn with_capacity(capacity: usize, allowance: &B) -> Result { + Ok(Self::from_buffer(Buffer::with_capacity( + capacity, allowance, + )?)) + } + pub(crate) fn allowance(&self) -> B { + B::allowance(&self.charge) + } + pub(crate) fn capacity(&self) -> usize { + self.values.capacity() + } + pub(crate) fn discard_prefix(&mut self, count: usize) { + self.values.drain(..count); + } + pub(crate) fn extend_admitted(&mut self, values: impl ExactSizeIterator) { + assert!(values.len() <= self.values.capacity() - self.values.len()); + self.values.extend(values); + } +} +impl std::ops::Deref for Deque { + type Target = std::collections::VecDeque; + fn deref(&self) -> &Self::Target { + &self.values + } +} +pub(crate) struct BufferIter { + values: std::vec::IntoIter, + _charge: B::Charge, +} +impl<'a, T, B: Budget> IntoIterator for &'a Buffer { + type Item = &'a T; + type IntoIter = std::slice::Iter<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} +impl<'a, T, B: Budget> IntoIterator for &'a mut Buffer { + type Item = &'a mut T; + type IntoIter = std::slice::IterMut<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.iter_mut() + } +} +impl IntoIterator for Buffer { + type Item = T; + type IntoIter = BufferIter; + fn into_iter(self) -> Self::IntoIter { + BufferIter { + values: self.values.into_iter(), + _charge: self.charge, + } + } +} +impl Iterator for BufferIter { + type Item = T; + fn next(&mut self) -> Option { + self.values.next() + } + fn size_hint(&self) -> (usize, Option) { + self.values.size_hint() + } +} +impl ExactSizeIterator for BufferIter {} +#[cfg(test)] +impl From> for Buffer { + fn from(values: Vec) -> Self { + Self::from_vec(values) + } +} +impl Buffer { + #[cfg(any(test, feature = "write"))] + pub(crate) fn from_vec(values: Vec) -> Self { + Self { values, charge: () } + } + /// Only unlimited buffers can cross an existing unaccounted Vec boundary. + pub(crate) fn into_vec(self) -> Vec { + self.values + } +} +impl Buffer { + pub(crate) fn read_to_end(&mut self, input: &mut impl std::io::Read) -> Result<()> { + let mut chunk = [0u8; 32 * 1024]; + loop { + let len = match input.read(&mut chunk) { + Ok(0) => return Ok(()), + Ok(len) => len, + Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue, + Err(error) => return Err(Error::from(error)), + }; + self.extend_from_slice(&chunk[..len]).map_err(Into::into)?; + } + } + #[cfg(feature = "write")] + pub(crate) fn write_msb_bits( + &mut self, + bit_pos: &mut usize, + value: u64, + count: usize, + ) -> std::result::Result<(), B::Failure> { + let used = *bit_pos % 8; + let additional = (used + count).div_ceil(8) - usize::from(used != 0); + if B::LIMITED && additional > self.values.capacity() - self.values.len() { + B::grow(&mut self.values, &mut self.charge, additional)?; + } + super::fast::write_msb_bits(&mut self.values, bit_pos, value, count); + Ok(()) + } + #[cfg(feature = "write")] + pub(crate) fn write_msb_bits_admitted( + &mut self, + bit_pos: &mut usize, + value: u64, + count: usize, + ) { + let used = *bit_pos % 8; + let additional = (used + count).div_ceil(8) - usize::from(used != 0); + debug_assert!(additional <= self.values.capacity() - self.values.len()); + super::fast::write_msb_bits(&mut self.values, bit_pos, value, count); + } +} +fn allocation_size(capacity: usize) -> Result { + capacity + .checked_mul(std::mem::size_of::()) + .filter(|bytes| *bytes <= isize::MAX as usize) + .map(|bytes| bytes as u64) + .ok_or(Error::InvalidData("codec capacity overflows")) +} +impl std::io::Write for Buffer { + fn write(&mut self, values: &[u8]) -> std::io::Result { + self.extend_from_slice(values) + .map_err(|error| std::io::Error::other(crate::Error::from(error.into())))?; + Ok(values.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} +impl std::ops::Deref for Buffer { + type Target = [T]; + #[inline] + fn deref(&self) -> &[T] { + &self.values + } +} +impl std::ops::DerefMut for Buffer { + #[inline] + fn deref_mut(&mut self) -> &mut [T] { + &mut self.values + } +} +impl PartialEq> for Buffer { + fn eq(&self, other: &Buffer) -> bool { + **self == **other + } +} +impl PartialEq> for Buffer { + fn eq(&self, other: &Vec) -> bool { + &**self == other.as_slice() + } +} + +#[cfg(test)] +mod tests { + #[test] + fn limited_insert_preserves_reordered_storage_and_refuses_growth_atomically() { + let ledger = Allowance::limited(4); + let mut bytes = Buffer::copied(b"ABCD", &ledger).unwrap(); + let storage = bytes.as_ptr(); + let value = bytes.remove(2); + bytes.insert(0, value).unwrap(); + assert_eq!(&*bytes, b"CABD"); + assert_eq!(bytes.as_ptr(), storage); + assert_eq!(ledger.used(), 4); + assert!(matches!( + bytes.insert(0, b'X'), + Err(Error::WorkspaceLimitExceeded(_)) + )); + assert_eq!(&*bytes, b"CABD"); + assert_eq!(bytes.as_ptr(), storage); + assert_eq!(ledger.used(), 4); + drop(bytes); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn interrupted_reads_retry_and_buffer_flush_preserves_charge() { + use std::io::{self, Cursor, Read, Write}; + struct InterruptedOnce { + interrupted: bool, + data: Cursor<&'static [u8]>, + } + impl Read for InterruptedOnce { + fn read(&mut self, out: &mut [u8]) -> io::Result { + if !self.interrupted { + self.interrupted = true; + return Err(io::ErrorKind::Interrupted.into()); + } + self.data.read(out) + } + } + let ledger = Allowance::limited(16); + let mut input = InterruptedOnce { + interrupted: false, + data: Cursor::new(b"payload".as_slice()), + }; + let mut bytes = Buffer::new(&ledger); + bytes.read_to_end(&mut input).unwrap(); + assert!(input.interrupted); + assert_eq!(&*bytes, b"payload"); + let charged = ledger.used(); + assert!(charged >= 7); + bytes.flush().unwrap(); + assert_eq!(&*bytes, b"payload"); + assert_eq!(ledger.used(), charged); + drop(bytes); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn boxed_workspace_is_admitted_before_construction_and_released_on_failure() { + let small = Allowance::limited(31); + let mut constructed = false; + let denied = Boxed::try_new( + || { + constructed = true; + Ok::<_, Error>([0u8; 32]) + }, + &small, + ); + assert!(matches!(denied, Err(Error::WorkspaceLimitExceeded(_)))); + assert!(!constructed); + assert_eq!(small.used(), 0); + let budget = Allowance::limited(32); + let failed = + Boxed::<[u8; 32], _>::try_new(|| Err::<[u8; 32], _>(Error::Cancelled), &budget); + assert!(matches!(failed, Err(Error::Cancelled))); + assert_eq!(budget.used(), 0); + let value = Boxed::try_new(|| Ok::<_, Error>([7u8; 32]), &budget).unwrap(); + assert_eq!(budget.used(), 32); + assert_eq!(*value, [7; 32]); + drop(value); + assert_eq!(budget.used(), 0); + } + + use super::*; + + #[test] + fn reader_buffer_writer_preserves_typed_workspace_failure() { + use std::io::Write; + let ledger = Allowance::limited(0); + let mut buffer = Buffer::new(&ledger); + let error = buffer.write_all(b"cannot fit").unwrap_err(); + assert!(matches!( + Error::from(error), + Error::WorkspaceLimitExceeded(_) + )); + assert!(buffer.is_empty()); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn reader_ring_preserves_capacity_charge_through_wrapped_conversion() { + let ledger = Allowance::limited(8); + let buffer = Buffer::copied(b"ABCDEFGH", &ledger).unwrap(); + let storage = buffer.as_ptr(); + let mut ring = Deque::from_buffer(buffer); + ring.discard_prefix(5); + ring.extend_admitted(b"12345".iter().copied()); + assert!(!ring.as_slices().1.is_empty()); + assert_eq!(ledger.used(), 8); + let buffer = ring.into_buffer(); + assert_eq!(&*buffer, b"FGH12345"); + assert_eq!(buffer.as_ptr(), storage); + assert_eq!(buffer.capacity(), 8); + assert_eq!(ledger.used(), 8); + drop(buffer); + assert_eq!(ledger.used(), 0); + assert_eq!( + std::mem::size_of::>(), + std::mem::size_of::>() + ); + } + + #[test] + fn history_admits_before_mutation_and_only_copies_the_retained_tail() { + for limit in [10, 11] { + let allowance = Allowance::limited(limit); + let mut history = Buffer::copied(b"abc", &allowance).unwrap(); + let result = history.remember(b"0123456789", 8); + if limit == 10 { + assert!(matches!(result, Err(Error::WorkspaceLimitExceeded(_)))); + assert_eq!(&*history, b"abc"); + assert_eq!(allowance.used(), 3); + } else { + result.unwrap(); + assert_eq!(&*history, b"23456789"); + assert_eq!(allowance.used(), 8); + } + } + let input = vec![42; 1024 * 1024]; + let allowance = Allowance::limited(8); + let mut history = Buffer::new(&allowance); + history.remember(&input, 8).unwrap(); + history.remember(b"abc", 8).unwrap(); + assert_eq!(&*history, &[42, 42, 42, 42, 42, b'a', b'b', b'c']); + assert_eq!(allowance.used(), 8); + history.remember(b"discard", 0).unwrap(); + assert!(history.is_empty()); + assert_eq!(allowance.used(), 8, "spare capacity remains owned"); + drop(history); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn consuming_a_container_keeps_its_allocation_and_extracted_children_charged() { + let allowance = Allowance::limited(4096); + let mut owners = Buffer::with_capacity(2, &allowance).unwrap(); + owners + .push(Buffer::filled(8, 1u8, &allowance).unwrap()) + .unwrap(); + owners + .push(Buffer::filled(16, 2u8, &allowance).unwrap()) + .unwrap(); + let total = allowance.used(); + let mut iter = owners.into_iter(); + let first = iter.next().unwrap(); + assert_eq!(iter.len(), 1); + assert_eq!(allowance.used(), total); + drop(iter); + assert_eq!(allowance.used(), 8); + assert_eq!(&*first, &[1; 8]); + drop(first); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn unlimited_buffers_and_success_results_keep_the_existing_layout() { + assert_eq!( + std::mem::size_of::>(), + std::mem::size_of::>() + ); + assert!( + std::mem::size_of::>() <= std::mem::size_of::<(&str, usize)>(), + "large diagnostics must not widen hot codec results" + ); + } + + #[test] + fn growth_reserves_replacement_peak_and_refusal_preserves_storage() { + for limit in [23, 24] { + let allowance = Allowance::limited(limit); + let mut buffer = Buffer::filled(1, 7u64, &allowance).unwrap(); + // Bounded growth requests at least four elements: 8 old + 32 new. + assert!(matches!( + buffer.push(9), + Err(Error::WorkspaceLimitExceeded(details)) if details.required == 40 && details.used == 8 + )); + assert_eq!(&*buffer, &[7]); + assert_eq!(allowance.used(), 8); + drop(buffer); + assert_eq!(allowance.used(), 0); + } + let allowance = Allowance::limited(40); + let mut buffer = Buffer::filled(1, 7u64, &allowance).unwrap(); + buffer.push(9).unwrap(); + assert_eq!(&*buffer, &[7, 9]); + assert_eq!(allowance.used(), 32); + buffer.clear(); + assert_eq!(allowance.used(), 32, "spare capacity is still owned"); + drop(buffer); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn prepend_keeps_order_and_refuses_before_mutating_a_full_buffer() { + let allowance = Allowance::limited(8); + let mut buffer = Buffer::filled(4, 7u8, &allowance).unwrap(); + assert!(buffer.prepend([1, 2].into_iter()).is_err()); + assert_eq!(&*buffer, &[7, 7, 7, 7]); + assert_eq!(allowance.used(), 4); + drop(buffer); + let allowance = Allowance::limited(12); + let mut buffer = Buffer::filled(4, 7u8, &allowance).unwrap(); + buffer.prepend([1, 2].into_iter()).unwrap(); + assert_eq!(&*buffer, &[1, 2, 7, 7, 7, 7]); + assert_eq!(allowance.used(), 8); + } + + #[test] + fn ownership_keeps_charges_through_failure_and_unwind() { + struct Probe(Limited); + impl Drop for Probe { + fn drop(&mut self) { + assert!(self.0.used() > 0); + } + } + let allowance = Allowance::limited(4096); + let result = std::panic::catch_unwind(|| { + let mut values = Buffer::with_capacity(1, &allowance).unwrap(); + values.push(Probe(allowance.clone())).unwrap(); + assert!(Buffer::::with_capacity(4096, &allowance).is_err()); + panic!("unwind the worker"); + }); + assert!(result.is_err()); + assert_eq!(allowance.used(), 0); + drop(Buffer::::with_capacity(4096, &allowance).unwrap()); + assert_eq!(allowance.used(), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn retained_buffers_move_between_threads_without_releasing_capacity() { + let allowance = Allowance::limited(32); + let retained = Buffer::filled(32, 1u8, &allowance).unwrap(); + let clone = allowance.clone(); + std::thread::spawn(move || { + assert_eq!(clone.used(), 32); + assert!(Buffer::::with_capacity(1, &clone).is_err()); + drop(retained); + assert_eq!(clone.used(), 0); + }) + .join() + .unwrap(); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn independent_allowances_do_not_race_for_each_others_spare_bytes() { + let first = Allowance::limited(16); + let second = Allowance::limited(16); + let kept = Buffer::::with_capacity(16, &first).unwrap(); + assert!(Buffer::::with_capacity(1, &first).is_err()); + drop(Buffer::::with_capacity(16, &second).unwrap()); + assert_eq!(first.used(), 16); + assert_eq!(second.used(), 0); + drop(kept); + assert_eq!(first.used(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/codec/workspace/coordinator.rs b/arca-rar/vendor/rars/src/codec/workspace/coordinator.rs new file mode 100644 index 00000000..502cdec7 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/workspace/coordinator.rs @@ -0,0 +1,217 @@ +//! Batch admission happens before dispatch. Workers cannot borrow a sibling's +//! unused allowance, and publication starts only after every callback joins. +use super::{Buffer, Limited, Reservation, RESERVATION_BYTES}; +use crate::{Error, Result}; +use std::sync::atomic::{AtomicBool, Ordering}; + +struct Slot { + item: T, + hint: u64, + reservation: Option, + result: Option>, +} + +pub(crate) fn extract_windowed( + items: I, + ledger: &Limited, + hint: H, + map: M, + mut publish: P, +) -> Result<()> +where + T: Copy + Send, + O: Send, + I: Iterator, + H: Fn(T) -> u64, + M: Fn(T, &Limited) -> Result + Sync + Send, + P: FnMut(O) -> Result<()>, +{ + let mut items = items.peekable(); + while let Some(&first) = items.peek() { + let overhead = std::mem::size_of::>() as u64; + let first_cost = hint(first) + .saturating_add(overhead) + .saturating_add(RESERVATION_BYTES); + ledger.check_capacity(first_cost)?; + let capacity = crate::parallel::default_window() + .max(1) + .min((ledger.available() / first_cost.max(1)).min(usize::MAX as u64) as usize); + let mut slots = Buffer::with_capacity(capacity, ledger)?; + let mut required = 0u64; + while slots.len() < capacity { + let Some(&item) = items.peek() else { break }; + let hint = hint(item); + let next = required + .saturating_add(hint) + .saturating_add(RESERVATION_BYTES); + if next > ledger.available() { + break; + } + items.next(); + slots.push_admitted(Slot { + item, + hint, + reservation: None, + result: None, + }); + required = next; + } + // Admission hints choose the batch width; they are not decoder upper bounds. + // The first-cost check includes its slot allocation, so at least one + // member fits. Only the coordinator holds the global allowance here. + debug_assert!(!slots.is_empty()); + let spare = ledger.available() - required; + let extra = spare / slots.len() as u64; + for slot in &mut slots { + slot.reservation = Some(ledger.reserve(slot.hint + extra)?); + } + let stopped = AtomicBool::new(false); + crate::parallel::for_each_mut(&mut slots, |_, slot| { + let mut reservation = slot.reservation.take().expect("admitted worker"); + if !stopped.load(Ordering::Acquire) { + reservation.start(); + let result = map(slot.item, &reservation.allowance()); + if result.is_err() { + stopped.store(true, Ordering::Release); + } + slot.result = Some(result); + } + reservation.retire(); + }); + // No successful sibling is published on a batch failure. Dropping slots + // frees their results, including results whose reservations have retired. + for slot in &mut slots { + if slot.result.as_ref().is_some_and(Result::is_err) { + return Err(slot.result.take().expect("failed worker").err().unwrap()); + } + } + for slot in &mut slots { + let result = slot.result.take().ok_or(Error::Cancelled)??; + publish(result)?; + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::codec::workspace::Allowance; + use std::sync::atomic::AtomicUsize; + + #[test] + fn a_large_later_hint_waits_for_the_next_batch_in_publication_order() { + let overhead = std::mem::size_of::>>() as u64; + let limit = 4 * (overhead + RESERVATION_BYTES + 16); + let ledger = Allowance::limited(limit); + let published = AtomicUsize::new(0); + extract_windowed( + 0..3usize, + &ledger, + |index| { + if index == 1 { + limit - overhead - RESERVATION_BYTES + } else { + 16 + } + }, + |index, local| { + if index == 1 { + assert_eq!(published.load(Ordering::SeqCst), 1); + } + Ok(Buffer::filled(16, index as u8, local)?) + }, + |data| { + let expected = published.fetch_add(1, Ordering::SeqCst) as u8; + assert_eq!(&*data, &[expected; 16]); + Ok(()) + }, + ) + .unwrap(); + assert_eq!(published.load(Ordering::SeqCst), 3); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn admitted_results_remain_charged_during_publication() { + let ledger = Allowance::limited(8192); + let published = AtomicUsize::new(0); + extract_windowed( + 0..4, + &ledger, + |_| 256, + |index, local| Ok(Buffer::filled(256, index as u8, local)?), + |data| { + assert!(ledger.used() >= data.len() as u64 + RESERVATION_BYTES); + assert!(ledger.used() <= ledger.limit()); + published.fetch_add(1, Ordering::Relaxed); + Ok(()) + }, + ) + .unwrap(); + assert_eq!(published.load(Ordering::Relaxed), 4); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn admission_refusal_runs_no_worker() { + let ledger = Allowance::limited(1); + let error = extract_windowed( + 0..1, + &ledger, + |_| 1, + |_, _| -> Result<()> { panic!("unadmitted worker ran") }, + |_| panic!("unadmitted result published"), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn underestimated_hint_refuses_runtime_growth_without_publishing() { + let ledger = Allowance::limited(8192); + let error = extract_windowed( + 0..2, + &ledger, + |_| 1, + |_, local| Ok(Buffer::filled(16384, 0u8, local)?), + |_| panic!("refused result published"), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn worker_and_sink_failures_release_sibling_results_and_stop_batches() { + for sink_failure in [false, true] { + let ledger = Allowance::limited(8192); + let launched = AtomicUsize::new(0); + let published = AtomicUsize::new(0); + let error = extract_windowed( + 0..100, + &ledger, + |_| 256, + |_, local| { + launched.fetch_add(1, Ordering::Relaxed); + let data = Buffer::filled(256, 0u8, local)?; + if sink_failure { + Ok(data) + } else { + Err(Error::Cancelled) + } + }, + |_| { + published.fetch_add(1, Ordering::Relaxed); + Err(Error::Cancelled) + }, + ) + .unwrap_err(); + assert_eq!(error, Error::Cancelled); + assert!(launched.load(Ordering::Relaxed) <= crate::parallel::default_window()); + assert_eq!(published.load(Ordering::Relaxed), usize::from(sink_failure)); + assert_eq!(ledger.used(), 0); + } + } +} diff --git a/arca-rar/vendor/rars/src/codec/workspace/ledger.rs b/arca-rar/vendor/rars/src/codec/workspace/ledger.rs new file mode 100644 index 00000000..af24fea0 --- /dev/null +++ b/arca-rar/vendor/rars/src/codec/workspace/ledger.rs @@ -0,0 +1,286 @@ +//! Internal admission ledger. Reservations are fixed before dispatch; retiring +//! one returns only unused space, while escaped owners retain their charges. +use super::{Error, Result}; +use std::sync::{Arc, Mutex}; + +#[derive(Debug)] +struct Ledger { + limit: u64, + used: Mutex, +} +#[derive(Debug)] +struct Usage { + ledger: Arc, + capacity: u64, + used: u64, + started: bool, + retired: bool, +} +// Count the per-reservation control payload until its last handle drops. +// Allocator/reference-count headers follow the existing overhead exclusion. +pub(crate) const RESERVATION_BYTES: u64 = std::mem::size_of::>() as u64; +impl Drop for Usage { + fn drop(&mut self) { + debug_assert!(self.retired && self.used == 0); + *self.ledger.used.lock().unwrap() -= RESERVATION_BYTES; + } +} +#[derive(Clone, Debug)] +pub(crate) struct Limited { + ledger: Arc, + scope: Option>>, +} +#[derive(Debug)] +pub(crate) struct Charge { + pub(super) allowance: Limited, + pub(super) bytes: u64, +} +#[derive(Debug)] +pub(crate) struct Reservation { + allowance: Limited, +} +fn refusal(limit: u64, required: u64, used: u64) -> Error { + Error::WorkspaceLimitExceeded(Box::new(crate::codec::WorkspaceLimitError { + limit, + required, + used, + })) +} +impl Limited { + pub(super) fn new(limit: u64) -> Self { + Self { + ledger: Arc::new(Ledger { + limit, + used: Mutex::new(0), + }), + scope: None, + } + } + #[cfg(any(test, feature = "write"))] + pub(crate) fn limit(&self) -> u64 { + self.ledger.limit + } + pub(crate) fn used(&self) -> u64 { + match &self.scope { + Some(scope) => scope.lock().unwrap().used, + None => *self.ledger.used.lock().unwrap(), + } + } + pub(crate) fn available(&self) -> u64 { + match &self.scope { + Some(scope) => { + let usage = scope.lock().unwrap(); + usage.capacity - usage.used + } + None => self.ledger.limit - self.used(), + } + } + pub(crate) fn check_capacity(&self, required: u64) -> Result<()> { + if let Some(scope) = &self.scope { + let usage = scope.lock().unwrap(); + if required > usage.capacity - usage.used { + return Err(refusal(usage.capacity, required, usage.used)); + } + } else { + let used = *self.ledger.used.lock().unwrap(); + if required > self.ledger.limit - used { + return Err(refusal(self.ledger.limit, required, used)); + } + } + Ok(()) + } + fn reserve_global(&self, bytes: u64, required: u64) -> Result<()> { + let mut used = self.ledger.used.lock().unwrap(); + if bytes > self.ledger.limit - *used { + return Err(refusal(self.ledger.limit, required, *used)); + } + *used += bytes; + Ok(()) + } + fn release_global(&self, bytes: u64) { + *self.ledger.used.lock().unwrap() -= bytes; + } + pub(crate) fn reserve(&self, capacity: u64) -> Result { + if self.scope.is_some() { + return Err(Error::InvalidData( + "workers cannot reserve global workspace", + )); + } + let committed = capacity + .checked_add(RESERVATION_BYTES) + .ok_or(Error::InvalidData("workspace reservation overflows"))?; + self.reserve_global(committed, committed)?; + Ok(Reservation { + allowance: Self { + ledger: self.ledger.clone(), + scope: Some(Arc::new(Mutex::new(Usage { + ledger: self.ledger.clone(), + capacity, + used: 0, + started: false, + retired: false, + }))), + }, + }) + } +} +impl Charge { + #[cfg(any(test, feature = "write"))] + pub(crate) fn bytes(&self) -> u64 { + self.bytes + } + pub(super) fn resize(&mut self, bytes: u64) -> Result<()> { + if let Some(scope) = &self.allowance.scope { + let mut usage = scope.lock().unwrap(); + if bytes > self.bytes { + let extra = bytes - self.bytes; + if extra > usage.capacity - usage.used { + return Err(refusal(usage.capacity, bytes, usage.used)); + } + usage.used += extra; + } else { + let released = self.bytes - bytes; + usage.used -= released; + if usage.retired { + usage.capacity -= released; + self.allowance.release_global(released); + } + } + } else if bytes > self.bytes { + self.allowance.reserve_global(bytes - self.bytes, bytes)?; + } else { + self.allowance.release_global(self.bytes - bytes); + } + self.bytes = bytes; + Ok(()) + } +} +impl Drop for Charge { + fn drop(&mut self) { + self.resize(0).expect("releasing capacity cannot fail"); + } +} +impl Reservation { + pub(crate) fn allowance(&self) -> Limited { + self.allowance.clone() + } + /// Extensions are a coordinator action before dispatch, never a worker's + /// attempt to take spare global capacity after an underestimate. + #[cfg(test)] + pub(crate) fn extend(&mut self, additional: u64) -> Result<()> { + let mut usage = self.allowance.scope.as_ref().unwrap().lock().unwrap(); + if usage.started || usage.retired { + return Err(Error::InvalidData("workspace extension after dispatch")); + } + let capacity = usage + .capacity + .checked_add(additional) + .ok_or(Error::InvalidData("workspace reservation overflows"))?; + self.allowance.reserve_global(additional, capacity)?; + usage.capacity = capacity; + Ok(()) + } + pub(crate) fn start(&mut self) { + let mut usage = self.allowance.scope.as_ref().unwrap().lock().unwrap(); + assert!(!usage.retired); + usage.started = true; + } + pub(crate) fn retire(self) { + drop(self); + } +} +impl Drop for Reservation { + fn drop(&mut self) { + let mut usage = self.allowance.scope.as_ref().unwrap().lock().unwrap(); + let unused = usage.capacity - usage.used; + usage.capacity = usage.used; + usage.retired = true; + self.allowance.release_global(unused); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::codec::workspace::Buffer; + + #[test] + fn scoped_capacity_never_borrows_global_spare_space_and_stays_retired() { + let ledger = Limited::new(128 + RESERVATION_BYTES); + let reservation = ledger.reserve(16).unwrap(); + let local = reservation.allowance(); + assert_eq!(local.available(), 16); + local.check_capacity(16).unwrap(); + assert!( + matches!(local.check_capacity(17), Err(Error::WorkspaceLimitExceeded(e)) if (e.limit, e.required, e.used) == (16, 17, 0)) + ); + let bytes = Buffer::filled(8, 1u8, &local).unwrap(); + assert_eq!(local.available(), 8); + assert!(ledger.available() > local.available()); + local.check_capacity(8).unwrap(); + assert!( + matches!(local.check_capacity(9), Err(Error::WorkspaceLimitExceeded(e)) if (e.limit, e.required, e.used) == (16, 9, 8)) + ); + reservation.retire(); + assert_eq!(local.available(), 0); + local.check_capacity(0).unwrap(); + assert!( + matches!(local.check_capacity(1), Err(Error::WorkspaceLimitExceeded(e)) if (e.limit, e.required, e.used) == (8, 1, 8)) + ); + drop(bytes); + assert_eq!(local.available(), 0); + assert_eq!(ledger.used(), RESERVATION_BYTES); + drop(local); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn retirement_releases_only_unused_reservations_and_keeps_escaped_outputs() { + let ledger = Limited::new(128 + 2 * RESERVATION_BYTES); + let mut first = ledger.reserve(64).unwrap(); + let mut second = ledger.reserve(32).unwrap(); + first.extend(16).unwrap(); + assert_eq!(ledger.used(), 112 + 2 * RESERVATION_BYTES); + assert!(ledger.reserve(17).is_err()); + first.start(); + second.start(); + assert!(first.extend(1).is_err()); + let a = first.allowance(); + let b = second.allowance(); + assert!(a.reserve(1).is_err()); + let left = Buffer::filled(48, 7u8, &a).unwrap(); + let mut right = Buffer::filled(16, 9u8, &b).unwrap(); + assert!(Buffer::filled(33, 0u8, &a).is_err()); + assert_eq!(ledger.used(), 112 + 2 * RESERVATION_BYTES); + first.retire(); + assert_eq!(ledger.used(), 80 + 2 * RESERVATION_BYTES); + second.retire(); + assert_eq!(ledger.used(), 64 + 2 * RESERVATION_BYTES); + assert!(right.resize(17, 0).is_err()); + assert_eq!(&*right, &[9u8; 16]); + drop(left); + assert_eq!(ledger.used(), 16 + 2 * RESERVATION_BYTES); + drop(right); + assert_eq!(ledger.used(), 2 * RESERVATION_BYTES); + assert!(Buffer::filled(1, 0u8, &a).is_err()); + drop((a, b)); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn failed_extension_and_unwind_release_the_admitted_scope() { + let ledger = Limited::new(64 + RESERVATION_BYTES); + let result = std::panic::catch_unwind(|| { + let mut reservation = ledger.reserve(48).unwrap(); + assert!(reservation.extend(17).is_err()); + assert_eq!(ledger.used(), 48 + RESERVATION_BYTES); + let _bytes = Buffer::filled(32, 0u8, &reservation.allowance()).unwrap(); + reservation.start(); + panic!("injected unwind"); + }); + assert!(result.is_err()); + assert_eq!(ledger.used(), 0); + ledger.reserve(64).unwrap().retire(); + assert_eq!(ledger.used(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/crc32/mod.rs b/arca-rar/vendor/rars/src/crc32/mod.rs new file mode 100644 index 00000000..891e1e71 --- /dev/null +++ b/arca-rar/vendor/rars/src/crc32/mod.rs @@ -0,0 +1,224 @@ +//! Shared RAR CRC-32 primitives. + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Crc32 { + value: u32, +} + +impl Crc32 { + pub const fn new() -> Self { + Self { value: 0xffff_ffff } + } + + pub fn update(&mut self, input: &[u8]) { + self.value = update_raw(self.value, input); + } + + pub fn update_zeroes(&mut self, len: u64) { + let mut matrix = zero_byte_matrix(); + let mut count = len; + while count != 0 { + if count & 1 != 0 { + self.value = gf2_matrix_times(&matrix, self.value); + } + count >>= 1; + if count != 0 { + matrix = gf2_matrix_square(&matrix); + } + } + } + + pub const fn finish(self) -> u32 { + !self.value + } +} + +impl Default for Crc32 { + fn default() -> Self { + Self::new() + } +} + +pub fn crc32(input: &[u8]) -> u32 { + let mut crc = Crc32::new(); + crc.update(input); + crc.finish() +} + +pub fn crc32_raw(input: &[u8]) -> u32 { + update_raw(0xffff_ffff, input) +} + +pub fn table_entry(index: u8) -> u32 { + TABLE[index as usize] +} + +fn update_raw_byte(crc: u32, byte: u8) -> u32 { + (crc >> 8) ^ table_entry((crc as u8) ^ byte) +} + +fn update_raw(mut crc: u32, mut input: &[u8]) -> u32 { + while input.len() >= 8 { + let word = u32::from_le_bytes([input[0], input[1], input[2], input[3]]); + crc ^= word; + crc = TABLES[7][(crc & 0xff) as usize] + ^ TABLES[6][((crc >> 8) & 0xff) as usize] + ^ TABLES[5][((crc >> 16) & 0xff) as usize] + ^ TABLES[4][((crc >> 24) & 0xff) as usize] + ^ TABLES[3][input[4] as usize] + ^ TABLES[2][input[5] as usize] + ^ TABLES[1][input[6] as usize] + ^ TABLES[0][input[7] as usize]; + input = &input[8..]; + } + for &byte in input { + crc = update_raw_byte(crc, byte); + } + crc +} + +fn zero_byte_matrix() -> [u32; 32] { + let mut matrix = [0; 32]; + for (bit, slot) in matrix.iter_mut().enumerate() { + let mut value = 1u32 << bit; + let index = value as u8; + value = (value >> 8) ^ table_entry(index); + *slot = value; + } + matrix +} + +fn gf2_matrix_times(matrix: &[u32; 32], mut vector: u32) -> u32 { + let mut sum = 0; + let mut index = 0; + while vector != 0 { + if vector & 1 != 0 { + sum ^= matrix[index]; + } + vector >>= 1; + index += 1; + } + sum +} + +fn gf2_matrix_square(matrix: &[u32; 32]) -> [u32; 32] { + let mut square = [0; 32]; + for (index, slot) in square.iter_mut().enumerate() { + *slot = gf2_matrix_times(matrix, matrix[index]); + } + square +} + +const TABLES: [[u32; 256]; 8] = crc32_tables(); +const TABLE: [u32; 256] = TABLES[0]; + +const fn crc32_tables() -> [[u32; 256]; 8] { + let mut tables = [[0; 256]; 8]; + let mut i = 0; + while i < 256 { + let mut value = i as u32; + let mut bit = 0; + while bit < 8 { + let mask = 0u32.wrapping_sub(value & 1); + value = (value >> 1) ^ (0xedb8_8320 & mask); + bit += 1; + } + tables[0][i] = value; + i += 1; + } + + let mut table = 1; + while table < 8 { + let mut i = 0; + while i < 256 { + let previous = tables[table - 1][i]; + tables[table][i] = (previous >> 8) ^ tables[0][(previous & 0xff) as usize]; + i += 1; + } + table += 1; + } + tables +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn crc32_matches_standard_check_value() { + assert_eq!(crc32(b"123456789"), 0xcbf4_3926); + assert_eq!(crc32(b""), 0); + } + + #[test] + fn default_accumulator_uses_the_standard_seed_and_finalization() { + assert_eq!(Crc32::default().finish(), 0); + let mut crc = Crc32::default(); + crc.update(b"1234"); + crc.update(b""); + crc.update(b"56789"); + assert_eq!(crc.finish(), 0xcbf4_3926); + } + + #[test] + fn raw_crc_matches_unfinalized_seeded_rar15_value() { + assert_eq!(crc32_raw(b"password"), 0xca3d_b92a); + } + + #[test] + fn update_zeroes_matches_byte_update() { + let mut skipped = Crc32::new(); + skipped.update(b"prefix"); + skipped.update_zeroes(1024); + skipped.update(b"suffix"); + + let mut bytewise = Crc32::new(); + bytewise.update(b"prefix"); + bytewise.update(&[0; 1024]); + bytewise.update(b"suffix"); + + assert_eq!(skipped.finish(), bytewise.finish()); + } + + fn reference_crc32(input: &[u8]) -> u32 { + let mut crc = 0xffff_ffffu32; + for &byte in input { + crc ^= u32::from(byte); + for _ in 0..8 { + let mask = 0u32.wrapping_sub(crc & 1); + crc = (crc >> 1) ^ (0xedb8_8320 & mask); + } + } + !crc + } + + fn deterministic_bytes(len: usize) -> Vec { + let mut state = 0x1234_5678u32; + let mut out = Vec::with_capacity(len); + while out.len() < len { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + out.push((state >> 24) as u8); + } + out + } + + #[test] + fn crc32_matches_bitwise_reference_across_chunk_boundaries() { + for len in 0..=257 { + let input = deterministic_bytes(len); + assert_eq!(crc32(&input), reference_crc32(&input), "len {len}"); + } + + for len in [1024, 4095, 4096, 4097, 65_536] { + let input = deterministic_bytes(len); + assert_eq!(crc32(&input), reference_crc32(&input), "len {len}"); + } + } + + #[test] + fn table_entry_matches_bitwise_generation() { + assert_eq!(table_entry(0), 0); + assert_eq!(table_entry(1), 0x7707_3096); + assert_eq!(table_entry(0xff), 0x2d02_ef8d); + } +} diff --git a/arca-rar/vendor/rars/src/crypto/mod.rs b/arca-rar/vendor/rars/src/crypto/mod.rs new file mode 100644 index 00000000..16d7f95e --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/mod.rs @@ -0,0 +1,90 @@ +//! RAR legacy and modern archive encryption primitives used by `rars`. + +pub mod rar13; +#[cfg(feature = "encryption")] +pub mod rar15; +pub mod rar20; +pub mod rar30; +pub mod rar50; + +#[cfg(not(feature = "encryption"))] +pub(crate) mod unavailable; + +/// The longest password any RAR key derivation sees. +/// +/// Reference builds copy the password into a 128-element `wchar_t` buffer and +/// keep 127 entries plus a terminator, so nothing past character 127 reaches +/// the KDF. Measured against RAR 7.12: a 133-character password and its first +/// 127 characters open the same archive, and the first 126 do not. +pub const MAX_PASSWORD_CHARS: usize = 127; + +/// Cuts a password down to the [`MAX_PASSWORD_CHARS`] the reference tools keep. +/// +/// Without this rars derives a key no official tool can reproduce, in both +/// directions: it cannot open a WinRAR archive when handed the same long +/// password, and the archives it writes from character 128 on cannot be opened +/// by WinRAR with that password or with any prefix of it. The boundary is +/// sharp, so a password of exactly 127 characters is untouched. +/// +/// A character here is a Unicode scalar, which matches the Linux reference +/// where `wchar_t` is 4 bytes wide. The Windows build has a 2-byte `wchar_t` +/// and so keeps 127 UTF-16 code units instead. The two disagree only for a +/// password carrying astral characters past position 127, where they derive +/// different keys from each other, so no single rule matches both. Scalars win +/// here because truncating UTF-16 can split a surrogate pair, and a Rust `str` +/// cannot hold the lone surrogate that would produce. +pub fn clamp_password(password: &[u8]) -> &[u8] { + match std::str::from_utf8(password) { + Ok(text) => match text.char_indices().nth(MAX_PASSWORD_CHARS) { + Some((byte_offset, _)) => &password[..byte_offset], + None => password, + }, + // RAR 1.3 through 2.0 take single-byte OEM/ANSI passwords, so one byte + // is one character. + Err(_) => &password[..password.len().min(MAX_PASSWORD_CHARS)], + } +} + +/// Refuses encrypted operations when the implementation is omitted. +pub(crate) fn require_encryption() -> crate::Result<()> { + if cfg!(feature = "encryption") { + Ok(()) + } else { + Err(crate::Error::FeatureDisabled { + feature: "encryption", + }) + } +} + +#[cfg(test)] +mod tests { + use super::{clamp_password, MAX_PASSWORD_CHARS}; + + #[test] + fn clamp_password_keeps_127_characters() { + let short = b"hunter2"; + assert_eq!(clamp_password(short), short); + + let exact = "A".repeat(MAX_PASSWORD_CHARS); + assert_eq!(clamp_password(exact.as_bytes()), exact.as_bytes()); + + let long = "A".repeat(130) + "ZZZ"; + assert_eq!(clamp_password(long.as_bytes()), exact.as_bytes()); + } + + #[test] + fn clamp_password_counts_characters_not_bytes() { + // 140 astral scalars: 560 UTF-8 bytes, 280 UTF-16 code units. + let emoji = "\u{1F600}".repeat(140); + let clamped = clamp_password(emoji.as_bytes()); + let text = std::str::from_utf8(clamped).unwrap(); + assert_eq!(text.chars().count(), MAX_PASSWORD_CHARS); + assert_eq!(clamped.len(), MAX_PASSWORD_CHARS * 4); + } + + #[test] + fn clamp_password_falls_back_to_bytes_when_not_utf8() { + let latin1 = vec![0xe9u8; 200]; + assert_eq!(clamp_password(&latin1).len(), MAX_PASSWORD_CHARS); + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar13.rs b/arca-rar/vendor/rars/src/crypto/rar13.rs new file mode 100644 index 00000000..043528cb --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar13.rs @@ -0,0 +1,107 @@ +#[cfg(feature = "encryption")] +use zeroize::ZeroizeOnDrop; + +#[cfg_attr(feature = "encryption", derive(ZeroizeOnDrop))] +pub struct Rar13Cipher { + key: [u8; 3], +} + +pub struct Rar13DecryptReader { + inner: R, + cipher: Rar13Cipher, +} + +impl Rar13Cipher { + #[cfg(feature = "encryption")] + pub fn new(password: &[u8]) -> Self { + let password = crate::crypto::clamp_password(password); + let mut key = [0u8; 3]; + for &byte in password { + key[0] = key[0].wrapping_add(byte); + key[1] ^= byte; + key[2] = key[2].wrapping_add(byte).rotate_left(1); + } + Self { key } + } + + pub(crate) fn for_password(password: &[u8]) -> crate::Result { + #[cfg(feature = "encryption")] + { + Ok(Self::new(password)) + } + #[cfg(not(feature = "encryption"))] + { + let _ = password; + Err(crate::Error::FeatureDisabled { + feature: "encryption", + }) + } + } + + pub fn new_comment() -> Self { + Self { key: [0, 7, 77] } + } + + #[cfg(any(test, feature = "write"))] + pub fn encrypt_in_place(mut self, data: &mut [u8]) { + for byte in data { + *byte = self.encrypt_byte(*byte); + } + } + + pub fn decrypt_in_place(mut self, data: &mut [u8]) { + for byte in data { + *byte = self.decrypt_byte(*byte); + } + } + + #[cfg(any(test, feature = "write"))] + pub fn encrypt_byte(&mut self, byte: u8) -> u8 { + self.advance(); + byte.wrapping_add(self.key[0]) + } + + pub fn decrypt_byte(&mut self, byte: u8) -> u8 { + self.advance(); + byte.wrapping_sub(self.key[0]) + } + + fn advance(&mut self) { + self.key[1] = self.key[1].wrapping_add(self.key[2]); + self.key[0] = self.key[0].wrapping_add(self.key[1]); + } +} + +impl Rar13DecryptReader { + pub fn new(inner: R, cipher: Rar13Cipher) -> Self { + Self { inner, cipher } + } +} + +impl std::io::Read for Rar13DecryptReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + let read = self.inner.read(out)?; + for byte in &mut out[..read] { + *byte = self.cipher.decrypt_byte(*byte); + } + Ok(read) + } +} + +#[cfg(all(test, feature = "encryption"))] +mod tests { + use super::Rar13Cipher; + + #[test] + fn rar13_cipher_matches_pinned_stream_vector() { + let mut data = *b"hello world"; + Rar13Cipher::new(b"password").encrypt_in_place(&mut data); + assert_eq!( + data, + [0x37, 0xcd, 0xaa, 0xbd, 0x10, 0x4e, 0x6f, 0x6e, 0xb5, 0x30, 0xe6] + ); + + Rar13Cipher::new(b"password").decrypt_in_place(&mut data); + assert_eq!(&data, b"hello world"); + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar15.rs b/arca-rar/vendor/rars/src/crypto/rar15.rs new file mode 100644 index 00000000..d4e13a73 --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar15.rs @@ -0,0 +1,76 @@ +use crate::crc32::{crc32_raw, table_entry as crc32_table_entry}; +use zeroize::ZeroizeOnDrop; + +#[derive(ZeroizeOnDrop)] +pub struct Rar15Cipher { + key: [u16; 4], +} + +impl Rar15Cipher { + pub fn new(password: &[u8]) -> Self { + let password = crate::crypto::clamp_password(password); + let password = password.split(|&byte| byte == 0).next().unwrap_or(password); + let password_crc = crc32_raw(password); + let mut key = [ + (password_crc & 0xffff) as u16, + (password_crc >> 16) as u16, + 0, + 0, + ]; + + for &byte in password { + let crc = crc32_table_entry(byte); + key[2] ^= u16::from(byte) ^ crc as u16; + key[3] = key[3].wrapping_add(u16::from(byte).wrapping_add((crc >> 16) as u16)); + } + + Self { key } + } + + pub fn crypt_in_place(&mut self, data: &mut [u8]) { + for byte in data { + *byte ^= self.next_mask(); + } + } + + fn next_mask(&mut self) -> u8 { + self.key[0] = self.key[0].wrapping_add(0x1234); + let crc = crc32_table_entry(((self.key[0] & 0x01fe) >> 1) as u8); + self.key[1] ^= crc as u16; + self.key[2] = self.key[2].wrapping_sub((crc >> 16) as u16); + self.key[0] ^= self.key[2]; + self.key[3] = self.key[3].rotate_right(1) ^ self.key[1]; + self.key[3] = self.key[3].rotate_right(1); + self.key[0] ^= self.key[3]; + (self.key[0] >> 8) as u8 + } +} + +#[cfg(test)] +mod tests { + use super::Rar15Cipher; + + #[test] + fn crypts_known_rar15_stream_vector() { + let mut data = *b"hello world"; + Rar15Cipher::new(b"password").crypt_in_place(&mut data); + assert_eq!( + data, + [0x2b, 0xb9, 0xf3, 0x9c, 0x41, 0xa6, 0xaa, 0xe7, 0x1a, 0x7a, 0x7b] + ); + + Rar15Cipher::new(b"password").crypt_in_place(&mut data); + assert_eq!(&data, b"hello world"); + } + + #[test] + fn password_is_legacy_c_string() { + let mut truncated = *b"hello world"; + let mut plain = *b"hello world"; + + Rar15Cipher::new(b"password\0ignored").crypt_in_place(&mut truncated); + Rar15Cipher::new(b"password").crypt_in_place(&mut plain); + + assert_eq!(truncated, plain); + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar20.rs b/arca-rar/vendor/rars/src/crypto/rar20.rs new file mode 100644 index 00000000..aa42b8fb --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar20.rs @@ -0,0 +1,22 @@ +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + UnalignedInput, +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::UnalignedInput => f.write_str("RAR 2.0 cipher input is not block aligned"), + } + } +} + +impl std::error::Error for Error {} + +pub type Result = std::result::Result; + +#[cfg(feature = "encryption")] +mod implementation; +#[cfg(feature = "encryption")] +pub use implementation::*; diff --git a/arca-rar/vendor/rars/src/crypto/rar20/implementation.rs b/arca-rar/vendor/rars/src/crypto/rar20/implementation.rs new file mode 100644 index 00000000..3604a9aa --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar20/implementation.rs @@ -0,0 +1,233 @@ +use super::{Error, Result}; + +use crate::crc32::table_entry as crc32_table_entry; +use zeroize::{ZeroizeOnDrop, Zeroizing}; + +const INIT_SUBST_TABLE: [u8; 256] = [ + 215, 19, 149, 35, 73, 197, 192, 205, 249, 28, 16, 119, 48, 221, 2, 42, 232, 1, 177, 233, 14, + 88, 219, 25, 223, 195, 244, 90, 87, 239, 153, 137, 255, 199, 147, 70, 92, 66, 246, 13, 216, 40, + 62, 29, 217, 230, 86, 6, 71, 24, 171, 196, 101, 113, 218, 123, 93, 91, 163, 178, 202, 67, 44, + 235, 107, 250, 75, 234, 49, 167, 125, 211, 83, 114, 157, 144, 32, 193, 143, 36, 158, 124, 247, + 187, 89, 214, 141, 47, 121, 228, 61, 130, 213, 194, 174, 251, 97, 110, 54, 229, 115, 57, 152, + 94, 105, 243, 212, 55, 209, 245, 63, 11, 164, 200, 31, 156, 81, 176, 227, 21, 76, 99, 139, 188, + 127, 17, 248, 51, 207, 120, 189, 210, 8, 226, 41, 72, 183, 203, 135, 165, 166, 60, 98, 7, 122, + 38, 155, 170, 69, 172, 252, 238, 39, 134, 59, 128, 236, 27, 240, 80, 131, 3, 85, 206, 145, 79, + 154, 142, 159, 220, 201, 133, 74, 64, 20, 129, 224, 185, 138, 103, 173, 182, 43, 34, 254, 82, + 198, 151, 231, 180, 58, 10, 118, 26, 102, 12, 50, 132, 22, 191, 136, 111, 162, 179, 45, 4, 148, + 108, 161, 56, 78, 126, 242, 222, 15, 175, 146, 23, 33, 241, 181, 190, 77, 225, 0, 46, 169, 186, + 68, 95, 237, 65, 53, 208, 253, 168, 9, 18, 100, 52, 116, 184, 160, 96, 109, 37, 30, 106, 140, + 104, 150, 5, 204, 117, 112, 84, +]; + +const INIT_KEY: [u32; 4] = [0xd3a3_b879, 0x3f6d_12f7, 0x7515_a235, 0xa4e7_f123]; + +#[derive(ZeroizeOnDrop)] +pub struct Rar20Cipher { + key: [u32; 4], + subst: [u8; 256], +} + +impl Rar20Cipher { + pub fn new(password: &[u8]) -> Self { + let mut cipher = Self { + key: INIT_KEY, + subst: INIT_SUBST_TABLE, + }; + cipher.set_key(password); + cipher + } + + pub fn decrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.decrypt_block(block); + } + Ok(()) + } + + #[cfg(any(test, feature = "write"))] + pub fn encrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.encrypt_block(block); + } + Ok(()) + } + + fn set_key(&mut self, password: &[u8]) { + let password = crate::crypto::clamp_password(password); + for j in 0..=255u32 { + for i in (0..password.len()).step_by(2) { + let n1_index = password[i].wrapping_sub(j as u8); + let next = password.get(i + 1).copied().unwrap_or(0); + let n2_index = next.wrapping_add(j as u8); + let mut n1 = crc32_table_entry(n1_index) as u8; + let n2 = crc32_table_entry(n2_index) as u8; + let mut k = 1usize; + while n1 != n2 { + self.subst.swap(n1 as usize, (n1 as usize + i + k) & 0xff); + n1 = n1.wrapping_add(1); + k += 1; + } + } + } + + // clamp_password retains at most 127 Unicode scalars (four UTF-8 + // bytes each). Round that fixed upper bound up to a cipher block. + const PADDED_PASSWORD_BYTES: usize = + (crate::crypto::MAX_PASSWORD_CHARS * 4).div_ceil(16) * 16; + let mut padded = Zeroizing::new([0u8; PADDED_PASSWORD_BYTES]); + padded[..password.len()].copy_from_slice(password); + let padded_len = password.len().div_ceil(16) * 16; + for block in padded[..padded_len].as_chunks_mut::<16>().0.iter_mut() { + self.encrypt_block(block); + } + } + + fn encrypt_block(&mut self, block: &mut [u8]) { + let (mut a, mut b, mut c, mut d) = self.load_block(block); + for i in 0..32 { + (a, b, c, d) = self.round(i, a, b, c, d); + } + write_block( + block, + c ^ self.key[0], + d ^ self.key[1], + a ^ self.key[2], + b ^ self.key[3], + ); + self.update_keys(block); + } + + pub(crate) fn decrypt_block(&mut self, block: &mut [u8; 16]) { + let saved = *block; + let (mut a, mut b, mut c, mut d) = self.load_block(block); + for i in (0..32).rev() { + (a, b, c, d) = self.round(i, a, b, c, d); + } + write_block( + block, + c ^ self.key[0], + d ^ self.key[1], + a ^ self.key[2], + b ^ self.key[3], + ); + self.update_keys(&saved); + } + + fn load_block(&self, block: &[u8]) -> (u32, u32, u32, u32) { + ( + read_u32_le(&block[0..4]) ^ self.key[0], + read_u32_le(&block[4..8]) ^ self.key[1], + read_u32_le(&block[8..12]) ^ self.key[2], + read_u32_le(&block[12..16]) ^ self.key[3], + ) + } + + fn round(&self, i: usize, a: u32, b: u32, c: u32, d: u32) -> (u32, u32, u32, u32) { + let t = c.wrapping_add(d.rotate_left(11)) ^ self.key[i & 3]; + let ta = a ^ self.subst_long(t); + let t = (d ^ c.rotate_left(17)).wrapping_add(self.key[i & 3]); + let tb = b ^ self.subst_long(t); + (c, d, ta, tb) + } + + fn subst_long(&self, value: u32) -> u32 { + u32::from(self.subst[(value & 0xff) as usize]) + | (u32::from(self.subst[((value >> 8) & 0xff) as usize]) << 8) + | (u32::from(self.subst[((value >> 16) & 0xff) as usize]) << 16) + | (u32::from(self.subst[((value >> 24) & 0xff) as usize]) << 24) + } + + fn update_keys(&mut self, block: &[u8]) { + for chunk in block.as_chunks::<4>().0.iter() { + self.key[0] ^= crc32_table_entry(chunk[0]); + self.key[1] ^= crc32_table_entry(chunk[1]); + self.key[2] ^= crc32_table_entry(chunk[2]); + self.key[3] ^= crc32_table_entry(chunk[3]); + } + } +} + +fn read_u32_le(bytes: &[u8]) -> u32 { + u32::from_le_bytes(bytes.try_into().expect("u32 input size")) +} + +fn write_block(block: &mut [u8], a: u32, b: u32, c: u32, d: u32) { + block[0..4].copy_from_slice(&a.to_le_bytes()); + block[4..8].copy_from_slice(&b.to_le_bytes()); + block[8..12].copy_from_slice(&c.to_le_bytes()); + block[12..16].copy_from_slice(&d.to_le_bytes()); +} + +#[cfg(test)] +mod tests { + use super::{Error, Rar20Cipher}; + + #[test] + fn rar20_encrypt_decrypt_round_trips_blocks() { + let mut encrypted = *b"0123456789abcdefRAR2.0 block pad"; + let original = encrypted; + + Rar20Cipher::new(b"password") + .encrypt_in_place(&mut encrypted) + .unwrap(); + assert_eq!( + encrypted, + [ + 0xb7, 0x14, 0x54, 0x5a, 0x55, 0x8b, 0xca, 0xf7, 0xbc, 0x18, 0x38, 0x17, 0x1d, 0x9e, + 0x31, 0xab, 0x81, 0x40, 0x72, 0xfe, 0x02, 0x76, 0x76, 0x65, 0x4a, 0xa5, 0x3f, 0x4b, + 0xb3, 0x0c, 0xad, 0x07, + ] + ); + + Rar20Cipher::new(b"password") + .decrypt_in_place(&mut encrypted) + .unwrap(); + assert_eq!(encrypted, original); + } + + #[test] + fn rar20_maximum_unicode_password_preserves_the_pinned_key_schedule() { + let password = "😀".repeat(crate::crypto::MAX_PASSWORD_CHARS); + let mut encrypted = *b"0123456789abcdef"; + Rar20Cipher::new(password.as_bytes()) + .encrypt_in_place(&mut encrypted) + .unwrap(); + // Captured from the former Vec-based key schedule before replacing it. + assert_eq!( + encrypted, + [162, 163, 252, 197, 198, 249, 120, 35, 101, 82, 12, 143, 172, 74, 33, 216] + ); + let mut longer = *b"0123456789abcdef"; + Rar20Cipher::new((password.clone() + "ignored").as_bytes()) + .encrypt_in_place(&mut longer) + .unwrap(); + assert_eq!(longer, encrypted); + Rar20Cipher::new(password.as_bytes()) + .decrypt_in_place(&mut encrypted) + .unwrap(); + assert_eq!(&encrypted, b"0123456789abcdef"); + } + + #[test] + fn rar20_cipher_rejects_partial_tail() { + let mut data = *b"0123456789abcdef!"; + let original = data; + + assert_eq!( + Rar20Cipher::new(b"password").encrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + assert_eq!(data, original); + assert_eq!( + Rar20Cipher::new(b"password").decrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + assert_eq!(data, original); + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar30.rs b/arca-rar/vendor/rars/src/crypto/rar30.rs new file mode 100644 index 00000000..54dbde9f --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar30.rs @@ -0,0 +1,24 @@ +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + NonUtf8Password, + UnalignedInput, +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::NonUtf8Password => f.write_str("RAR 3.x password is not UTF-8"), + Self::UnalignedInput => f.write_str("RAR 3.x AES input is not block aligned"), + } + } +} + +impl std::error::Error for Error {} + +pub type Result = std::result::Result; + +#[cfg(feature = "encryption")] +mod implementation; +#[cfg(feature = "encryption")] +pub use implementation::*; diff --git a/arca-rar/vendor/rars/src/crypto/rar30/implementation.rs b/arca-rar/vendor/rars/src/crypto/rar30/implementation.rs new file mode 100644 index 00000000..91d6f023 --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar30/implementation.rs @@ -0,0 +1,312 @@ +use super::{Error, Result}; + +#[cfg(any(test, feature = "write"))] +use aes::cipher::BlockCipherEncrypt; +use aes::cipher::{BlockCipherDecrypt, KeyInit}; +use aes::Aes128; +use sha1::{Digest, Sha1 as FastSha1}; +use std::str; +use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; + +const HASH_ROUNDS: u32 = 0x40000; + +#[derive(Clone, ZeroizeOnDrop)] +pub struct Rar30Cipher { + cipher: Aes128, + iv: [u8; 16], +} + +impl Rar30Cipher { + pub fn new(password: &[u8], salt: Option<[u8; 8]>) -> Result { + let (mut key, iv) = derive_key_iv(password, salt)?; + let cipher = Aes128::new(&key.into()); + key.zeroize(); + Ok(Self { cipher, iv }) + } + + pub fn decrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.decrypt_block(block); + } + Ok(()) + } + + #[cfg(any(test, feature = "write"))] + pub fn encrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.encrypt_block(block); + } + Ok(()) + } + + #[cfg(any(test, feature = "write"))] + fn encrypt_block(&mut self, block: &mut [u8]) { + for (byte, iv_byte) in block.iter_mut().zip(self.iv) { + *byte ^= iv_byte; + } + let block: &mut [u8; 16] = block.try_into().expect("AES block size"); + self.cipher.encrypt_block(block.into()); + self.iv.copy_from_slice(block); + } + + pub(crate) fn decrypt_block(&mut self, block: &mut [u8; 16]) { + let ciphertext = *block; + self.cipher.decrypt_block(block.into()); + for (byte, iv_byte) in block.iter_mut().zip(self.iv) { + *byte ^= iv_byte; + } + self.iv = ciphertext; + } +} + +fn derive_key_iv(password: &[u8], salt: Option<[u8; 8]>) -> Result<([u8; 16], [u8; 16])> { + let password = crate::crypto::clamp_password(password); + // The reference password ceiling is in Unicode scalar values. Each can + // contribute at most two UTF-16 units, followed by an optional eight-byte salt. + let mut storage = Zeroizing::new([0u8; crate::crypto::MAX_PASSWORD_CHARS * 4 + 8]); + let mut used = 0; + let password = str::from_utf8(password).map_err(|_| Error::NonUtf8Password)?; + for code_unit in password.encode_utf16() { + storage[used..used + 2].copy_from_slice(&code_unit.to_le_bytes()); + used += 2; + } + if let Some(salt) = salt { + storage[used..used + salt.len()].copy_from_slice(&salt); + used += salt.len(); + } + + let raw = &mut storage[..used]; + + // RAR 3.x mutates password/salt bytes only when the repeated KDF input + // crosses complete SHA-1 blocks. The stock SHA-1 path is equivalent while + // the password+salt material never fills a 64-byte block. + if raw.len() < 64 { + return Ok(derive_key_iv_fast(raw)); + } + + Ok(derive_key_iv_slow(raw)) +} + +fn derive_key_iv_slow(raw: &mut [u8]) -> ([u8; 16], [u8; 16]) { + let raw_size = raw.len(); + let mut storage = Zeroizing::new([0u8; crate::crypto::MAX_PASSWORD_CHARS * 4 + 8 + 64]); + storage[..raw_size].copy_from_slice(raw); + let raw = &mut storage[..raw_size + 64]; + let mut sha1 = FastSha1::new(); + let mut iv = [0; 16]; + let mut pos = 0u32; + for i in 0..HASH_ROUNDS { + sha1.update(&raw[..raw_size]); + let end_pos = (pos + raw_size as u32) & !(64 - 1); + if end_pos > pos + 64 { + let mut cur_pos = (pos & !(64 - 1)) + 64; + while cur_pos != end_pos { + let offset = (cur_pos - pos) as usize; + update_password_data_sha1(&mut raw[offset..offset + 64]); + cur_pos += 64; + } + } + pos = pos.wrapping_add(raw_size as u32); + + sha1.update([ + (i & 0xff) as u8, + ((i >> 8) & 0xff) as u8, + ((i >> 16) & 0xff) as u8, + ]); + pos = pos.wrapping_add(3); + if i.is_multiple_of(HASH_ROUNDS / 16) { + let digest = sha1.clone().finalize(); + iv[(i / (HASH_ROUNDS / 16)) as usize] = digest[19]; + } + } + + let digest = sha1.finalize(); + let mut key = [0; 16]; + for (word_index, chunk) in digest[..16].as_chunks::<4>().0.iter().enumerate() { + key[word_index * 4..word_index * 4 + 4] + .copy_from_slice(&[chunk[3], chunk[2], chunk[1], chunk[0]]); + } + (key, iv) +} + +fn update_password_data_sha1(data: &mut [u8]) { + let mut w = [0u32; 80]; + for (i, chunk) in data.as_chunks::<4>().0.iter().take(16).enumerate() { + w[i] = u32::from_be_bytes(*chunk); + } + for i in 16..80 { + w[i] = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]).rotate_left(1); + } + for (i, word) in w[64..80].iter().enumerate() { + data[i * 4..i * 4 + 4].copy_from_slice(&word.to_le_bytes()); + } +} + +fn derive_key_iv_fast(raw: &[u8]) -> ([u8; 16], [u8; 16]) { + let mut sha1 = FastSha1::new(); + let mut iv = [0; 16]; + for i in 0..HASH_ROUNDS { + sha1.update(raw); + sha1.update([ + (i & 0xff) as u8, + ((i >> 8) & 0xff) as u8, + ((i >> 16) & 0xff) as u8, + ]); + if i.is_multiple_of(HASH_ROUNDS / 16) { + let digest = sha1.clone().finalize(); + iv[(i / (HASH_ROUNDS / 16)) as usize] = digest[19]; + } + } + + let digest = sha1.finalize(); + let mut key = [0; 16]; + for (word_index, chunk) in digest[..16].as_chunks::<4>().0.iter().enumerate() { + key[word_index * 4..word_index * 4 + 4] + .copy_from_slice(&[chunk[3], chunk[2], chunk[1], chunk[0]]); + } + (key, iv) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn maximum_supplementary_unicode_password_fits_bounded_kdf_scratch() { + let password = "🙂".repeat(crate::crypto::MAX_PASSWORD_CHARS); + let longer = format!("{password}🙂"); + let mut exact = *b"0123456789abcdef"; + let mut clamped = exact; + let salt = Some(*b"longsalt"); + Rar30Cipher::new(password.as_bytes(), salt) + .unwrap() + .encrypt_in_place(&mut exact) + .unwrap(); + Rar30Cipher::new(longer.as_bytes(), salt) + .unwrap() + .encrypt_in_place(&mut clamped) + .unwrap(); + assert_eq!(exact, clamped); + } + + fn raw_kdf_material(password: &[u8], salt: Option<[u8; 8]>) -> Vec { + let mut raw = Vec::with_capacity(password.len() * 2 + 8); + let password = str::from_utf8(password).unwrap(); + for code_unit in password.encode_utf16() { + raw.extend_from_slice(&code_unit.to_le_bytes()); + } + if let Some(salt) = salt { + raw.extend_from_slice(&salt); + } + raw + } + + #[test] + fn rar30_aes_encrypt_decrypt_round_trips_blocks() { + let salt = Some([1, 2, 3, 4, 5, 6, 7, 8]); + let mut data = *b"0123456789abcdefRAR AES CBC data"; + let plain = data; + + Rar30Cipher::new(b"password", salt) + .unwrap() + .encrypt_in_place(&mut data) + .unwrap(); + assert_eq!( + data, + [ + 0x5e, 0x59, 0xce, 0xa1, 0x16, 0xca, 0xa2, 0x1d, 0x4d, 0xc5, 0x05, 0xeb, 0xa9, 0x3f, + 0x7b, 0xcd, 0x0d, 0x04, 0xff, 0xea, 0x60, 0x67, 0x3d, 0xaf, 0x6a, 0x8f, 0x02, 0xb2, + 0x03, 0xc8, 0x7d, 0xde, + ] + ); + + Rar30Cipher::new(b"password", salt) + .unwrap() + .decrypt_in_place(&mut data) + .unwrap(); + assert_eq!(data, plain); + } + + #[test] + fn rar30_aes_round_trips_with_long_password_slow_path() { + // Password long enough that utf-16(password) + 8-byte salt >= 64, + // forcing derive_key_iv to use the RAR3 password-buffer mutation path + // instead of derive_key_iv_fast. + let password = b"this-password-is-deliberately-long-enough-to-exceed-64-bytes-utf16"; + let salt = Some(*b"longsalt"); + let mut data = *b"0123456789abcdefRAR AES CBC data"; + let plain = data; + + Rar30Cipher::new(password, salt) + .unwrap() + .encrypt_in_place(&mut data) + .unwrap(); + assert_eq!( + data, + [ + 0xb9, 0xa7, 0xac, 0x4b, 0x81, 0x0a, 0x5c, 0xf1, 0x6e, 0xd4, 0x5a, 0x4c, 0xbc, 0x1e, + 0x2e, 0xef, 0x53, 0x7b, 0x89, 0x63, 0x7a, 0xc5, 0x7a, 0x1e, 0xfc, 0x43, 0x3c, 0x18, + 0xea, 0xfd, 0x54, 0xed, + ] + ); + + Rar30Cipher::new(password, salt) + .unwrap() + .decrypt_in_place(&mut data) + .unwrap(); + assert_eq!(data, plain); + } + + #[test] + fn rar30_aes_rejects_partial_tail() { + let mut data = *b"partial block!!"; + + assert_eq!( + Rar30Cipher::new(b"password", None) + .unwrap() + .encrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + assert_eq!( + Rar30Cipher::new(b"password", None) + .unwrap() + .decrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + } + + #[test] + fn rejects_non_utf8_passwords() { + assert!(matches!( + Rar30Cipher::new(b"\xffpassword", None), + Err(Error::NonUtf8Password) + )); + } + + #[test] + fn rar30_fast_kdf_matches_reference_path_for_short_material() { + for (password, salt) in [ + (b"".as_slice(), None), + (b"password".as_slice(), Some(*b"rarsalt!")), + ("páss".as_bytes(), Some([1, 2, 3, 4, 5, 6, 7, 8])), + ] { + let raw = raw_kdf_material(password, salt); + assert!( + raw.len() < 64, + "case should exercise the fast-path precondition" + ); + + let fast = derive_key_iv_fast(&raw); + let mut reference_raw = raw.clone(); + let reference = derive_key_iv_slow(&mut reference_raw); + + assert_eq!(fast, reference); + } + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar50.rs b/arca-rar/vendor/rars/src/crypto/rar50.rs new file mode 100644 index 00000000..931b73f1 --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar50.rs @@ -0,0 +1,122 @@ +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + KdfCountTooLarge, + BadPassword, + UnalignedInput, + FeatureDisabled, +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::KdfCountTooLarge => f.write_str("RAR 5 KDF count is too large"), + Self::BadPassword => f.write_str("wrong password or corrupt encrypted data"), + Self::FeatureDisabled => f.write_str("Cargo feature encryption is disabled"), + Self::UnalignedInput => f.write_str("RAR 5 AES input is not block aligned"), + } + } +} + +impl std::error::Error for Error {} + +pub type Result = std::result::Result; + +/// The PBKDF2 iteration exponent this writer stores in new archives, giving +/// `2^15` = 32768 iterations. +/// +/// WinRAR writes 15 and a reader honours whatever the archive declares, so the +/// only thing a smaller exponent buys is a faster offline password guess +/// against the archives we produce. It costs about 15 ms per encrypted member +/// on the write side, which is what WinRAR pays too. +pub const WRITE_KDF_COUNT_LOG: u8 = 15; + +#[derive(Clone)] +#[cfg_attr(feature = "encryption", derive(zeroize::ZeroizeOnDrop))] +#[non_exhaustive] +pub struct Rar50Keys { + pub key: [u8; 32], + pub hash_key: [u8; 32], + pub password_check: [u8; 8], +} + +impl std::fmt::Debug for Rar50Keys { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Rar50Keys").finish_non_exhaustive() + } +} + +impl PartialEq for Rar50Keys { + fn eq(&self, other: &Self) -> bool { + let key_eq = constant_time_eq(&self.key, &other.key); + let hash_eq = constant_time_eq(&self.hash_key, &other.hash_key); + let check_eq = constant_time_eq(&self.password_check, &other.password_check); + key_eq & hash_eq & check_eq + } +} + +impl Eq for Rar50Keys {} + +fn constant_time_eq(left: &[u8; N], right: &[u8; N]) -> bool { + let mut diff = 0u8; + for (&left, &right) in left.iter().zip(right) { + diff |= left ^ right; + } + diff == 0 +} + +#[cfg(feature = "encryption")] +mod implementation; +#[cfg(feature = "encryption")] +pub use implementation::*; + +impl Rar50Keys { + pub(crate) fn checked_crc_mac(&self, value: u32) -> crate::Result { + #[cfg(feature = "encryption")] + { + Ok(self.mac_crc32(value)) + } + #[cfg(not(feature = "encryption"))] + { + let _ = value; + Err(crate::Error::FeatureDisabled { + feature: "encryption", + }) + } + } + pub(crate) fn checked_hash_mac(&self, value: [u8; 32]) -> crate::Result<[u8; 32]> { + #[cfg(feature = "encryption")] + { + Ok(self.mac_hash32(value)) + } + #[cfg(not(feature = "encryption"))] + { + let _ = value; + Err(crate::Error::FeatureDisabled { + feature: "encryption", + }) + } + } +} + +#[cfg(not(feature = "encryption"))] +impl Rar50Keys { + pub fn derive(_password: &[u8], _salt: [u8; 16], _kdf_count_log: u8) -> Result { + Err(Error::FeatureDisabled) + } +} +#[cfg(feature = "write")] +impl Rar50Keys { + pub(crate) fn checked_password_record(&self) -> crate::Result<[u8; 12]> { + #[cfg(feature = "encryption")] + { + Ok(self.password_check_record()) + } + #[cfg(not(feature = "encryption"))] + { + Err(crate::Error::FeatureDisabled { + feature: "encryption", + }) + } + } +} diff --git a/arca-rar/vendor/rars/src/crypto/rar50/implementation.rs b/arca-rar/vendor/rars/src/crypto/rar50/implementation.rs new file mode 100644 index 00000000..591f25f7 --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/rar50/implementation.rs @@ -0,0 +1,280 @@ +use super::{constant_time_eq, Error, Rar50Keys, Result}; + +#[cfg(any(test, feature = "write", feature = "recovery"))] +use aes::cipher::BlockCipherEncrypt; +use aes::cipher::{BlockCipherDecrypt, KeyInit}; +use aes::Aes256; +use hmac::{Hmac, Mac}; +use sha2::{Digest, Sha256}; +use zeroize::{Zeroize, ZeroizeOnDrop}; + +const MAX_KDF_COUNT_LOG: u8 = 24; + +type HmacSha256 = Hmac; + +impl Rar50Keys { + pub fn derive(password: &[u8], salt: [u8; 16], kdf_count_log: u8) -> Result { + if kdf_count_log > MAX_KDF_COUNT_LOG { + return Err(Error::KdfCountTooLarge); + } + let password = crate::crypto::clamp_password(password); + + let mut first_input = [0u8; 20]; + first_input[..16].copy_from_slice(&salt); + first_input[16..].copy_from_slice(&1u32.to_be_bytes()); + + let mut u = hmac_sha256(password, &first_input); + let mut accumulator = u; + let mut taps = [[0u8; 32]; 3]; + let mut iterations = (1u32 << kdf_count_log) - 1; + + for tap in &mut taps { + for _ in 0..iterations { + u = hmac_sha256(password, &u); + for (acc, byte) in accumulator.iter_mut().zip(u) { + *acc ^= byte; + } + } + *tap = accumulator; + iterations = 16; + } + + let mut password_check = [0u8; 8]; + for (i, byte) in password_check.iter_mut().enumerate() { + *byte = taps[2][i] ^ taps[2][i + 8] ^ taps[2][i + 16] ^ taps[2][i + 24]; + } + + let result = Self { + key: taps[0], + hash_key: taps[1], + password_check, + }; + u.zeroize(); + accumulator.zeroize(); + taps.zeroize(); + Ok(result) + } + + /// Verifies the password against a stored check record, unless the record + /// is the all-zero one WinRAR 5.21 and earlier wrote. + /// + /// Those versions set the check-present flag and then left the eight bytes + /// zero, so verifying rejects the correct password and the archive cannot + /// be opened at all. Treat all-zero as "no check available" and let the + /// data checksum decide instead. + /// + /// The reference readers do the same. Zeroing the field in a WinRAR 7.12 + /// archive leaves the right password working, and changes what a wrong one + /// reports from "Incorrect password" to a checksum error, which is the + /// explicit check dropping out and detection falling through. Zeroing the + /// record's own trailing checksum or leaving it stale makes no difference + /// to that, so the all-zero test comes first here too. + pub fn check_password(&self, stored: &[u8; 12]) -> Result<()> { + if stored[..8] == [0u8; 8] { + return Ok(()); + } + let checksum = sha256(&stored[..8]); + let checksum_matches = constant_time_eq( + checksum.first_chunk::<4>().unwrap(), + stored.last_chunk::<4>().unwrap(), + ); + let password_matches = + constant_time_eq(&self.password_check, stored.first_chunk::<8>().unwrap()); + if !(checksum_matches & password_matches) { + return Err(Error::BadPassword); + } + Ok(()) + } + + pub fn password_check_record(&self) -> [u8; 12] { + let mut record = [0u8; 12]; + record[..8].copy_from_slice(&self.password_check); + record[8..].copy_from_slice(&sha256(&self.password_check)[..4]); + record + } + + pub fn mac_crc32(&self, crc: u32) -> u32 { + let digest = hmac_sha256(&self.hash_key, &crc.to_le_bytes()); + digest + .as_chunks::<4>() + .0 + .iter() + .fold(0, |acc, chunk| acc ^ u32::from_le_bytes(*chunk)) + } + + pub fn mac_hash32(&self, hash: [u8; 32]) -> [u8; 32] { + hmac_sha256(&self.hash_key, &hash) + } +} + +#[derive(ZeroizeOnDrop)] +pub struct Rar50Cipher { + cipher: Aes256, + iv: [u8; 16], +} + +impl Rar50Cipher { + pub fn new(key: [u8; 32], iv: [u8; 16]) -> Self { + Self { + cipher: Aes256::new(&key.into()), + iv, + } + } + + pub fn decrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.decrypt_block(block); + } + Ok(()) + } + + #[cfg(any(test, feature = "write", feature = "recovery"))] + pub fn encrypt_in_place(&mut self, data: &mut [u8]) -> Result<()> { + if !data.len().is_multiple_of(16) { + return Err(Error::UnalignedInput); + } + for block in data.as_chunks_mut::<16>().0.iter_mut() { + self.encrypt_block(block); + } + Ok(()) + } + + #[cfg(any(test, feature = "write", feature = "recovery"))] + fn encrypt_block(&mut self, block: &mut [u8]) { + for (byte, iv_byte) in block.iter_mut().zip(self.iv) { + *byte ^= iv_byte; + } + let block: &mut [u8; 16] = block.try_into().expect("AES block size"); + self.cipher.encrypt_block(block.into()); + self.iv.copy_from_slice(block); + } + + pub(crate) fn decrypt_block(&mut self, block: &mut [u8; 16]) { + let ciphertext = *block; + self.cipher.decrypt_block(block.into()); + for (byte, iv_byte) in block.iter_mut().zip(self.iv) { + *byte ^= iv_byte; + } + self.iv = ciphertext; + } +} + +fn hmac_sha256(key: &[u8], data: &[u8]) -> [u8; 32] { + let mut hmac = + ::new_from_slice(key).expect("HMAC accepts keys of any size"); + hmac.update(data); + hmac.finalize().into_bytes().into() +} + +fn sha256(data: &[u8]) -> [u8; 32] { + Sha256::digest(data).into() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sha256_matches_standard_vectors() { + assert_eq!( + hex(&sha256(b"")), + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + ); + assert_eq!( + hex(&sha256(b"abc")), + "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" + ); + } + + #[test] + fn hmac_sha256_matches_standard_vector() { + assert_eq!( + hex(&hmac_sha256(&[0x0b; 20], b"Hi There")), + "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7" + ); + } + + #[test] + fn password_check_uses_the_check_value_and_its_checksum() { + let keys = Rar50Keys::derive(b"secret", [7; 16], 4).unwrap(); + let mut record = keys.password_check_record(); + + assert_eq!(keys.check_password(&record), Ok(())); + + record[0] ^= 0x01; + assert_eq!(keys.check_password(&record), Err(Error::BadPassword)); + + let mut record = keys.password_check_record(); + record[11] ^= 0x01; + assert_eq!(keys.check_password(&record), Err(Error::BadPassword)); + } + + #[test] + fn rar50_aes_encrypt_decrypt_round_trips_blocks() { + let key = [9u8; 32]; + let iv = [5u8; 16]; + let mut data = *b"0123456789abcdefRAR5 block two!!"; + let plain = data; + + Rar50Cipher::new(key, iv) + .encrypt_in_place(&mut data) + .unwrap(); + assert_ne!(data, plain); + + Rar50Cipher::new(key, iv) + .decrypt_in_place(&mut data) + .unwrap(); + assert_eq!(data, plain); + } + + #[test] + fn rar50_aes_rejects_partial_tail() { + let key = [9u8; 32]; + let iv = [5u8; 16]; + let mut data = *b"partial block!!"; + + assert_eq!( + Rar50Cipher::new(key, iv).encrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + assert_eq!( + Rar50Cipher::new(key, iv).decrypt_in_place(&mut data), + Err(Error::UnalignedInput) + ); + } + + #[test] + fn rar50_kdf_matches_pinned_vector() { + let keys = Rar50Keys::derive( + b"password", + [ + 0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13, 0x20, 0x21, 0x22, 0x23, 0x30, 0x31, + 0x32, 0x33, + ], + 4, + ) + .unwrap(); + + assert_eq!( + hex(&keys.key), + "cae43ebc57fcbdfc97ddc6f4a2d09687fd06010b51f651bec8f911f20caf008f" + ); + assert_eq!( + hex(&keys.hash_key), + "e65c566ff17139eaabdf60986e64058aac7e8dd82d6c5b027dd2e6d761a44d3c" + ); + assert_eq!(hex(&keys.password_check), "118929fdcad8a74f"); + assert_eq!( + hex(&keys.password_check_record()), + "118929fdcad8a74f5379ff2d" + ); + assert_eq!(keys.mac_crc32(0x1234_5678), 0xd742_398d); + } + + fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|byte| format!("{byte:02x}")).collect() + } +} diff --git a/arca-rar/vendor/rars/src/crypto/unavailable.rs b/arca-rar/vendor/rars/src/crypto/unavailable.rs new file mode 100644 index 00000000..28123779 --- /dev/null +++ b/arca-rar/vendor/rars/src/crypto/unavailable.rs @@ -0,0 +1,64 @@ +//! Uninhabited reader storage preserves shared generic extraction types when +//! encrypted implementations are excluded. Constructors always report availability. +use crate::{Error, Result}; +use std::convert::Infallible; +use std::marker::PhantomData; +pub(crate) struct Reader { + unavailable: Infallible, + _parameters: PhantomData<(R, B)>, +} +impl Reader { + pub(crate) fn with_allowance( + _inner: R, + _version: u8, + _password: &[u8], + _salt: Option<[u8; 8]>, + _allowance: &B, + ) -> Result { + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } +} +impl Reader { + pub(crate) fn with_keys(_inner: R, _key: [u8; 32], _iv: [u8; 16]) -> Result { + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } +} +impl std::io::Read for Reader { + fn read(&mut self, _out: &mut [u8]) -> std::io::Result { + match self.unavailable {} + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn constructors_refuse_before_input_or_workspace_access() { + struct Unread; + impl std::io::Read for Unread { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + panic!("disabled crypto must not read input") + } + } + let allowance = crate::codec::workspace::Allowance::limited(0); + let result = Reader::with_allowance(Unread, 29, b"password", None, &allowance); + assert!(matches!( + result, + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + assert_eq!(allowance.used(), 0); + let result = Reader::with_keys(Unread, [0; 32], [0; 16]); + assert!(matches!( + result, + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + } +} diff --git a/arca-rar/vendor/rars/src/detect.rs b/arca-rar/vendor/rars/src/detect.rs new file mode 100644 index 00000000..23febc89 --- /dev/null +++ b/arca-rar/vendor/rars/src/detect.rs @@ -0,0 +1,192 @@ +use crate::version::ArchiveFamily; +use aho_corasick::AhoCorasick; +use std::sync::OnceLock; + +pub const RAR13_SIGNATURE: &[u8; 4] = b"RE~^"; +pub const RAR15_SIGNATURE: &[u8; 7] = b"Rar!\x1a\x07\x00"; +pub const RAR50_SIGNATURE: &[u8; 8] = b"Rar!\x1a\x07\x01\x00"; + +/// Default upper bound for scanning past an SFX stub when looking for the RAR +/// signature. Most installers in the wild place the archive within a few +/// hundred KiB, but large SFX modules (notably WinRAR's own installer plus a +/// bundled runtime) can push the offset past 1 MiB. +pub const SFX_SCAN_LIMIT: usize = 8 * 1024 * 1024; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct ArchiveSignature { + pub family: ArchiveFamily, + pub offset: usize, + pub length: usize, +} + +pub fn detect_archive_family(input: &[u8]) -> Option { + detect_at(input, 0) +} + +const SIGNATURES: &[&[u8]] = &[RAR50_SIGNATURE, RAR15_SIGNATURE, RAR13_SIGNATURE]; +const MAX_SIGNATURE_LEN: usize = { + let mut max_len = 0; + let mut i = 0; + while i < SIGNATURES.len() { + if SIGNATURES[i].len() > max_len { + max_len = SIGNATURES[i].len(); + } + i += 1; + } + max_len +}; + +fn signatures_searcher() -> &'static AhoCorasick { + static INSTANCE: OnceLock = OnceLock::new(); + INSTANCE.get_or_init(|| AhoCorasick::new(SIGNATURES).unwrap()) +} + +fn signatures_searcher_only_15_plus() -> &'static AhoCorasick { + static INSTANCE: OnceLock = OnceLock::new(); + INSTANCE.get_or_init(|| AhoCorasick::new(&SIGNATURES[..2]).unwrap()) +} + +pub fn find_archive_start(input: &[u8], max_scan: usize) -> Option { + // The limit is the maximum offset to find the signature, so we need to look + // up to the longest signature after that point. + let limit = input.len().min(max_scan.saturating_add(MAX_SIGNATURE_LEN)); + let input = &input[..limit]; + let mut first_rar13 = None; + let mut it = signatures_searcher().find_iter(input); + while let Some(m) = it.next() { + let family = match m.pattern().as_u32() { + 0 => ArchiveFamily::Rar50Plus, + 1 => ArchiveFamily::Rar15To40, + 2 => { + // Only find the first rar13 signature + debug_assert!(first_rar13.is_none()); + first_rar13 = Some(ArchiveSignature { + family: ArchiveFamily::Rar13, + offset: m.start(), + length: m.len(), + }); + // Switch to a searcher that doesn't have the rar13 signature anymore + it = signatures_searcher_only_15_plus() + .find_iter(aho_corasick::Input::new(input).range(m.end()..)); + continue; + } + _ => unreachable!(), + }; + if m.start() > max_scan { + break; + } + return Some(ArchiveSignature { + family, + offset: m.start(), + length: m.len(), + }); + } + first_rar13.filter(|sig| sig.offset <= max_scan) +} + +fn detect_at(input: &[u8], offset: usize) -> Option { + let tail = input.get(offset..)?; + + if tail.starts_with(RAR50_SIGNATURE) { + Some(ArchiveSignature { + family: ArchiveFamily::Rar50Plus, + offset, + length: RAR50_SIGNATURE.len(), + }) + } else if tail.starts_with(RAR15_SIGNATURE) { + Some(ArchiveSignature { + family: ArchiveFamily::Rar15To40, + offset, + length: RAR15_SIGNATURE.len(), + }) + } else if tail.starts_with(RAR13_SIGNATURE) { + Some(ArchiveSignature { + family: ArchiveFamily::Rar13, + offset, + length: RAR13_SIGNATURE.len(), + }) + } else { + None + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn detects_all_known_signatures() { + assert_eq!( + detect_archive_family(b"RE~^").unwrap().family, + ArchiveFamily::Rar13 + ); + assert_eq!( + detect_archive_family(b"Rar!\x1a\x07\x00").unwrap().family, + ArchiveFamily::Rar15To40 + ); + assert_eq!( + detect_archive_family(b"Rar!\x1a\x07\x01\x00") + .unwrap() + .family, + ArchiveFamily::Rar50Plus + ); + } + + #[test] + fn finds_sfx_prefixed_archive() { + let sig = find_archive_start(b"stub bytes RE~^payload", 128).unwrap(); + assert_eq!(sig.family, ArchiveFamily::Rar13); + assert_eq!(sig.offset, 11); + } + + #[test] + fn sfx_scan_prefers_stronger_rar15_signature_over_earlier_rar13_bytes() { + let sig = find_archive_start(b"stub RE~^ bytes Rar!\x1a\x07\x00payload", 128).unwrap(); + assert_eq!(sig.family, ArchiveFamily::Rar15To40); + assert_eq!(sig.offset, 16); + } + + #[test] + fn rejects_unknown_and_truncated_signatures() { + assert_eq!(detect_archive_family(b""), None); + assert_eq!(detect_archive_family(b"RAR!"), None); + assert_eq!(detect_archive_family(b"Rar!\x1a\x07"), None); + assert_eq!(find_archive_start(b"not an archive", 128), None); + } + + #[test] + fn scan_limit_bounds_sfx_detection() { + let input = b"stub bytes RE~^payload"; + + assert_eq!(find_archive_start(input, 10), None); + + let sig = find_archive_start(input, 11).unwrap(); + assert_eq!(sig.family, ArchiveFamily::Rar13); + assert_eq!(sig.offset, 11); + assert_eq!(sig.length, RAR13_SIGNATURE.len()); + } + + #[test] + fn shorter_signatures_in_scan_lookahead_do_not_escape_the_offset_limit() { + for signature in [RAR15_SIGNATURE.as_slice(), RAR13_SIGNATURE.as_slice()] { + let mut input = vec![0]; + input.extend_from_slice(signature); + assert_eq!(find_archive_start(&input, 0), None); + let found = find_archive_start(&input, 1).unwrap(); + assert_eq!(found.offset, 1); + assert_eq!(found.length, signature.len()); + } + } + + #[test] + fn sfx_scan_limit_finds_signature_past_128kib_stub() { + // Real SFX installers routinely place the RAR payload past 128 KiB + // (modern WinRAR-built SFXes, Nero, anti-virus installers, etc.). + let mut stub = vec![0u8; 300 * 1024]; + stub.extend_from_slice(RAR15_SIGNATURE); + let sig = find_archive_start(&stub, SFX_SCAN_LIMIT).unwrap(); + assert_eq!(sig.family, ArchiveFamily::Rar15To40); + assert_eq!(sig.offset, 300 * 1024); + } +} diff --git a/arca-rar/vendor/rars/src/entropy.rs b/arca-rar/vendor/rars/src/entropy.rs new file mode 100644 index 00000000..fbbd315a --- /dev/null +++ b/arca-rar/vendor/rars/src/entropy.rs @@ -0,0 +1,65 @@ +//! Fresh salts and IVs for writing archives or framing repaired headers. + +use crate::{Error, Result}; + +fn entropy_error(error: getrandom::Error, context: &'static str) -> Error { + std::io::Error::other(format!("{context}: {error}")).into() +} + +/// Fill salt or IV bytes using the operating system's entropy source. +pub(crate) fn fill_entropy(bytes: &mut [u8], context: &'static str) -> Result<()> { + fill_entropy_with(bytes, context, getrandom::fill) +} + +fn fill_entropy_with( + bytes: &mut [u8], + context: &'static str, + fill: fn(&mut [u8]) -> std::result::Result<(), getrandom::Error>, +) -> Result<()> { + fill(bytes).map_err(|error| entropy_error(error, context)) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn entropy_failure_is_io_and_keeps_the_backend_diagnostic() { + let error = super::entropy_error(getrandom::Error::UNSUPPORTED, "encryption salt"); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert!(error.to_string().contains("encryption salt")); + assert!(error + .to_string() + .contains(&getrandom::Error::UNSUPPORTED.to_string())); + } + + #[test] + fn entropy_fill_delegates_the_whole_buffer_and_refuses_backend_failure() { + fn success(bytes: &mut [u8]) -> std::result::Result<(), getrandom::Error> { + for (index, byte) in bytes.iter_mut().enumerate() { + *byte = index as u8; + } + Ok(()) + } + fn failure(bytes: &mut [u8]) -> std::result::Result<(), getrandom::Error> { + bytes[0] = 42; + Err(getrandom::Error::UNSUPPORTED) + } + for context in [ + "RAR 3.x writer could not generate encryption salt", + "RAR 5 writer could not generate encryption salt", + "RAR 5 writer could not generate encryption IV", + ] { + let mut bytes = [0xff; 16]; + fill_entropy_with(&mut bytes, context, success).unwrap(); + assert_eq!(bytes, std::array::from_fn(|index| index as u8)); + let error = fill_entropy_with(&mut bytes, context, failure).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.to_string(), + format!("I/O error: {context}: {}", getrandom::Error::UNSUPPORTED) + ); + assert_eq!(bytes[0], 42); + assert_eq!(&bytes[1..], &(1u8..16).collect::>()); + } + } +} diff --git a/arca-rar/vendor/rars/src/error.rs b/arca-rar/vendor/rars/src/error.rs new file mode 100644 index 00000000..7af9f3c9 --- /dev/null +++ b/arca-rar/vendor/rars/src/error.rs @@ -0,0 +1,1098 @@ +use crate::version::{ArchiveFamily, ArchiveVersion}; +use std::sync::Arc; + +pub type Result = std::result::Result; + +/// Stable error categories for callers and language bindings. Context wrappers +/// do not change the category; display text remains a diagnostic, not a protocol. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum ErrorKind { + InvalidArchive, + InvalidArgument, + UnsupportedFormat, + UnsupportedFeature, + PasswordRequired, + BadPassword, + ChecksumMismatch, + EntryNotFound, + DuplicateEntry, + UnsafePath, + Io, + ResourceLimit, + Cancelled, + SourceChanged, + /// Archive construction failed because the writer reached an invalid state. + WriterFailure, +} + +impl ErrorKind { + /// Stable machine-readable code, independent of diagnostic wording. + pub fn code(self) -> &'static str { + match self { + Self::InvalidArchive => "INVALID_ARCHIVE", + Self::InvalidArgument => "INVALID_OPTION", + Self::UnsupportedFormat => "UNSUPPORTED_FORMAT", + Self::UnsupportedFeature => "UNSUPPORTED_FEATURE", + Self::PasswordRequired => "PASSWORD_REQUIRED", + Self::BadPassword => "BAD_PASSWORD", + Self::ChecksumMismatch => "CHECKSUM_MISMATCH", + Self::EntryNotFound => "ENTRY_NOT_FOUND", + Self::DuplicateEntry => "DUPLICATE_ENTRY", + Self::UnsafePath => "UNSAFE_ENTRY_NAME", + Self::Io => "IO", + Self::ResourceLimit => "RESOURCE_LIMIT", + Self::Cancelled => "CANCELLED", + Self::SourceChanged => "SOURCE_CHANGED", + Self::WriterFailure => "WRITE_FAILED", + } + } +} + +#[derive(Debug, Clone)] +pub struct IoError { + pub kind: std::io::ErrorKind, + pub message: String, + source: Arc, +} + +impl IoError { + pub fn source(&self) -> &(dyn std::error::Error + 'static) { + self.source.as_ref() + } +} + +impl PartialEq for IoError { + fn eq(&self, other: &Self) -> bool { + self.kind == other.kind && self.message == other.message + } +} + +impl Eq for IoError {} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + TooShort, + UnsupportedSignature, + InvalidHeader(&'static str), + InvalidArgument(&'static str), + EntryNotFound, + DuplicateEntry, + InputSymlink, + UnsafePath(&'static str), + SourceChanged(&'static str), + WriterFailure(&'static str), + AtArchiveOffset { + offset: usize, + source: Box, + }, + AtEntry { + name: Vec, + operation: &'static str, + source: Box, + }, + /// A fault traced to one volume of a set, numbered from one. + InVolume { + number: usize, + source: Box, + }, + UnsupportedVersion(ArchiveVersion), + /// The requested implementation was omitted at compile time. + FeatureDisabled { + feature: &'static str, + }, + /// Skipping payload decoding would leave solid history unavailable. + CannotSkipSolidMember, + UnsupportedFeature { + version: ArchiveVersion, + feature: &'static str, + }, + /// A writer option that would change the output, for a format that cannot + /// honour it. + UnsupportedWriterOption { + target: ArchiveVersion, + option: crate::WriterOption, + /// Why, when the format alone is not the reason: "in a compressed + /// archive", "levels run from 0 to 5". Rendered after the format. + because: Option<&'static str>, + }, + /// `required` is the declared size or the minimum attempted output size. + MemberOutputLimitExceeded { + limit: u64, + required: u64, + }, + /// Cumulative top-level headers required; diagnostic sums saturate at u64::MAX. + HeaderCountLimitExceeded { + limit: u64, + required: u64, + }, + /// Cumulative plaintext header bytes required, saturated at u64::MAX. + HeaderBytesLimitExceeded { + limit: u64, + required: u64, + }, + /// Total logical output refusal. `used` is accepted output before refusal; + /// `required` is used plus the declared size or offered chunk, saturated at + /// u64::MAX (a lower bound if the attempted sum cannot be represented). + TotalOutputLimitExceeded { + limit: u64, + required: u64, + used: u64, + }, + Rar50DictionaryLimitExceeded { + limit: u64, + required: u64, + }, + Rar50BufferedDecodeLimitExceeded { + limit: u64, + required: u64, + }, + Rar50ScratchLimitExceeded { + limit: u64, + required: u64, + }, + /// Retained rewrite payload bytes, excluding decoder and writer workspace. + RewriteStagingLimitExceeded { + limit: u64, + required: u64, + }, + Rar50FilterMemoryLimitExceeded { + limit: u64, + required: u64, + }, + /// Aggregate logical spool storage, including in-flight growth reservations. + /// Diagnostic `required` saturates at u64::MAX on accounting overflow. + WriterSpoolLimitExceeded { + limit: u64, + required: u64, + used: u64, + }, + /// Shared capacity of in-memory spool payloads and indexes, including reservations. + WriterSpoolMemoryLimitExceeded { + limit: u64, + required: u64, + used: u64, + }, + /// Retained RAR5/7 prepared header image capacity, including reservations. + WriterPreparedHeaderLimitExceeded { + limit: u64, + required: u64, + used: u64, + }, + WriterPreparationLimitExceeded { + limit: u64, + required: u64, + used: u64, + }, + MemoryLimitExceeded { + limit: u64, + required: u64, + dictionary_size: u64, + }, + UnsupportedFamilyFeature { + family: ArchiveFamily, + feature: &'static str, + }, + UnsupportedCompression { + family: &'static str, + unpack_version: u8, + method: u8, + }, + UnsupportedEncryption { + family: &'static str, + unpack_version: u8, + }, + Io(IoError), + NeedPassword, + WrongPasswordOrCorruptData, + /// Archive writing was cancelled by a token or progress callback. + Cancelled, + CrcMismatch { + expected: u16, + actual: u16, + }, + Crc32Mismatch { + expected: u32, + actual: u32, + }, + HashMismatch { + hash_type: u64, + }, + Codec(crate::codec::Error), + Rar3Recovery(crate::recovery::rar3::Error), + Rar5Recovery(crate::recovery::rar5::Error), + Rar20Crypto(crate::crypto::rar20::Error), + Rar30Crypto(crate::crypto::rar30::Error), + Rar50Crypto(crate::crypto::rar50::Error), +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::TooShort => write!(f, "input is too short"), + Self::UnsupportedSignature => write!(f, "unsupported archive signature"), + Self::InvalidHeader(msg) => write!(f, "invalid header: {msg}"), + Self::InvalidArgument(msg) => write!(f, "invalid argument: {msg}"), + Self::EntryNotFound => f.write_str("no such archive entry"), + Self::DuplicateEntry => f.write_str("duplicate archive entry name"), + Self::InputSymlink => f.write_str("input is a symlink; refusing to follow it"), + Self::UnsafePath(msg) | Self::SourceChanged(msg) | Self::WriterFailure(msg) => f.write_str(msg), + Self::AtArchiveOffset { offset, source } => { + write!(f, "at archive offset {offset:#x}: {source}") + } + Self::InVolume { number, source } => write!(f, "in volume {number}: {source}"), + Self::AtEntry { + name, + operation, + source, + } => { + write!( + f, + "while {operation} entry '{}': {source}", + String::from_utf8_lossy(name) + ) + } + Self::UnsupportedVersion(version) => write!(f, "unsupported version: {version}"), + Self::FeatureDisabled { feature } => write!(f, "Cargo feature {feature} is disabled"), + Self::CannotSkipSolidMember => write!(f, "cannot skip file data in a solid archive"), + Self::UnsupportedFeature { version, feature } => { + write!(f, "feature {feature} is not supported by {version}") + } + Self::UnsupportedWriterOption { + target, + option, + because, + } => match because { + Some(reason) => { + write!(f, "{} is not supported by {target} ({reason})", option.name()) + } + None => write!(f, "{} is not supported by {target}", option.name()), + }, + Self::MemberOutputLimitExceeded { limit, required } => write!(f, + "member requires {required} output bytes, above the configured limit of {limit} bytes"), + Self::HeaderCountLimitExceeded { limit, required } => write!(f, + "parsing requires at least {required} headers, above the configured limit of {limit} headers"), + Self::HeaderBytesLimitExceeded { limit, required } => write!(f, + "parsing requires at least {required} header bytes, above the configured limit of {limit} bytes"), + Self::TotalOutputLimitExceeded { limit, required, used } => write!(f, + "extraction requires at least {required} total output bytes, above the configured limit of {limit} bytes ({used} bytes already accepted)"), + Self::Rar50DictionaryLimitExceeded { limit, required } => write!( + f, + "RAR 5 member declares a {required}-byte dictionary, above the configured limit of {limit} bytes" + ), + Self::Rar50BufferedDecodeLimitExceeded { limit, required } => write!( + f, + "RAR 5 filtered member requires buffered decoding of {required} bytes, above the configured limit of {limit} bytes" + ), + Self::Rar50ScratchLimitExceeded { limit, required } => write!(f, "RAR 5 scratch limit {limit} bytes exceeded (requires {required})"), + Self::RewriteStagingLimitExceeded { limit, required } => write!(f, "rewrite staging limit {limit} bytes exceeded (requires {required})"), + Self::Rar50FilterMemoryLimitExceeded { limit, required } => write!(f, "RAR 5 filter workspace limit {limit} bytes exceeded (requires {required})"), + Self::WriterSpoolLimitExceeded { limit, required, used } => write!(f, + "writer spool limit {limit} bytes exceeded (requires {required}; {used} bytes already retained or reserved)"), + Self::WriterPreparationLimitExceeded { limit, required, used } => write!(f, + "writer preparation limit {limit} bytes exceeded (requires {required}; {used} bytes already retained or reserved)"), + Self::WriterPreparedHeaderLimitExceeded { limit, required, used } => write!(f, + "writer prepared header limit {limit} bytes exceeded (requires {required}; {used} bytes already retained or reserved)"), + Self::WriterSpoolMemoryLimitExceeded { limit, required, used } => write!(f, + "writer spool memory limit {limit} bytes exceeded (requires {required}; {used} bytes already retained or reserved)"), + Self::MemoryLimitExceeded { + limit, + required, + dictionary_size, + } => write!( + f, + "compression needs at least {required} bytes of working memory for a {dictionary_size}-byte dictionary, above the configured limit of {limit} bytes" + ), + Self::UnsupportedFamilyFeature { family, feature } => { + write!(f, "feature {feature} is not supported by {family:?}") + } + Self::UnsupportedCompression { + family, + unpack_version, + method, + } => write!( + f, + "{family} compression is not supported: unpack version {unpack_version}, method {method:#04x}" + ), + Self::UnsupportedEncryption { + family, + unpack_version, + } => write!( + f, + "{family} encryption is not supported: unpack version {unpack_version}" + ), + Self::Io(error) => write!(f, "I/O error: {}", error.message), + Self::NeedPassword => write!(f, "a password is required"), + Self::WrongPasswordOrCorruptData => { + write!(f, "wrong password or corrupt encrypted data") + } + Self::Cancelled => f.write_str("archive writing was cancelled"), + Self::CrcMismatch { expected, actual } => { + write!( + f, + "checksum mismatch: expected {expected:#06x}, got {actual:#06x}" + ) + } + Self::Crc32Mismatch { expected, actual } => { + write!( + f, + "checksum mismatch: expected {expected:#010x}, got {actual:#010x}" + ) + } + Self::HashMismatch { hash_type } => { + write!(f, "hash mismatch for hash type {hash_type}") + } + Self::Codec(error) => write!(f, "{error}"), + Self::Rar3Recovery(error) => write!(f, "{error}"), + Self::Rar5Recovery(error) => write!(f, "{error}"), + Self::Rar20Crypto(error) => write!(f, "{error}"), + Self::Rar30Crypto(error) => write!(f, "{error}"), + Self::Rar50Crypto(error) => write!(f, "{error}"), + } + } +} + +impl From for Error { + fn from(error: std::io::Error) -> Self { + // A reader buried inside a decoder has only `io::Error` to report + // through, so it wraps the real error. Unwrap it again here, otherwise + // a checksum mismatch surfaces as an I/O failure. + let error = match error.downcast::() { + Ok(inner) => return inner, + Err(error) => error, + }; + Self::Io(IoError { + kind: error.kind(), + message: error.to_string(), + source: Arc::new(error), + }) + } +} + +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + Self::AtArchiveOffset { source, .. } + | Self::AtEntry { source, .. } + | Self::InVolume { source, .. } => Some(source), + Self::Codec(source) => Some(source), + Self::Rar3Recovery(source) => Some(source), + Self::Rar5Recovery(source) => Some(source), + Self::Rar20Crypto(source) => Some(source), + Self::Rar30Crypto(source) => Some(source), + Self::Rar50Crypto(source) => Some(source), + Self::Io(source) => Some(source.source()), + _ => None, + } + } +} + +impl Error { + /// The underlying library error, with archive/entry/volume context removed. + /// The original error still owns and displays every context wrapper. + pub fn root_cause(&self) -> &Self { + let mut error = self; + while let Self::AtArchiveOffset { source, .. } + | Self::AtEntry { source, .. } + | Self::InVolume { source, .. } = error + { + error = source; + } + error + } + + /// The outermost member context, if this error identifies a member. + pub fn entry_context(&self) -> Option<(&[u8], &'static str)> { + let mut error = self; + loop { + match error { + Self::AtEntry { + name, operation, .. + } => return Some((name, operation)), + Self::AtArchiveOffset { source, .. } | Self::InVolume { source, .. } => { + error = source + } + _ => return None, + } + } + } + + /// Classify the cause without discarding its diagnostic context. + pub fn kind(&self) -> ErrorKind { + match self.root_cause() { + Self::AtArchiveOffset { .. } | Self::AtEntry { .. } | Self::InVolume { .. } => { + unreachable!("root cause has no context wrapper") + } + Self::UnsupportedSignature | Self::UnsupportedVersion(_) => { + ErrorKind::UnsupportedFormat + } + Self::FeatureDisabled { .. } + | Self::Rar50Crypto(crate::crypto::rar50::Error::FeatureDisabled) + | Self::CannotSkipSolidMember + | Self::UnsupportedFeature { .. } + | Self::UnsupportedFamilyFeature { .. } + | Self::UnsupportedCompression { .. } + | Self::UnsupportedEncryption { .. } + | Self::UnsupportedWriterOption { .. } => ErrorKind::UnsupportedFeature, + Self::NeedPassword => ErrorKind::PasswordRequired, + Self::WrongPasswordOrCorruptData + | Self::Rar50Crypto(crate::crypto::rar50::Error::BadPassword) => ErrorKind::BadPassword, + Self::CrcMismatch { .. } | Self::Crc32Mismatch { .. } | Self::HashMismatch { .. } => { + ErrorKind::ChecksumMismatch + } + Self::Rar5Recovery(crate::recovery::rar5::Error::Cancelled) => ErrorKind::Cancelled, + Self::Io(_) | Self::Rar5Recovery(crate::recovery::rar5::Error::Io(_)) => ErrorKind::Io, + Self::Rar50ScratchLimitExceeded { .. } + | Self::RewriteStagingLimitExceeded { .. } + | Self::Rar50FilterMemoryLimitExceeded { .. } + | Self::MemoryLimitExceeded { .. } + | Self::WriterSpoolLimitExceeded { .. } + | Self::WriterSpoolMemoryLimitExceeded { .. } + | Self::WriterPreparedHeaderLimitExceeded { .. } + | Self::WriterPreparationLimitExceeded { .. } + | Self::MemberOutputLimitExceeded { .. } + | Self::HeaderCountLimitExceeded { .. } + | Self::HeaderBytesLimitExceeded { .. } + | Self::TotalOutputLimitExceeded { .. } + | Self::Rar50DictionaryLimitExceeded { .. } + | Self::Rar50BufferedDecodeLimitExceeded { .. } + | Self::Rar5Recovery(crate::recovery::rar5::Error::RebuildTooLarge) + | Self::Rar5Recovery(crate::recovery::rar5::Error::RepairWorkspaceLimitExceeded { + .. + }) => ErrorKind::ResourceLimit, + Self::Codec(crate::codec::Error::Io(error)) => error.kind(), + Self::Codec(crate::codec::Error::WorkspaceLimitExceeded(_)) => ErrorKind::ResourceLimit, + Self::Cancelled | Self::Codec(crate::codec::Error::Cancelled) => ErrorKind::Cancelled, + Self::EntryNotFound => ErrorKind::EntryNotFound, + Self::DuplicateEntry => ErrorKind::DuplicateEntry, + Self::InputSymlink | Self::InvalidArgument(_) => ErrorKind::InvalidArgument, + Self::UnsafePath(_) => ErrorKind::UnsafePath, + Self::SourceChanged(_) => ErrorKind::SourceChanged, + Self::WriterFailure(_) => ErrorKind::WriterFailure, + Self::TooShort + | Self::InvalidHeader(_) + | Self::Codec(_) + | Self::Rar3Recovery(_) + | Self::Rar5Recovery(_) + | Self::Rar20Crypto(_) + | Self::Rar30Crypto(_) + | Self::Rar50Crypto(_) => ErrorKind::InvalidArchive, + } + } + + pub fn at_archive_offset(self, offset: usize) -> Self { + Self::AtArchiveOffset { + offset, + source: Box::new(self), + } + } + + pub fn at_entry(self, name: Vec, operation: &'static str) -> Self { + Self::AtEntry { + name, + operation, + source: Box::new(self), + } + } +} + +impl From for Error { + fn from(error: crate::codec::Error) -> Self { + match error { + crate::codec::Error::Cancelled => Self::Cancelled, + crate::codec::Error::Io(error) => *error, + error => Self::Codec(error), + } + } +} + +impl From for Error { + fn from(error: crate::recovery::rar5::Error) -> Self { + match error { + crate::recovery::rar5::Error::Cancelled => Self::Cancelled, + crate::recovery::rar5::Error::TypedIo(error) => *error, + error => Self::Rar5Recovery(error), + } + } +} + +impl From for Error { + fn from(error: crate::recovery::rar3::Error) -> Self { + Self::Rar3Recovery(error) + } +} + +impl From for Error { + fn from(error: crate::crypto::rar20::Error) -> Self { + Self::Rar20Crypto(error) + } +} + +impl From for Error { + fn from(error: crate::crypto::rar30::Error) -> Self { + Self::Rar30Crypto(error) + } +} + +impl From for Error { + fn from(error: crate::crypto::rar50::Error) -> Self { + if error == crate::crypto::rar50::Error::FeatureDisabled { + return Self::FeatureDisabled { + feature: "encryption", + }; + } + Self::Rar50Crypto(error) + } +} + +#[cfg(test)] +mod tests { + #[test] + fn machine_readable_codes_remain_stable_and_distinct() { + let cases = [ + (ErrorKind::InvalidArchive, "INVALID_ARCHIVE"), + (ErrorKind::InvalidArgument, "INVALID_OPTION"), + (ErrorKind::UnsupportedFormat, "UNSUPPORTED_FORMAT"), + (ErrorKind::UnsupportedFeature, "UNSUPPORTED_FEATURE"), + (ErrorKind::PasswordRequired, "PASSWORD_REQUIRED"), + (ErrorKind::BadPassword, "BAD_PASSWORD"), + (ErrorKind::ChecksumMismatch, "CHECKSUM_MISMATCH"), + (ErrorKind::EntryNotFound, "ENTRY_NOT_FOUND"), + (ErrorKind::DuplicateEntry, "DUPLICATE_ENTRY"), + (ErrorKind::UnsafePath, "UNSAFE_ENTRY_NAME"), + (ErrorKind::Io, "IO"), + (ErrorKind::ResourceLimit, "RESOURCE_LIMIT"), + (ErrorKind::Cancelled, "CANCELLED"), + (ErrorKind::SourceChanged, "SOURCE_CHANGED"), + (ErrorKind::WriterFailure, "WRITE_FAILED"), + ]; + let mut codes = std::collections::HashSet::new(); + for (kind, expected) in cases { + assert_eq!(kind.code(), expected); + assert!(codes.insert(kind.code()), "duplicate error code {expected}"); + } + } + + #[test] + fn resource_diagnostics_retain_required_used_and_limit_values() { + let cases = [ + ( + Error::Rar50ScratchLimitExceeded { limit: 11, required: 23 }, + "RAR 5 scratch limit 11 bytes exceeded (requires 23)", + ), + ( + Error::Rar50FilterMemoryLimitExceeded { limit: 11, required: 23 }, + "RAR 5 filter workspace limit 11 bytes exceeded (requires 23)", + ), + ( + Error::WriterSpoolLimitExceeded { limit: 11, required: 23, used: 7 }, + "writer spool limit 11 bytes exceeded (requires 23; 7 bytes already retained or reserved)", + ), + ( + Error::WriterPreparationLimitExceeded { limit: 11, required: 23, used: 7 }, + "writer preparation limit 11 bytes exceeded (requires 23; 7 bytes already retained or reserved)", + ), + ( + Error::WriterPreparedHeaderLimitExceeded { limit: 11, required: 23, used: 7 }, + "writer prepared header limit 11 bytes exceeded (requires 23; 7 bytes already retained or reserved)", + ), + ( + Error::WriterSpoolMemoryLimitExceeded { limit: 11, required: 23, used: 7 }, + "writer spool memory limit 11 bytes exceeded (requires 23; 7 bytes already retained or reserved)", + ), + ]; + for (error, expected) in cases { + assert_eq!(error.kind(), ErrorKind::ResourceLimit); + assert_eq!(error.to_string(), expected); + assert!(std::error::Error::source(&error).is_none()); + } + assert_eq!( + Error::CannotSkipSolidMember.to_string(), + "cannot skip file data in a solid archive" + ); + assert_eq!( + Error::CannotSkipSolidMember.kind(), + ErrorKind::UnsupportedFeature + ); + assert!(Error::CannotSkipSolidMember.entry_context().is_none()); + } + + #[test] + fn codec_io_transport_retains_library_error_types() { + for cause in [ + Error::Cancelled, + Error::NeedPassword, + Error::MemberOutputLimitExceeded { + limit: 1, + required: 2, + }, + ] { + let transported = crate::codec::Error::from(std::io::Error::other(cause.clone())); + assert_eq!(Error::from(transported.clone()), cause); + assert_eq!(Error::Codec(transported).kind(), cause.kind()); + } + } + + #[test] + fn codec_workspace_refusal_keeps_its_resource_classification_and_details() { + let cause = crate::codec::Error::WorkspaceLimitExceeded(Box::new( + crate::codec::WorkspaceLimitError { + limit: 12, + required: 16, + used: 8, + }, + )); + let error = Error::from(cause.clone()).at_archive_offset(42); + assert_eq!(error.kind(), ErrorKind::ResourceLimit); + assert!(matches!(error.root_cause(), Error::Codec(actual) if actual == &cause)); + assert!(error.to_string().contains("codec workspace limit 12")); + } + + use super::*; + + #[test] + fn classification_survives_every_context_order_without_losing_details() { + let cases = [ + (Error::NeedPassword, ErrorKind::PasswordRequired), + ( + Error::Rar50Crypto(crate::crypto::rar50::Error::BadPassword), + ErrorKind::BadPassword, + ), + ( + Error::UnsupportedCompression { + family: "RAR", + unpack_version: 99, + method: 9, + }, + ErrorKind::UnsupportedFeature, + ), + ( + Error::UnsupportedVersion(ArchiveVersion::Rar50), + ErrorKind::UnsupportedFormat, + ), + ( + Error::from(std::io::Error::from(std::io::ErrorKind::PermissionDenied)), + ErrorKind::Io, + ), + ( + Error::Rar5Recovery(crate::recovery::rar5::Error::Io( + std::io::ErrorKind::WriteZero, + )), + ErrorKind::Io, + ), + ( + Error::MemoryLimitExceeded { + limit: 1, + required: 2, + dictionary_size: 1, + }, + ErrorKind::ResourceLimit, + ), + ( + Error::TotalOutputLimitExceeded { + limit: 100, + required: 110, + used: 60, + }, + ErrorKind::ResourceLimit, + ), + ( + Error::Codec(crate::codec::Error::Cancelled), + ErrorKind::Cancelled, + ), + ( + Error::HeaderCountLimitExceeded { + limit: 1, + required: 2, + }, + ErrorKind::ResourceLimit, + ), + ( + Error::HeaderBytesLimitExceeded { + limit: 1, + required: 2, + }, + ErrorKind::ResourceLimit, + ), + (Error::Cancelled, ErrorKind::Cancelled), + ( + Error::WriterFailure("layout failure"), + ErrorKind::WriterFailure, + ), + (Error::EntryNotFound, ErrorKind::EntryNotFound), + (Error::DuplicateEntry, ErrorKind::DuplicateEntry), + (Error::InputSymlink, ErrorKind::InvalidArgument), + (Error::UnsafePath("path refusal"), ErrorKind::UnsafePath), + ( + Error::SourceChanged("changed source"), + ErrorKind::SourceChanged, + ), + ( + Error::InvalidHeader("password is required; unsafe; I/O error"), + ErrorKind::InvalidArchive, + ), + ( + Error::HashMismatch { hash_type: 0 }, + ErrorKind::ChecksumMismatch, + ), + ]; + for (cause, expected) in cases { + assert_eq!(cause.kind(), expected); + for order in [ + [0, 1, 2], + [0, 2, 1], + [1, 0, 2], + [1, 2, 0], + [2, 0, 1], + [2, 1, 0], + ] { + let mut wrapped = cause.clone(); + for wrapper in order { + wrapped = match wrapper { + 0 => wrapped.at_archive_offset(42), + 1 => wrapped.at_entry(b"member".to_vec(), "reading"), + _ => Error::InVolume { + number: 3, + source: Box::new(wrapped), + }, + }; + } + assert_eq!(wrapped.kind(), expected); + assert_eq!(wrapped.root_cause(), &cause); + assert_eq!( + wrapped.entry_context(), + Some((b"member".as_slice(), "reading")) + ); + assert!(wrapped.to_string().contains("in volume 3")); + assert!(wrapped.to_string().contains("member")); + } + } + } + + #[test] + fn archive_offset_context_exposes_source_error() { + let error = Error::InvalidHeader("bad block").at_archive_offset(0x1234); + + assert_eq!( + error.to_string(), + "at archive offset 0x1234: invalid header: bad block" + ); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("invalid header: bad block".to_string()) + ); + } + + #[test] + fn entry_context_exposes_source_error() { + let error = Error::Crc32Mismatch { + expected: 1, + actual: 2, + } + .at_entry(b"hello.txt".to_vec(), "verifying"); + + assert_eq!( + error.to_string(), + "while verifying entry 'hello.txt': checksum mismatch: expected 0x00000001, got 0x00000002" + ); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("checksum mismatch: expected 0x00000001, got 0x00000002".to_string()) + ); + } + + #[test] + fn io_error_preserves_error_kind() { + let error = Error::from(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "locked", + )); + + assert!(matches!( + error, + Error::Io(ref source) if source.kind == std::io::ErrorKind::PermissionDenied + )); + assert_eq!(error.to_string(), "I/O error: locked"); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("locked".to_string()) + ); + } + + #[test] + fn io_error_partial_eq_compares_kind_and_message_ignoring_source_identity() { + let permission = Error::from(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "locked", + )); + let permission_again = Error::from(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "locked", + )); + let different_kind = + Error::from(std::io::Error::new(std::io::ErrorKind::NotFound, "locked")); + let different_message = Error::from(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "elsewhere", + )); + + // Same kind + same message → equal even though Arc differs. + assert_eq!(permission, permission_again); + // Differing kind or message → not equal. + assert_ne!(permission, different_kind); + assert_ne!(permission, different_message); + } + + #[test] + fn unsupported_codec_errors_are_not_reported_as_invalid_headers() { + assert_eq!( + Error::UnsupportedCompression { + family: "RAR 1.5-4.x", + unpack_version: 14, + method: 0x33, + } + .to_string(), + "RAR 1.5-4.x compression is not supported: unpack version 14, method 0x33" + ); + assert_eq!( + Error::UnsupportedEncryption { + family: "RAR 1.5-4.x", + unpack_version: 14, + } + .to_string(), + "RAR 1.5-4.x encryption is not supported: unpack version 14" + ); + } + + #[test] + fn codec_errors_remain_inspectable_without_changing_display_text() { + let error = Error::from(crate::codec::Error::NeedMoreInput); + + assert!(matches!( + error, + Error::Codec(crate::codec::Error::NeedMoreInput) + )); + assert_eq!(error.to_string(), "codec input is truncated"); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("codec input is truncated".to_string()) + ); + } + + #[test] + fn recovery_errors_remain_inspectable_without_changing_display_text() { + let error = Error::from(crate::recovery::rar5::Error::TooManyDamagedShards); + + assert!(matches!( + error, + Error::Rar5Recovery(crate::recovery::rar5::Error::TooManyDamagedShards) + )); + assert_eq!( + error.to_string(), + "RAR 5 recovery data cannot repair this many damaged shards" + ); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("RAR 5 recovery data cannot repair this many damaged shards".to_string()) + ); + } + + #[test] + fn rar3_recovery_errors_remain_in_source_chain() { + let error = Error::from(crate::recovery::rar3::Error::DecodeFailed); + + assert_eq!(error.to_string(), "RAR 3 recovery decode failed"); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("RAR 3 recovery decode failed".to_string()) + ); + } + + #[test] + fn rar30_crypto_errors_remain_in_source_chain() { + let error = Error::from(crate::crypto::rar30::Error::UnalignedInput); + + assert!(matches!( + error, + Error::Rar30Crypto(crate::crypto::rar30::Error::UnalignedInput) + )); + assert_eq!(error.to_string(), "RAR 3.x AES input is not block aligned"); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("RAR 3.x AES input is not block aligned".to_string()) + ); + } + + #[test] + fn rar20_crypto_errors_remain_in_source_chain() { + let error = Error::from(crate::crypto::rar20::Error::UnalignedInput); + + assert!(matches!( + error, + Error::Rar20Crypto(crate::crypto::rar20::Error::UnalignedInput) + )); + assert_eq!( + error.to_string(), + "RAR 2.0 cipher input is not block aligned" + ); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("RAR 2.0 cipher input is not block aligned".to_string()) + ); + } + + #[test] + fn rar50_crypto_errors_remain_in_source_chain() { + let error = Error::from(crate::crypto::rar50::Error::UnalignedInput); + + assert_eq!(error.to_string(), "RAR 5 AES input is not block aligned"); + assert_eq!( + std::error::Error::source(&error).map(ToString::to_string), + Some("RAR 5 AES input is not block aligned".to_string()) + ); + } + + #[test] + fn simple_display_variants_render_their_messages() { + assert_eq!(Error::TooShort.to_string(), "input is too short"); + assert_eq!( + Error::UnsupportedSignature.to_string(), + "unsupported archive signature" + ); + assert_eq!(Error::NeedPassword.to_string(), "a password is required"); + assert_eq!( + Error::WrongPasswordOrCorruptData.to_string(), + "wrong password or corrupt encrypted data" + ); + assert_eq!( + Error::HashMismatch { hash_type: 7 }.to_string(), + "hash mismatch for hash type 7" + ); + assert_eq!( + Error::CrcMismatch { + expected: 0xabcd, + actual: 0x1234 + } + .to_string(), + "checksum mismatch: expected 0xabcd, got 0x1234" + ); + assert_eq!( + Error::UnsupportedVersion(ArchiveVersion::Rar50).to_string(), + "unsupported version: rar50" + ); + assert_eq!( + Error::UnsupportedFeature { + version: ArchiveVersion::Rar50, + feature: "quantum compression", + } + .to_string(), + "feature quantum compression is not supported by rar50" + ); + assert_eq!( + Error::Rar50BufferedDecodeLimitExceeded { + limit: 536_870_912, + required: 734_003_200, + } + .to_string(), + "RAR 5 filtered member requires buffered decoding of 734003200 bytes, above the configured limit of 536870912 bytes" + ); + } + + #[test] + fn rar3_recovery_errors_render_messages_through_from_conversion() { + assert_eq!( + Error::from(crate::recovery::rar3::Error::InvalidParitySize).to_string(), + "RAR 3 recovery parity size is invalid" + ); + assert_eq!( + Error::from(crate::recovery::rar3::Error::InvalidCodewordSize).to_string(), + "RAR 3 recovery codeword size is invalid" + ); + assert_eq!( + Error::from(crate::recovery::rar3::Error::TooManyErasures).to_string(), + "RAR 3 recovery data cannot repair this many erasures" + ); + assert_eq!( + Error::from(crate::recovery::rar3::Error::DecodeFailed).to_string(), + "RAR 3 recovery decode failed" + ); + } + + #[test] + fn rar5_recovery_errors_render_messages_for_every_named_variant() { + let cases = [ + ( + crate::recovery::rar5::Error::BadRecoveryChunk, + "RAR 5 recovery chunk is invalid", + ), + ( + crate::recovery::rar5::Error::OddShardSize, + "RAR 5 recovery shard size is odd", + ), + ( + crate::recovery::rar5::Error::PlanOverflow, + "RAR 5 recovery plan overflows", + ), + ( + crate::recovery::rar5::Error::PrefixExceedsPlan, + "RAR 5 recovery prefix exceeds planned shard capacity", + ), + ( + crate::recovery::rar5::Error::ShardSizeMismatch, + "RAR 5 recovery shard sizes differ", + ), + ( + crate::recovery::rar5::Error::TooManyShards, + "RAR 5 recovery shard count is invalid", + ), + ( + crate::recovery::rar5::Error::SingularElement, + "RAR 5 recovery matrix is singular", + ), + ]; + for (variant, expected) in cases { + assert_eq!(Error::from(variant).to_string(), expected); + } + } + + #[test] + fn rar50_crypto_errors_render_messages_through_from_conversion() { + assert_eq!( + Error::from(crate::crypto::rar50::Error::KdfCountTooLarge).to_string(), + "RAR 5 KDF count is too large" + ); + assert_eq!( + Error::from(crate::crypto::rar50::Error::BadPassword).to_string(), + "wrong password or corrupt encrypted data" + ); + } + + #[test] + fn codec_invalid_data_display_uses_inner_message() { + assert_eq!( + Error::from(crate::codec::Error::InvalidData("bad symbol")).to_string(), + "bad symbol" + ); + } + + #[test] + fn unsupported_family_feature_display_renders_family_and_feature() { + assert_eq!( + Error::UnsupportedFamilyFeature { + family: ArchiveFamily::Rar13, + feature: "recovery repair for RAR 1.3/1.4 archives", + } + .to_string(), + "feature recovery repair for RAR 1.3/1.4 archives is not supported by Rar13", + ); + } + + #[test] + fn rar50_crypto_unaligned_input_display_uses_named_message() { + assert_eq!( + Error::from(crate::crypto::rar50::Error::UnalignedInput).to_string(), + "RAR 5 AES input is not block aligned" + ); + } +} diff --git a/arca-rar/vendor/rars/src/extraction_control.rs b/arca-rar/vendor/rars/src/extraction_control.rs new file mode 100644 index 00000000..321a188f --- /dev/null +++ b/arca-rar/vendor/rars/src/extraction_control.rs @@ -0,0 +1,99 @@ +use crate::{ArchiveMember, ArchiveReadOptions, Error, Result}; +use std::io::Write; + +/// Decision made before a member's payload is admitted or decoded. +pub enum ExtractionDecision { + /// Decode and verify the member, writing its contents to this destination. + Extract(Box), + /// Do not read, decrypt, decode or verify this member's payload. + Skip, + /// Finish successfully without processing this member or any later member. + Stop, +} + +/// Whether a controlled extraction visited every member or stopped by request. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ExtractionOutcome { + /// Reached the end; skipped members and explicitly continued failures were not verified. + Complete, + /// The callback requested an early stop. + Stopped, +} + +/// Response to a failed independent member's extraction. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ExtractionErrorAction { + /// Return the original extraction error. + Abort, + /// Keep any partial output and attempt the next independent member. + Continue, +} + +pub(crate) type ErrorHandler<'a> = + dyn FnMut(&ArchiveMember, &Error) -> Result + 'a; + +/// Returns true only when an independent member failure was explicitly accepted. +pub(crate) fn finish_member( + handler: &mut Option<&mut ErrorHandler<'_>>, + options: ArchiveReadOptions<'_>, + member: impl FnOnce() -> ArchiveMember, + solid: bool, + result: Result<()>, +) -> Result { + let Err(error) = result else { + return Ok(false); + }; + if solid + || matches!( + error.kind(), + crate::ErrorKind::Cancelled | crate::ErrorKind::ResourceLimit + ) + { + return Err(error); + } + let Some(handler) = handler.as_mut() else { + return Err(error); + }; + options.check_cancelled()?; + let member = member(); + if member.meta.is_split_before || member.meta.is_split_after { + return Err(error); + } + let action = handler(&member, &error)?; + options.check_cancelled()?; + match action { + ExtractionErrorAction::Abort => Err(error), + ExtractionErrorAction::Continue => Ok(true), + } +} + +pub(crate) type Selector<'a> = dyn FnMut(&ArchiveMember) -> Result + 'a; + +pub(crate) fn select( + selector: &mut Option<&mut Selector<'_>>, + options: ArchiveReadOptions<'_>, + member: impl FnOnce() -> ArchiveMember, + solid: bool, +) -> Result> { + let Some(selector) = selector.as_mut() else { + return Ok(None); + }; + options.check_cancelled()?; + let member = member(); + let decision = selector(&member).map_err(|error| { + if error.entry_context().is_none() { + error.at_entry(member.meta.name.clone(), "selecting") + } else { + error + } + })?; + options.check_cancelled()?; + if matches!(decision, ExtractionDecision::Skip) + && solid + && !member.meta.is_directory + && !member.meta.is_redirection + { + return Err(Error::CannotSkipSolidMember.at_entry(member.meta.name, "selecting")); + } + Ok(Some(decision)) +} diff --git a/arca-rar/vendor/rars/src/features.rs b/arca-rar/vendor/rars/src/features.rs new file mode 100644 index 00000000..3146460f --- /dev/null +++ b/arca-rar/vendor/rars/src/features.rs @@ -0,0 +1,113 @@ +/// What a caller is asking a writer to do, beyond the data it hands over. +/// +/// Only choices that cannot be read off the data itself live here. Whether an +/// archive has a comment, a password, per-file comments or a recovery record is +/// decided by whether a comment, a password or a percentage was supplied, so +/// carrying separate flags for those only created a way for the two to +/// disagree, which is a bug the writer then had to check for. +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +#[non_exhaustive] +pub struct FeatureSet { + /// Compress members against each other rather than independently. + pub solid: bool, + /// Encrypt the headers as well as the payloads, so names are not readable + /// without the password. + pub header_encryption: bool, + /// Write an index so a reader can list the archive without walking every + /// header. + pub quick_open: bool, +} + +/// One writer feature, in the order a rejection prefers to report them. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum Feature { + Solid, + HeaderEncryption, + QuickOpen, +} + +impl Feature { + pub const ALL: [Self; 3] = [Self::Solid, Self::HeaderEncryption, Self::QuickOpen]; + + /// How this feature is named when a writer has to refuse it. + pub const fn name(self) -> &'static str { + match self { + Self::Solid => "solid compression", + Self::HeaderEncryption => "header encryption", + Self::QuickOpen => "a quick-open index", + } + } + + const fn get(self, set: FeatureSet) -> bool { + match self { + Self::Solid => set.solid, + Self::HeaderEncryption => set.header_encryption, + Self::QuickOpen => set.quick_open, + } + } +} + +impl FeatureSet { + pub const fn store_only() -> Self { + Self { + solid: false, + header_encryption: false, + quick_open: false, + } + } + + /// The first feature asked for here that `supported` does not offer. + pub fn first_unsupported(self, supported: Self) -> Option { + Feature::ALL + .into_iter() + .find(|feature| feature.get(self) && !feature.get(supported)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Destructuring exhaustively, so a new field is a compile error here + /// rather than a silent hole in `Feature::ALL`. + #[test] + fn every_feature_field_has_an_entry_in_the_table() { + let mut all = FeatureSet::store_only(); + let FeatureSet { + solid, + header_encryption, + quick_open, + } = &mut all; + *solid = true; + *header_encryption = true; + *quick_open = true; + + let reported: Vec<_> = Feature::ALL + .into_iter() + .filter(|feature| feature.get(all)) + .collect(); + assert_eq!(reported, Feature::ALL); + } + + #[test] + fn the_first_missing_feature_is_the_one_reported() { + let asked = FeatureSet { + solid: true, + header_encryption: true, + quick_open: true, + }; + assert_eq!( + asked.first_unsupported(FeatureSet::store_only()), + Some(Feature::Solid) + ); + assert_eq!( + asked.first_unsupported(FeatureSet { + solid: true, + ..FeatureSet::store_only() + }), + Some(Feature::HeaderEncryption) + ); + assert_eq!(asked.first_unsupported(asked), None); + } +} diff --git a/arca-rar/vendor/rars/src/file_times.rs b/arca-rar/vendor/rars/src/file_times.rs new file mode 100644 index 00000000..386a8623 --- /dev/null +++ b/arca-rar/vendor/rars/src/file_times.rs @@ -0,0 +1,526 @@ +//! Lossless RAR5 timestamps and validation/conversion of legacy extended times. + +use crate::{Error, Result}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FileTimestamp { + Unix { seconds: u32, nanoseconds: u32 }, + WindowsFiletime(u64), +} + +impl FileTimestamp { + pub fn unix_nanoseconds(self) -> i128 { + match self { + Self::Unix { + seconds, + nanoseconds, + } => i128::from(seconds) * 1_000_000_000 + i128::from(nanoseconds), + Self::WindowsFiletime(ticks) => (i128::from(ticks) - 116_444_736_000_000_000) * 100, + } + } +} + +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub struct FileTimes { + pub modified: Option, + pub created: Option, + pub accessed: Option, +} + +#[cfg(any(test, feature = "write"))] +pub(crate) struct EncodedTimes { + bytes: [u8; 25], + len: usize, +} +#[cfg(any(test, feature = "write"))] +impl std::ops::Deref for EncodedTimes { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.bytes[..self.len] + } +} + +impl FileTimes { + /// Build a record from exact Unix nanoseconds, using FILETIME when needed. + /// FILETIME requires 100-nanosecond precision for every present timestamp. + pub fn from_unix_nanoseconds( + modified: Option, + created: Option, + accessed: Option, + ) -> Result { + let values = [modified, created, accessed]; + let unix = values + .iter() + .flatten() + .all(|value| *value >= 0 && *value / 1_000_000_000 <= i128::from(u32::MAX)); + let mut result = [None; 3]; + for (slot, value) in result.iter_mut().zip(values) { + if let Some(value) = value { + *slot = Some(if unix { + FileTimestamp::Unix { + seconds: (value / 1_000_000_000) as u32, + nanoseconds: (value % 1_000_000_000) as u32, + } + } else { + if value % 100 != 0 { + return Err(Error::InvalidArgument( + "FILETIME range requires 100-nanosecond precision", + )); + } + let ticks = (value / 100) + .checked_add(116_444_736_000_000_000) + .and_then(|ticks| u64::try_from(ticks).ok()) + .ok_or(Error::InvalidArgument("timestamp exceeds FILETIME range"))?; + FileTimestamp::WindowsFiletime(ticks) + }); + } + } + Ok(Self { + modified: result[0], + created: result[1], + accessed: result[2], + }) + } + + #[cfg(any(test, feature = "write"))] + pub(crate) fn encode(self) -> Result { + let times = [self.modified, self.created, self.accessed]; + let first = times + .iter() + .flatten() + .next() + .ok_or(Error::InvalidArgument("file time record is empty"))?; + let unix = matches!(first, FileTimestamp::Unix { .. }); + let mut flags = u8::from(unix); + let mut seconds = [0; 24]; + let mut seconds_len = 0; + let mut fractions = [0; 12]; + let mut fractions_len = 0; + for (index, time) in times.into_iter().enumerate() { + if let Some(time) = time { + flags |= 2 << index; + match time { + FileTimestamp::Unix { + seconds: value, + nanoseconds, + } if unix && nanoseconds < 1_000_000_000 => { + flags |= 0x10; + seconds[seconds_len..seconds_len + 4].copy_from_slice(&value.to_le_bytes()); + seconds_len += 4; + fractions[fractions_len..fractions_len + 4] + .copy_from_slice(&nanoseconds.to_le_bytes()); + fractions_len += 4; + } + FileTimestamp::WindowsFiletime(ticks) if !unix => { + seconds[seconds_len..seconds_len + 8].copy_from_slice(&ticks.to_le_bytes()); + seconds_len += 8; + } + _ => { + return Err(Error::InvalidArgument( + "file times require one encoding and fractions below one second", + )) + } + } + } + } + let mut bytes = [0; 25]; + bytes[0] = flags; + bytes[1..1 + seconds_len].copy_from_slice(&seconds[..seconds_len]); + bytes[1 + seconds_len..1 + seconds_len + fractions_len] + .copy_from_slice(&fractions[..fractions_len]); + Ok(EncodedTimes { + bytes, + len: 1 + seconds_len + fractions_len, + }) + } + + pub(crate) fn parse(flags: u64, data: &[u8]) -> Option { + if flags & !0x1f != 0 || flags & 0x0e == 0 || flags & 0x11 == 0x10 { + return None; + } + let unix = flags & 1 != 0; + let count = (flags & 0x0e).count_ones() as usize; + let width = if unix { 4 } else { 8 }; + let fractions = unix && flags & 0x10 != 0; + if data.len() != count * (width + if fractions { 4 } else { 0 }) { + return None; + } + let mut times = [None; 3]; + let mut at = 0; + for (index, slot) in times.iter_mut().enumerate() { + if flags & (2 << index) == 0 { + continue; + } + *slot = Some(if unix { + let seconds = u32::from_le_bytes(data[at * width..at * width + 4].try_into().ok()?); + let nanoseconds = if fractions { + let offset = count * width + at * 4; + u32::from_le_bytes(data[offset..offset + 4].try_into().ok()?) + } else { + 0 + }; + if nanoseconds >= 1_000_000_000 { + return None; + } + FileTimestamp::Unix { + seconds, + nanoseconds, + } + } else { + FileTimestamp::WindowsFiletime(u64::from_le_bytes( + data[at * width..at * width + 8].try_into().ok()?, + )) + }); + at += 1; + } + Some(Self { + modified: times[0], + created: times[1], + accessed: times[2], + }) + } + + #[cfg(any(test, feature = "write"))] + pub(crate) fn legacy(raw: &[u8], mtime: Option) -> Result> { + if raw.is_empty() { + return Ok(None); + } + let invalid = + || Error::InvalidArgument("legacy extended timestamps are incomplete or invalid"); + let flags = u16::from_le_bytes(raw.get(..2).ok_or_else(invalid)?.try_into().unwrap()); + let mut at = 2; + let mut times = [None; 3]; + // Fourth legacy slot is archival time. It has no RAR5 counterpart. + if flags & 8 != 0 { + return Err(Error::InvalidArgument( + "legacy archival time has no supported RAR5 representation", + )); + } + for (index, slot) in times.iter_mut().enumerate() { + let mode = (flags >> (12 - index * 4)) & 15; + if mode & 8 == 0 { + continue; + } + let seconds = if index == 0 { + mtime.ok_or_else(invalid)? + } else { + let value = u32::from_le_bytes( + raw.get(at..at + 4).ok_or_else(invalid)?.try_into().unwrap(), + ); + at += 4; + value + }; + let mut ticks = 0u32; + for _ in 0..mode & 3 { + ticks = (u32::from(*raw.get(at).ok_or_else(invalid)?) << 16) | (ticks >> 8); + at += 1; + } + if ticks >= 10_000_000 { + return Err(invalid()); + } + let time = crate::timestamp::extracted_system_time( + crate::ArchiveFamily::Rar15To40, + Some(seconds), + Some(crate::TimeRefinement { + add_second: mode & 4 != 0, + nanoseconds: ticks * 100, + }), + ) + .ok_or_else(invalid)?; + let duration = time + .duration_since(std::time::UNIX_EPOCH) + // extracted_system_time adds nonnegative durations to UNIX_EPOCH. + .expect("extracted timestamps cannot precede the Unix epoch"); + *slot = Some(FileTimestamp::Unix { + seconds: u32::try_from(duration.as_secs()).map_err(|_| invalid())?, + nanoseconds: duration.subsec_nanos(), + }); + } + if at != raw.len() { + return Err(invalid()); + } + let times = Self { + modified: times[0], + created: times[1], + accessed: times[2], + }; + Ok((times != Self::default()).then_some(times)) + } +} + +/// Validate a native legacy record without interpreting DOS wall-clock times. +/// Includes the fourth (archival) timestamp, which RAR5 cannot represent. +#[cfg(any(test, feature = "write"))] +pub(crate) fn validate_legacy_extended_times(raw: &[u8]) -> Result<()> { + let invalid = || Error::InvalidArgument("legacy extended timestamps are incomplete or invalid"); + let flags = u16::from_le_bytes(raw.get(..2).ok_or_else(invalid)?.try_into().unwrap()); + let mut at = 2; + for index in 0..4 { + let mode = (flags >> (12 - index * 4)) & 15; + if mode & 8 == 0 { + if mode != 0 { + return Err(invalid()); + } + continue; + } + if index != 0 { + raw.get(at..at + 4).ok_or_else(invalid)?; + at += 4; + } + let mut ticks = 0u32; + for _ in 0..mode & 3 { + ticks = (u32::from(*raw.get(at).ok_or_else(invalid)?) << 16) | (ticks >> 8); + at += 1; + } + if ticks >= 10_000_000 { + return Err(invalid()); + } + } + if at != raw.len() { + return Err(invalid()); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn all_rar5_time_combinations_retain_full_precision() { + for unix in [true, false] { + for mask in 1..8 { + let stamp = |index: u64| { + if unix { + FileTimestamp::Unix { + seconds: if index == 0 { 0 } else { u32::MAX }, + nanoseconds: (index as u32 + 1) * 123, + } + } else { + FileTimestamp::WindowsFiletime(if index == 0 { + 0 + } else { + u64::MAX - index + }) + } + }; + let times = FileTimes { + modified: (mask & 1 != 0).then(|| stamp(0)), + created: (mask & 2 != 0).then(|| stamp(1)), + accessed: (mask & 4 != 0).then(|| stamp(2)), + }; + let bytes = times.encode().unwrap(); + assert_eq!( + FileTimes::parse(u64::from(bytes[0]), &bytes[1..]), + Some(times) + ); + } + } + assert_eq!( + FileTimestamp::WindowsFiletime(0).unix_nanoseconds(), + -11_644_473_600_000_000_000 + ); + } + + #[test] + fn malformed_or_mixed_time_records_are_rejected() { + assert!(FileTimes::parse(1, &[]).is_none()); + assert!(FileTimes::parse(0x23, &[0; 4]).is_none()); + assert!(FileTimes::parse(0x13, &[0; 4]).is_none()); + // Fractional seconds are available only with Unix encoding. + assert!(FileTimes::parse(0x12, &[0; 8]).is_none()); + let mut data = vec![0; 4]; + data.extend(1_000_000_000u32.to_le_bytes()); + assert!(FileTimes::parse(0x13, &data).is_none()); + let mixed = FileTimes { + modified: Some(FileTimestamp::WindowsFiletime(0)), + created: Some(FileTimestamp::Unix { + seconds: 0, + nanoseconds: 0, + }), + accessed: None, + }; + assert!(mixed.encode().is_err()); + assert!(FileTimes::default().encode().is_err()); + assert!(FileTimes { + modified: Some(FileTimestamp::Unix { + seconds: 0, + nanoseconds: 1_000_000_000, + }), + ..FileTimes::default() + } + .encode() + .is_err()); + let mut reverse_mixed = mixed; + std::mem::swap(&mut reverse_mixed.modified, &mut reverse_mixed.created); + assert!(reverse_mixed.encode().is_err()); + assert_eq!( + FileTimes::parse(3, &123u32.to_le_bytes()).unwrap().modified, + Some(FileTimestamp::Unix { + seconds: 123, + nanoseconds: 0 + }) + ); + } + + #[test] + fn exact_nanoseconds_choose_one_lossless_encoding_at_range_boundaries() { + let unix_end = i128::from(u32::MAX) * 1_000_000_000 + 999_999_999; + for value in [0, 1, unix_end] { + let times = FileTimes::from_unix_nanoseconds(Some(value), None, None).unwrap(); + assert!(matches!(times.modified, Some(FileTimestamp::Unix { .. }))); + assert_eq!(times.modified.unwrap().unix_nanoseconds(), value); + let encoded = times.encode().unwrap(); + assert_eq!( + FileTimes::parse(u64::from(encoded[0]), &encoded[1..]), + Some(times) + ); + } + let filetime_min = -11_644_473_600_000_000_000i128; + let filetime_max = (i128::from(u64::MAX) - 116_444_736_000_000_000) * 100; + for value in [filetime_min, -100, unix_end + 1, filetime_max] { + let times = FileTimes::from_unix_nanoseconds(Some(value), Some(0), None).unwrap(); + assert!(matches!( + times.modified, + Some(FileTimestamp::WindowsFiletime(_)) + )); + assert!(matches!( + times.created, + Some(FileTimestamp::WindowsFiletime(_)) + )); + assert_eq!(times.modified.unwrap().unix_nanoseconds(), value); + assert_eq!(times.created.unwrap().unix_nanoseconds(), 0); + let encoded = times.encode().unwrap(); + assert_eq!( + FileTimes::parse(u64::from(encoded[0]), &encoded[1..]), + Some(times) + ); + } + for value in [ + -1, + unix_end + 2, + filetime_min - 100, + filetime_max + 100, + i128::MIN, + i128::MAX, + ] { + assert!( + FileTimes::from_unix_nanoseconds(Some(value), None, None).is_err(), + "{value}" + ); + } + assert_eq!( + FileTimes::from_unix_nanoseconds(None, None, None).unwrap(), + FileTimes::default() + ); + } + + #[test] + fn legacy_conversion_refuses_missing_invalid_and_unix_out_of_range_dates() { + for (raw, modified) in [ + (vec![0], None), + (0x8000u16.to_le_bytes().to_vec(), None), + (0x8000u16.to_le_bytes().to_vec(), Some(0)), + (0x0800u16.to_le_bytes().to_vec(), None), + (0x9000u16.to_le_bytes().to_vec(), Some(0x5022_1882)), + ] { + assert!(FileTimes::legacy(&raw, modified).is_err()); + } + let future_dos = (127 << 25) | (1 << 21) | (1 << 16); // 2107-01-01 + let instant = crate::timestamp::extracted_system_time( + crate::ArchiveFamily::Rar15To40, + Some(future_dos), + None, + ) + .unwrap(); + assert!( + instant + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs() + > u64::from(u32::MAX) + ); + assert!(FileTimes::legacy(&0x8000u16.to_le_bytes(), Some(future_dos)).is_err()); + assert_eq!(FileTimes::legacy(&[], None).unwrap(), None); + assert!(validate_legacy_extended_times(&[0]).is_err()); + assert!(validate_legacy_extended_times(&0x0800u16.to_le_bytes()).is_err()); + assert!(validate_legacy_extended_times(&0x9000u16.to_le_bytes()).is_err()); + } + + #[test] + fn archival_time_is_preserved_natively_but_cannot_be_converted_to_rar5() { + // Legacy extended-time flags place archival time in the low nibble. + let mut raw = 0x0008u16.to_le_bytes().to_vec(); + raw.extend(0x5022_1882u32.to_le_bytes()); + validate_legacy_extended_times(&raw).unwrap(); + assert_eq!( + FileTimes::legacy(&raw, None), + Err(Error::InvalidArgument( + "legacy archival time has no supported RAR5 representation" + )) + ); + } + + #[test] + fn legacy_fractions_end_before_one_second_and_records_have_no_trailing_bytes() { + let dos = 0x5022_1882; + for (ticks, valid) in [ + (9_999_999u32, true), + (10_000_000, false), + (0xff_ffff, false), + ] { + let mut raw = 0xb000u16.to_le_bytes().to_vec(); + raw.extend_from_slice(&ticks.to_le_bytes()[..3]); + assert_eq!(validate_legacy_extended_times(&raw).is_ok(), valid); + let converted = FileTimes::legacy(&raw, Some(dos)); + assert_eq!(converted.is_ok(), valid); + if valid { + let FileTimestamp::Unix { nanoseconds, .. } = + converted.unwrap().unwrap().modified.unwrap() + else { + panic!("legacy conversion must use Unix seconds"); + }; + assert_eq!(nanoseconds, ticks * 100); + } + } + assert_eq!(FileTimes::legacy(&[0, 0], None).unwrap(), None); + assert!(FileTimes::legacy(&[0, 0, 1], None).is_err()); + assert!(validate_legacy_extended_times(&[0, 0, 1]).is_err()); + } + + #[test] + fn legacy_creation_and_access_times_keep_odd_seconds_and_fractions() { + let dos = 0x5022_1882u32; + let mut raw = 0xfb90u16.to_le_bytes().to_vec(); + raw.extend([1, 2, 3]); + raw.extend(dos.to_le_bytes()); + raw.extend([4, 5, 6]); + raw.extend(dos.to_le_bytes()); + raw.push(7); + let times = FileTimes::legacy(&raw, Some(dos)).unwrap().unwrap(); + let base = crate::timestamp::extracted_system_time( + crate::ArchiveFamily::Rar15To40, + Some(dos), + None, + ) + .unwrap() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs() as i128 + * 1_000_000_000; + assert_eq!( + times.modified.unwrap().unix_nanoseconds(), + base + 1_000_000_000 + 0x030201 * 100 + ); + assert_eq!( + times.created.unwrap().unix_nanoseconds(), + base + 0x060504 * 100 + ); + assert_eq!( + times.accessed.unwrap().unix_nanoseconds(), + base + 0x070000 * 100 + ); + raw.pop(); + assert!(FileTimes::legacy(&raw, Some(dos)).is_err()); + } +} diff --git a/arca-rar/vendor/rars/src/filename.rs b/arca-rar/vendor/rars/src/filename.rs new file mode 100644 index 00000000..71890604 --- /dev/null +++ b/arca-rar/vendor/rars/src/filename.rs @@ -0,0 +1,607 @@ +//! Conversion at the boundary between archive member names and native paths. +//! +//! Legacy byte names have no reliably inferable code page. On Unix they remain +//! bytes; Unicode legacy names have already been decoded by the format reader. +//! RAR5 archive names remain in their wire encoding in member metadata and lookup +//! APIs. Its Unix byte mapping is applied only when importing/exporting paths. + +use crate::{Error, Result}; +use std::borrow::Cow; +use std::ffi::{OsStr, OsString}; +use std::path::{Component, Path, PathBuf}; + +/// Native filename bytes on Unix, UTF-8 elsewhere. Never substitutes characters. +pub fn native_bytes(name: &OsStr) -> Result<&[u8]> { + #[cfg(unix)] + { + use std::os::unix::ffi::OsStrExt; + Ok(name.as_bytes()) + } + #[cfg(not(unix))] + { + name.to_str() + .map(str::as_bytes) + .ok_or(Error::InvalidArgument( + "native filename cannot be represented as Unicode", + )) + } +} + +/// Convert decoded filename bytes to a native name without replacement. +/// Non-Unix platforms require Unicode; an unspecified legacy code page is not +/// guessed. This function does not validate paths or decode RAR5 wire names. +pub fn native_string(name: &[u8]) -> Result { + Ok(native_str(name)?.to_os_string()) +} + +/// Borrows decoded filename bytes as a native name without replacement. +/// Like [`native_string`], this does not validate paths or decode RAR5 wire names. +pub fn native_str(name: &[u8]) -> Result<&OsStr> { + #[cfg(unix)] + { + use std::os::unix::ffi::OsStrExt; + Ok(OsStr::from_bytes(name)) + } + #[cfg(not(unix))] + { + std::str::from_utf8(name).map(OsStr::new).map_err(|_| { + Error::InvalidArgument( + "archive name requires an explicit legacy code page on this platform", + ) + }) + } +} + +/// Constructs a nonempty native relative path from already decoded name bytes. +/// +/// Callers choose whether backslashes separate components (legacy RAR) or remain +/// literal characters (RAR5 on Unix). Native platform path syntax still applies. +/// Rejects NUL, drive prefixes, roots and parent components; removes `.` and +/// repeated separators. Filename interpretation and identity preflight remain +/// separate caller policies. +pub fn relative_path(name: &[u8], backslash_separator: bool) -> Result { + if name.contains(&0) { + return Err(Error::UnsafePath("unsafe archive path contains NUL byte")); + } + let bytes = if backslash_separator && name.contains(&b'\\') { + Cow::Owned( + name.iter() + .map(|&byte| if byte == b'\\' { b'/' } else { byte }) + .collect::>(), + ) + } else { + Cow::Borrowed(name) + }; + let text = native_str(&bytes)?; + if bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':' { + return Err(Error::UnsafePath("unsafe archive path")); + } + let mut out = PathBuf::new(); + for component in Path::new(text).components() { + match component { + Component::Normal(part) => out.push(part), + Component::CurDir => {} + _ => return Err(Error::UnsafePath("unsafe archive path")), + } + } + if out.as_os_str().is_empty() { + return Err(Error::InvalidHeader("empty archive path")); + } + Ok(out) +} + +/// Joins normal relative components to a caller-selected, trusted root. +/// Rejects existing symlinks in appended components; an empty relative path +/// returns the root. This does not create or open files. Symlink checks are a +/// snapshot; callers control subsequent filesystem access and publication. +pub fn checked_output_path(root: &Path, relative: &Path) -> Result { + let mut path = root.to_path_buf(); + for component in relative.components() { + let Component::Normal(part) = component else { + return Err(Error::UnsafePath("unsafe archive path")); + }; + path.push(part); + if std::fs::symlink_metadata(&path).is_ok_and(|metadata| metadata.file_type().is_symlink()) + { + return Err(Error::UnsafePath("unsafe archive path crosses symlink")); + } + } + Ok(path) +} + +/// Encode native Unix filename bytes as a RAR5 UTF-8 name. +/// +/// Valid UTF-8 is unchanged unless it contains the reserved U+FFFE marker. +/// Otherwise high bytes are mapped to U+E080..U+E0FF with a U+FFFE marker. +/// Mapping all high bytes in this case also protects literal private-use +/// characters and literal markers from being confused with encoded bytes. +/// See . +pub fn encode_rar50(name: &[u8]) -> Cow<'_, [u8]> { + if std::str::from_utf8(name).is_ok_and(|s| !s.contains('\u{fffe}')) { + return Cow::Borrowed(name); + } + let mut out = String::from("\u{fffe}"); + for &byte in name { + out.push(if byte < 0x80 { + char::from(byte) + } else { + char::from_u32(0xe000 + u32::from(byte)).expect("mapped high byte") + }); + } + Cow::Owned(out.into_bytes()) +} + +/// Encode a renamed legacy Unicode entry without relying on a code page. +/// Full UTF-16 units make the Unicode stream independent of the ASCII fallback. +#[cfg(any(test, feature = "write"))] +pub(crate) fn encode_legacy_unicode(name: &[u8]) -> Result> { + validate_relative(name)?; + let text = std::str::from_utf8(name) + .map_err(|_| Error::InvalidArgument("renaming a Unicode entry requires a UTF-8 name"))?; + let mut raw: Vec = text + .chars() + .map(|ch| if ch.is_ascii() { ch as u8 } else { b'_' }) + .collect(); + raw.extend_from_slice(&[0, 0]); + let units: Vec = text.encode_utf16().collect(); + for group in units.chunks(4) { + raw.push(0xaa); // Four full UTF-16 commands; unused low bits are ignored. + for unit in group { + raw.extend_from_slice(&unit.to_le_bytes()); + } + } + if raw.len() > usize::from(u16::MAX) - 32 { + return Err(Error::InvalidArgument( + "legacy Unicode filename is too long", + )); + } + Ok(raw) +} + +/// Restore a RAR5 Unix mapped name to filename bytes. Call only for Unix-host +/// names when writing to a Unix filesystem. Unmarked names, including malformed +/// UTF-8 from tolerant archive readers, retain their exact bytes. +pub fn decode_rar50(name: &[u8]) -> Cow<'_, [u8]> { + let Ok(text) = std::str::from_utf8(name) else { + return Cow::Borrowed(name); + }; + if !text.contains('\u{fffe}') { + return Cow::Borrowed(name); + } + let mut out = Vec::with_capacity(name.len()); + for ch in text.chars() { + match ch { + '\u{fffe}' => {} + '\u{e080}'..='\u{e0ff}' => out.push((ch as u32 - 0xe000) as u8), + _ => out.extend_from_slice(ch.encode_utf8(&mut [0; 4]).as_bytes()), + } + } + Cow::Owned(out) +} + +/// Validate relative member identity using ASCII path syntax, independently of +/// filename encoding and of the destination filesystem. +pub(crate) fn validate_relative(name: &[u8]) -> Result<()> { + if name.contains(&0) { + return Err(Error::UnsafePath("unsafe archive path contains NUL byte")); + } + if name.first().is_some_and(|b| matches!(b, b'/' | b'\\')) + || (name.len() >= 2 && name[0].is_ascii_alphabetic() && name[1] == b':') + || name + .split(|b| matches!(b, b'/' | b'\\')) + .any(|p| p == b"..") + { + return Err(Error::UnsafePath("unsafe archive path")); + } + if name + .split(|b| matches!(b, b'/' | b'\\')) + .all(|p| p.is_empty() || p == b".") + { + return Err(Error::InvalidArgument("empty archive path")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn legacy_unicode_names_respect_the_header_length_limit() { + // ASCII fallback plus full UTF-16 units and one command per four + // units: 20154 characters produce the largest fitting field. + let name = vec![b'a'; 20_154]; + let encoded = encode_legacy_unicode(&name).unwrap(); + assert_eq!(encoded.len(), 65_503); + crate::rar15_40::validate_unicode_name(&encoded, &name).unwrap(); + let too_long = vec![b'a'; 20_155]; + assert_eq!( + encode_legacy_unicode(&too_long), + Err(Error::InvalidArgument( + "legacy Unicode filename is too long" + )), + ); + } + + #[test] + fn legacy_unicode_commands_preserve_supplementary_characters_and_group_tails() { + for name in ["a", "abcd", "abcde", "notes/🦀/é.txt"] { + let encoded = encode_legacy_unicode(name.as_bytes()).unwrap(); + crate::rar15_40::validate_unicode_name(&encoded, name.as_bytes()).unwrap(); + } + } + + #[test] + fn utf8_legacy_decoding_is_strict_for_both_valid_and_invalid_input() { + for name in ["", "é", "🦀", "a/b"] { + assert_eq!( + LegacyNameEncoding::Utf8.decode(name.as_bytes()).unwrap(), + name + ); + } + assert_eq!( + LegacyNameEncoding::Utf8.decode(&[0xff]), + Err(Error::InvalidArgument("legacy name is not valid UTF-8")), + ); + } + + #[test] + fn native_names_preserve_utf8_and_unix_legacy_bytes_without_replacement() { + let bytes = "café.txt".as_bytes(); + let borrowed = native_str(bytes).unwrap(); + assert!(std::ptr::eq( + native_bytes(borrowed).unwrap().as_ptr(), + bytes.as_ptr() + )); + let name = native_string(bytes).unwrap(); + assert_eq!(native_bytes(&name).unwrap(), bytes); + #[cfg(unix)] + { + let bytes = b"caf\xff.txt"; + let name = native_string(bytes).unwrap(); + assert_eq!(native_bytes(&name).unwrap(), bytes); + } + #[cfg(not(unix))] + assert!(native_string(b"caf\xff.txt").is_err()); + } + + #[test] + fn destination_paths_preserve_selected_separator_policy_and_error_categories() { + for separator in [false, true] { + for name in [b"a\0b".as_slice(), b"/root", b"a/../b", b"C:root"] { + assert!(matches!( + relative_path(name, separator), + Err(Error::UnsafePath(_)) + )); + } + for name in [b"".as_slice(), b".", b"././"] { + assert_eq!( + relative_path(name, separator), + Err(Error::InvalidHeader("empty archive path")) + ); + } + assert_eq!( + relative_path(b"./a//./b", separator).unwrap(), + PathBuf::from("a").join("b") + ); + } + assert_eq!( + relative_path(b"a\\b", true).unwrap(), + PathBuf::from("a").join("b") + ); + assert!(relative_path(b"a\\..\\b", true).is_err()); + #[cfg(unix)] + { + assert_eq!( + relative_path(b"..\\literal", false).unwrap(), + PathBuf::from("..\\literal") + ); + assert_eq!( + native_bytes(relative_path(b"caf\xff", false).unwrap().as_os_str()).unwrap(), + b"caf\xff" + ); + } + #[cfg(not(unix))] + assert!(relative_path(b"caf\xff", false).is_err()); + } + + #[test] + #[cfg(unix)] + fn destination_paths_refuse_link_components_and_keep_root_selection_separate() { + let root = crate::scratch::case("shared-destination-policy"); + let target = root.join("target"); + std::fs::create_dir(&target).unwrap(); + std::os::unix::fs::symlink(&target, root.join("link")).unwrap(); + assert_eq!( + checked_output_path(&root, Path::new("link/file")), + Err(Error::UnsafePath("unsafe archive path crosses symlink")) + ); + assert_eq!( + checked_output_path(&root, Path::new("link")), + Err(Error::UnsafePath("unsafe archive path crosses symlink")) + ); + for path in ["../file", "/file", "./file"] { + assert_eq!( + checked_output_path(&root, Path::new(path)), + Err(Error::UnsafePath("unsafe archive path")) + ); + } + assert_eq!( + checked_output_path(&root, Path::new("")), + Ok(root.to_path_buf()) + ); + assert_eq!( + checked_output_path(&root.join("link"), Path::new("file")), + Ok(root.join("link/file")) + ); + assert_eq!( + checked_output_path(&root, Path::new("missing/file")), + Ok(root.join("missing/file")) + ); + } + + #[test] + fn relative_names_reject_unsafe_or_empty_paths_in_both_legacy_separator_styles() { + for name in [ + b"a\0b".as_slice(), + b"/root", + b"\\root", + b"C:\\root", + b"a/../b", + b"a\\..\\b", + ] { + assert!( + matches!(validate_relative(name), Err(Error::UnsafePath(_))), + "{name:?}" + ); + } + for name in [b"".as_slice(), b".", b".//.", b".\\.\\"] { + assert_eq!( + validate_relative(name), + Err(Error::InvalidArgument("empty archive path")) + ); + } + for name in [ + b"a/b".as_slice(), + b"a\\b", + b".//a", + b"a\\.\\b", + b"legacy-\xff", + ] { + validate_relative(name).unwrap(); + } + assert!(matches!(decode_rar50(b"plain-name"), Cow::Borrowed(_))); + assert!(matches!(decode_rar50(b"bad-\xff"), Cow::Borrowed(_))); + } + + #[test] + fn rar50_mapping_is_reversible_and_does_not_alias_unicode() { + let mut bytes: Vec = (0x80..=0xff).collect(); + bytes.extend_from_slice("/日本語/\u{fffe}\u{e080}".as_bytes()); + for name in [ + bytes.as_slice(), + "literal-\u{fffe}".as_bytes(), + b"bad-\xff", + "\u{e0ff}".as_bytes(), + ] { + let encoded = encode_rar50(name); + assert!(std::str::from_utf8(&encoded).is_ok()); + assert_eq!(decode_rar50(&encoded).as_ref(), name); + } + assert_ne!( + encode_rar50(b"bad-\xff"), + encode_rar50("bad-\u{fffd}".as_bytes()) + ); + assert!(matches!( + encode_rar50("cafe\u{301}/日本語".as_bytes()), + Cow::Borrowed(_) + )); + } + + #[test] + fn rar50_mapping_accepts_reference_mixed_names_and_marker_positions() { + for encoded in ["a\u{fffe}\u{e0ff}日本語", "a\u{e0ff}日本語\u{fffe}"] { + assert_eq!( + decode_rar50(encoded.as_bytes()).as_ref(), + b"a\xff\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e" + ); + } + // Only high bytes are mapped; lower private-use characters stay Unicode. + assert_eq!( + decode_rar50("\u{fffe}\u{e02f}".as_bytes()).as_ref(), + "\u{e02f}".as_bytes() + ); + } +} + +/// Explicit source encoding for legacy names without a Unicode representation. +/// These mappings are locale independent and shared by every binding. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum LegacyNameEncoding { + Cp437, + Cp850, + Cp852, + Cp866, + Windows1251, + Windows1252, + Utf8, +} + +impl std::str::FromStr for LegacyNameEncoding { + type Err = Error; + fn from_str(value: &str) -> Result { + match value.to_ascii_lowercase().as_str() { + "cp437" => Ok(Self::Cp437), + "cp850" => Ok(Self::Cp850), + "cp852" => Ok(Self::Cp852), + "cp866" => Ok(Self::Cp866), + "cp1251" | "windows-1251" => Ok(Self::Windows1251), + "cp1252" | "windows-1252" => Ok(Self::Windows1252), + "utf8" | "utf-8" => Ok(Self::Utf8), + _ => Err(Error::InvalidArgument("unsupported legacy name encoding (use cp437, cp850, cp852, cp866, windows-1251, windows-1252 or utf-8)")), + } + } +} + +impl LegacyNameEncoding { + /// Strict decoding: undefined bytes never become replacement characters. + pub fn decode(self, name: &[u8]) -> Result { + let table = match self { + Self::Utf8 => { + return std::str::from_utf8(name) + .map(str::to_owned) + .map_err(|_| Error::InvalidArgument("legacy name is not valid UTF-8")); + } + Self::Cp437 => &CP437, + Self::Cp850 => &CP850, + Self::Cp852 => &CP852, + Self::Cp866 => &CP866, + Self::Windows1251 => &CP1251, + Self::Windows1252 => &CP1252, + }; + name.iter() + .map(|&byte| { + if byte < 128 { + Ok(char::from(byte)) + } else { + char::from_u32(u32::from(table[usize::from(byte - 128)])).ok_or( + Error::InvalidArgument("undefined byte in selected legacy name encoding"), + ) + } + }) + .collect() + } +} + +/// Interpret a legacy name without changing its stored identity. `unicode` means +/// the format already supplied Unicode, which always takes precedence. Without +/// an explicit encoding the existing bytes are returned unchanged. +pub fn decoded_name( + name: &[u8], + unicode: bool, + encoding: Option, +) -> Result> { + match encoding { + Some(encoding) if !unicode => encoding + .decode(name) + .map(|text| Cow::Owned(text.into_bytes())) + .map_err(|error| error.at_entry(name.to_vec(), "decoding legacy filename")), + _ => Ok(Cow::Borrowed(name)), + } +} + +// High-byte mappings from Python's standard-library IBM/Microsoft codec tables. +// ASCII 0..127 is unchanged. 0xD800 marks an undefined code-page byte. +const CP437: [u16; 128] = [ + 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, + 0x00ee, 0x00ec, 0x00c4, 0x00c5, 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, + 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, 0x00e1, 0x00ed, 0x00f3, 0x00fa, + 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, + 0x255d, 0x255c, 0x255b, 0x2510, 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, + 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, 0x2568, 0x2564, 0x2565, 0x2559, + 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, + 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, 0x03a6, 0x0398, 0x03a9, 0x03b4, + 0x221e, 0x03c6, 0x03b5, 0x2229, 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, + 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0, +]; +const CP850: [u16; 128] = [ + 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, + 0x00ee, 0x00ec, 0x00c4, 0x00c5, 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, + 0x00ff, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x00d7, 0x0192, 0x00e1, 0x00ed, 0x00f3, 0x00fa, + 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x00ae, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1, 0x00c2, 0x00c0, 0x00a9, 0x2563, 0x2551, 0x2557, + 0x255d, 0x00a2, 0x00a5, 0x2510, 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3, + 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4, 0x00f0, 0x00d0, 0x00ca, 0x00cb, + 0x00c8, 0x0131, 0x00cd, 0x00ce, 0x00cf, 0x2518, 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580, + 0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5, 0x00b5, 0x00fe, 0x00de, 0x00da, 0x00db, 0x00d9, + 0x00fd, 0x00dd, 0x00af, 0x00b4, 0x00ad, 0x00b1, 0x2017, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x00b8, + 0x00b0, 0x00a8, 0x00b7, 0x00b9, 0x00b3, 0x00b2, 0x25a0, 0x00a0, +]; +const CP852: [u16; 128] = [ + 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x016f, 0x0107, 0x00e7, 0x0142, 0x00eb, 0x0150, 0x0151, + 0x00ee, 0x0179, 0x00c4, 0x0106, 0x00c9, 0x0139, 0x013a, 0x00f4, 0x00f6, 0x013d, 0x013e, 0x015a, + 0x015b, 0x00d6, 0x00dc, 0x0164, 0x0165, 0x0141, 0x00d7, 0x010d, 0x00e1, 0x00ed, 0x00f3, 0x00fa, + 0x0104, 0x0105, 0x017d, 0x017e, 0x0118, 0x0119, 0x00ac, 0x017a, 0x010c, 0x015f, 0x00ab, 0x00bb, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1, 0x00c2, 0x011a, 0x015e, 0x2563, 0x2551, 0x2557, + 0x255d, 0x017b, 0x017c, 0x2510, 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x0102, 0x0103, + 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4, 0x0111, 0x0110, 0x010e, 0x00cb, + 0x010f, 0x0147, 0x00cd, 0x00ce, 0x011b, 0x2518, 0x250c, 0x2588, 0x2584, 0x0162, 0x016e, 0x2580, + 0x00d3, 0x00df, 0x00d4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161, 0x0154, 0x00da, 0x0155, 0x0170, + 0x00fd, 0x00dd, 0x0163, 0x00b4, 0x00ad, 0x02dd, 0x02db, 0x02c7, 0x02d8, 0x00a7, 0x00f7, 0x00b8, + 0x00b0, 0x00a8, 0x02d9, 0x0171, 0x0158, 0x0159, 0x25a0, 0x00a0, +]; +const CP866: [u16; 128] = [ + 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041a, 0x041b, + 0x041c, 0x041d, 0x041e, 0x041f, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, + 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, 0x0430, 0x0431, 0x0432, 0x0433, + 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, + 0x255d, 0x255c, 0x255b, 0x2510, 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, + 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, 0x2568, 0x2564, 0x2565, 0x2559, + 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, + 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044a, 0x044b, + 0x044c, 0x044d, 0x044e, 0x044f, 0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040e, 0x045e, + 0x00b0, 0x2219, 0x00b7, 0x221a, 0x2116, 0x00a4, 0x25a0, 0x00a0, +]; +const CP1251: [u16; 128] = [ + 0x0402, 0x0403, 0x201a, 0x0453, 0x201e, 0x2026, 0x2020, 0x2021, 0x20ac, 0x2030, 0x0409, 0x2039, + 0x040a, 0x040c, 0x040b, 0x040f, 0x0452, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, + 0xd800, 0x2122, 0x0459, 0x203a, 0x045a, 0x045c, 0x045b, 0x045f, 0x00a0, 0x040e, 0x045e, 0x0408, + 0x00a4, 0x0490, 0x00a6, 0x00a7, 0x0401, 0x00a9, 0x0404, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x0407, + 0x00b0, 0x00b1, 0x0406, 0x0456, 0x0491, 0x00b5, 0x00b6, 0x00b7, 0x0451, 0x2116, 0x0454, 0x00bb, + 0x0458, 0x0405, 0x0455, 0x0457, 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, + 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f, 0x0420, 0x0421, 0x0422, 0x0423, + 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, + 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, + 0x043c, 0x043d, 0x043e, 0x043f, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, + 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f, +]; +const CP1252: [u16; 128] = [ + 0x20ac, 0xd800, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0160, 0x2039, + 0x0152, 0xd800, 0x017d, 0xd800, 0xd800, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, + 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xd800, 0x017e, 0x0178, 0x00a0, 0x00a1, 0x00a2, 0x00a3, + 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, + 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, + 0x00bc, 0x00bd, 0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, + 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 0x00d0, 0x00d1, 0x00d2, 0x00d3, + 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, + 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, + 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, + 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, +]; + +#[cfg(all(test, windows))] +#[test] +fn windows_native_names_reject_unpaired_surrogates_without_replacement() { + use std::os::windows::ffi::OsStringExt; + for units in [&[0xd800][..], &[0xdc00], &[u16::from(b'a'), 0xd800]] { + let name = OsString::from_wide(units); + assert_eq!( + native_bytes(&name), + Err(Error::InvalidArgument( + "native filename cannot be represented as Unicode" + )) + ); + } + let paired = OsString::from_wide(&[0xd83d, 0xde00]); + assert_eq!(native_bytes(&paired).unwrap(), "😀".as_bytes()); +} + +/// Reject absolute paths, `..`, drive prefixes and NUL bytes without assuming +/// a filename encoding. Destination filesystem representability and RAR5 Unix +/// byte mapping are separate from archive member identity validation. +pub fn validate_entry_name(name: Vec) -> Result> { + crate::filename::validate_relative(&name)?; + Ok(name) +} + +/// The path a member name denotes below an output directory, or an error if it +/// denotes anywhere else. Backslashes are separators, because that is what a +/// DOS-era writer put in the header. On Unix non-UTF-8 bytes are preserved. +/// This is the legacy path convention, not a RAR5 wire-name decoder. +pub fn entry_relative_path(name: &[u8]) -> Result { + crate::filename::validate_relative(name)?; + relative_path(name, true) +} diff --git a/arca-rar/vendor/rars/src/filter.rs b/arca-rar/vendor/rars/src/filter.rs new file mode 100644 index 00000000..66ec0579 --- /dev/null +++ b/arca-rar/vendor/rars/src/filter.rs @@ -0,0 +1,237 @@ +//! Data filters: the reversible transforms a writer applies to a member before +//! compressing it, so the encoder sees something it can match on. +//! +//! Every RAR family that has filters at all draws from this set, but no family +//! encodes all of it. RAR 5 has four builtin filter types; the RAR 2.9 family +//! ships six filters as RarVM programs; delta and the two x86 filters are the +//! only ones common to both. Asking a writer for a filter it cannot encode is +//! rejected when the archive is written, not when the filter is named, because +//! the format is chosen at the same moment and often from the same argument. + +use std::ops::Range; + +/// A reversible transform applied to a member before it is compressed. +/// +/// Deliberately not `#[non_exhaustive]`: each format converts this into its own +/// narrower set with an exhaustive match and no wildcard arm, so an eighth +/// filter has to be decided about everywhere before the crate will build. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum FilterKind { + /// Splits the member into `channels` planes and stores each plane as + /// differences, which turns a smooth ramp into a run of near-zero bytes. + Delta { channels: usize }, + /// Rewrites x86 `E8` call targets from relative to absolute, so the same + /// call made from different places becomes the same bytes. + E8, + /// As [`FilterKind::E8`], also converting `E9` jumps. + E8E9, + /// The ARM equivalent, rewriting `BL` branch targets. + Arm, + /// The Itanium equivalent. RAR 2.9 family only. + Itanium, + /// De-interleaves `width`-byte pixels and predicts each channel from its + /// neighbours. RAR 2.9 family only. + Rgb { width: usize, pos_r: usize }, + /// Predicts each sample from the previous ones in the same channel. + /// RAR 2.9 family only. + Audio { channels: usize }, +} + +impl FilterKind { + /// What this filter is called when a writer has to refuse it. + pub const fn name(self) -> &'static str { + match self { + Self::Delta { .. } => "the delta filter", + Self::E8 => "the x86 E8 filter", + Self::E8E9 => "the x86 E8/E9 filter", + Self::Arm => "the ARM filter", + Self::Itanium => "the Itanium filter", + Self::Rgb { .. } => "the RGB filter", + Self::Audio { .. } => "the audio filter", + } + } +} + +/// A filter and the bytes it covers. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FilterSpec { + pub kind: FilterKind, + /// The bytes the filter covers. `None` covers the whole member. + pub range: Option>, +} + +impl FilterSpec { + pub const fn whole(kind: FilterKind) -> Self { + Self { kind, range: None } + } + + pub const fn range(kind: FilterKind, range: Range) -> Self { + Self { + kind, + range: Some(range), + } + } +} + +impl From for FilterSpec { + fn from(kind: FilterKind) -> Self { + Self::whole(kind) + } +} + +/// How a writer decides which filter, if any, to apply to a member. +#[derive(Debug, Clone, PartialEq, Eq, Default)] +#[non_exhaustive] +pub enum FilterPolicy { + /// Compress the member as it stands. + #[default] + None, + /// Look for a filter that makes the member compress smaller, and use one + /// only if it does. + Auto, + /// Apply this filter whether or not it pays off. + Explicit(FilterSpec), +} + +impl FilterPolicy { + /// The common case: one filter over the whole member. + pub const fn explicit(kind: FilterKind) -> Self { + Self::Explicit(FilterSpec::whole(kind)) + } +} + +impl FilterKind { + /// Whether this format's writer can encode this filter. + /// + /// Answered by the same conversions the writers use, so the question and + /// the refusal cannot disagree. + pub fn is_supported_by(self, target: crate::ArchiveVersion) -> bool { + match target.family() { + crate::version::ArchiveFamily::Rar50Plus => { + crate::codec::rar50::Rar50Filter::try_from(self).is_ok() + } + crate::version::ArchiveFamily::Rar15To40 => { + // RAR 1.5 and 2.0 predate the filter VM entirely. + !matches!( + target, + crate::ArchiveVersion::Rar15 | crate::ArchiveVersion::Rar20 + ) && crate::codec::rar29::Rar29Filter::try_from(self).is_ok() + } + crate::version::ArchiveFamily::Rar13 => false, + } + } +} + +/// Every format whose writer can encode `kind`. +pub fn formats_supporting_filter(kind: FilterKind) -> Vec { + crate::ArchiveVersion::ALL + .into_iter() + .filter(|&target| kind.is_supported_by(target)) + .collect() +} + +/// A filter the target format has no way to encode. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct UnsupportedFilterKind(pub FilterKind); + +#[cfg(test)] +mod tests { + use super::*; + use crate::codec::rar29::Rar29Filter; + use crate::codec::rar50::Rar50Filter; + + /// Exhaustive by construction: a new filter has to be added here, and the + /// two conversions below then have to say what each format does with it. + const ALL: [FilterKind; 7] = [ + FilterKind::Delta { channels: 1 }, + FilterKind::E8, + FilterKind::E8E9, + FilterKind::Arm, + FilterKind::Itanium, + FilterKind::Rgb { width: 3, pos_r: 0 }, + FilterKind::Audio { channels: 1 }, + ]; + + #[test] + fn kind_conversion_selects_the_whole_member_without_changing_parameters() { + for kind in ALL { + let spec = FilterSpec::from(kind); + assert_eq!(spec.kind, kind); + assert_eq!(spec.range, None); + } + } + + #[test] + fn every_filter_is_named_and_accepted_by_at_least_one_format() { + for kind in ALL { + assert!( + !kind.name().is_empty(), + "{kind:?} has no name to refuse it by" + ); + assert!( + Rar50Filter::try_from(kind).is_ok() || Rar29Filter::try_from(kind).is_ok(), + "{kind:?} is a filter no format can write" + ); + } + } + + /// The two families are complementary rather than nested, which is why a + /// rejection is worth naming the format that does support the filter. + #[test] + fn the_two_families_each_have_what_the_other_lacks() { + assert!(Rar50Filter::try_from(FilterKind::Arm).is_ok()); + assert!(Rar29Filter::try_from(FilterKind::Arm).is_err()); + for kind in [ + FilterKind::Itanium, + FilterKind::Rgb { width: 3, pos_r: 0 }, + FilterKind::Audio { channels: 1 }, + ] { + assert!(Rar29Filter::try_from(kind).is_ok(), "{kind:?}"); + assert_eq!( + Rar50Filter::try_from(kind), + Err(UnsupportedFilterKind(kind)), + "{kind:?}" + ); + } + } + + #[test] + fn each_filter_names_the_formats_that_can_write_it() { + use crate::ArchiveVersion; + assert_eq!( + formats_supporting_filter(FilterKind::Arm), + vec![ArchiveVersion::Rar50, ArchiveVersion::Rar70] + ); + assert_eq!( + formats_supporting_filter(FilterKind::Itanium), + vec![ + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40 + ] + ); + // Delta is the one every filtering format has. + assert_eq!( + formats_supporting_filter(FilterKind::Delta { channels: 2 }), + vec![ + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70 + ] + ); + for kind in ALL { + assert!(!formats_supporting_filter(kind).is_empty(), "{kind:?}"); + } + } + + #[test] + fn a_policy_defaults_to_leaving_the_data_alone() { + assert_eq!(FilterPolicy::default(), FilterPolicy::None); + assert_eq!( + FilterPolicy::explicit(FilterKind::E8), + FilterPolicy::Explicit(FilterSpec::whole(FilterKind::E8)) + ); + } +} diff --git a/arca-rar/vendor/rars/src/filter_search.rs b/arca-rar/vendor/rars/src/filter_search.rs new file mode 100644 index 00000000..59eef09b --- /dev/null +++ b/arca-rar/vendor/rars/src/filter_search.rs @@ -0,0 +1,2292 @@ +//! Choosing a filter for a member, for any format that has filters. +//! +//! The expensive part of picking a filter is that judging one means compressing +//! the member with it. Doing that for every filter a format offers, times every +//! region a scanner proposes, is most of the cost of writing an archive and +//! nearly all of it is spent proving that filters which were never going to help +//! do not help. +//! +//! So the candidates are cut down before any whole-member encode happens. +//! Filters with a structural detector behind them get their regions from the +//! detector and a sample encode per region to confirm the detector was not +//! fooled by chance byte patterns and to drop the regions where the filter +//! would cost more than it saves. The x86 pair detect code by its opcodes; the +//! table scanner detects arrays of fixed-size records by the stride they +//! repeat at, and its regions become ranged delta filters at the record size. +//! Filters with no detector are measured on a sample of the member and have to +//! win by a clear margin to earn a whole-member encode. What survives is a +//! handful of finalists, each encoded once at the caller's real settings, +//! smallest wins. +//! +//! The unfiltered member is always one of the finalists, so the result can never +//! be larger than leaving the data alone. + +use crate::codec::workspace::{Allowance, Budget, Buffer}; +use crate::{FilterKind, FilterSpec, Result}; +use std::ops::Range; + +/// How much of the member the screens encode when deciding whether a filter is +/// worth a whole-member encode. +const SCREEN_SAMPLE_LEN: usize = 128 * 1024; + +/// Keeps the screen sample's delta planes aligned the way they fall in the whole +/// member: the lowest common multiple of the delta widths worth trying. +const SCREEN_SAMPLE_ALIGNMENT: usize = 12; + +/// How much smaller a filter has to make the sample before it earns a +/// whole-member encode, as a percentage. +/// +/// A filter that pays off does so by a mile: delta on 16-bit audio takes 43% off +/// and on interleaved counters 96%. A sample that comes out a fraction of a +/// percent smaller is measurement noise from the shorter history, and chasing it +/// costs a whole-member encode per filter to find out. +const SCREEN_MARGIN_PERCENT: usize = 1; + +/// How much of the member x86 detection has to cover before filtering the whole +/// thing is as good as filtering only the detected regions, as a fraction. +const X86_CODE_COVERAGE_RATIO: (usize, usize) = (9, 10); + +/// How many x86 regions the progress estimate assumes the scanner will find. +/// +/// Only used to scale a progress bar, and deliberately not measured: finding out +/// means scanning the member, which is a whole extra pass to sharpen a +/// percentage. Two to five is what the binaries measured came to, with an +/// unstripped 25 MB outlier at eleven. +const X86_ASSUMED_REGIONS: u64 = 4; + +/// Bytes at each end of a member that a ranged delta filter skips, because +/// container headers and trailers are not part of the sampled signal. +pub(crate) const AUTO_DELTA_EDGE_SKIP: usize = 64; + +/// How much of the member the table scanner judges at a time. +/// +/// A window is the resolution of the region boundaries: a table loses at most +/// one window at each end. Smaller windows find smaller tables and cost more +/// scanning per member. +const TABLE_SCAN_WINDOW: usize = 16 * 1024; + +/// The widest record stride the table scanner looks for. +/// +/// This is the scanner's own ceiling, traded against what it costs: every extra +/// stride is another comparison per byte of the member. What the *format* can +/// encode is a separate question, answered by +/// [`FilterSearch::max_delta_channels`], and the scan uses whichever is lower. +const MAX_TABLE_STRIDE: usize = 32; + +/// How close a byte has to be to the one a stride back to count as part of the +/// record structure. Not just equal: a field that creeps, like an address +/// column, is exactly what delta flattens. +const TABLE_STRIDE_NEAR: u8 = 2; + +/// How much of a window has to repeat at the winning stride before the window +/// counts as table-like, as a percentage. Code and text sit well under half +/// this at every stride; an array of structs sits well over it at the record +/// size, because most fields barely change from one record to the next. +const TABLE_STRIDE_HIT_PERCENT: usize = 40; + +/// How close to the best stride's score a shorter stride has to come to be +/// preferred, as a percentage. An 8-byte record repeats at 16, 24 and 32 too, +/// and the shortest period is the record size; the tolerance keeps noise from +/// picking a harmonic. +const TABLE_STRIDE_TIE_PERCENT: usize = 95; + +/// The smallest run of table-like windows worth a filter of its own. +const MIN_TABLE_REGION: usize = 2 * TABLE_SCAN_WINDOW; + +/// How many table regions the progress estimate assumes the scanner will find. +/// +/// Same reasoning as [`X86_ASSUMED_REGIONS`], and the same refusal to go and +/// measure: the binaries this was built for have one or two, being a +/// relocation table and sometimes a symbol table beside it. +const TABLE_ASSUMED_REGIONS: u64 = 2; + +/// What a writer has to tell the search about its format. +/// +/// Implementors describe a format at fixed encoder settings and hold no state, +/// so a search can run inside a parallel per-member encode. +pub(crate) trait FilterSearch { + /// The encoder settings a candidate is measured at. Compared, so the search + /// can tell when a screen's encode is also a real measurement. + type Options: Copy + PartialEq; + + /// Every filter this format can encode that has no detector of its own, so + /// the only way to know whether it helps is to try it. Given the member, so + /// a format can drop widths that do not fit or that its own cheap + /// statistics have already ruled out. + fn screened_kinds(&self, data: &[u8]) -> Vec; + + /// Whether this format can encode the x86 filters, which come with a + /// structural detector instead of a screen. + fn detects_x86(&self) -> bool { + true + } + + /// The most channels this format's delta filter can carry. + /// + /// The table scanner picks a stride from the data rather than from + /// [`FilterSearch::screened_kinds`], so this is how a format keeps it + /// inside what the writer can encode. Deliberately has no default: a + /// format that gets this wrong proposes a filter its own writer must then + /// refuse, and there is no safe guess to make on its behalf. + fn max_delta_channels(&self) -> usize; + + /// Cheaper settings for the screens, when ranking candidates at less than + /// full effort ranks them the same way. + /// + /// Defaults to the caller's own settings, because on RAR 5 the + /// reduced-effort parse measured *slower* than the full one: weaker matches + /// mean more for the entropy coder to do. On RAR 2.9 it really is cheaper, + /// so that format overrides this. + fn screen_options(&self, options: Self::Options) -> Self::Options { + options + } + + /// Apply the filters to a copy of `data`, without encoding it. + /// + /// This is how a screen prices a filter it can only afford to try on a slice + /// of the member: compress the transformed bytes and compare against the + /// unfiltered ones. Comparing a filtered *encode* with an unfiltered one used + /// to measure something else entirely. On a 396 KB binary the 128 KiB sample + /// said the E8E9 filter cost 10% (74322 plain against 81744 filtered) while + /// the same filter was worth 7.4% of the finished archive, so every x86 + /// member was screened out before anything measured it. + /// + /// That gap was the two paths cutting blocks at different sizes, fixed in + /// 6ce759c: they now agree to within a filter token per block. So a screen + /// that can encode the whole member goes straight to + /// [`FilterSearch::encode_filtered`] and keeps the result, and this stays for + /// the case it was written for, where the sample is a slice and there is + /// nothing to keep. + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result>; + + /// Encode without filters. + /// + /// Separate from [`FilterSearch::encode_filtered`] because carrying filters + /// can force shorter blocks, so encoding an empty filter list would not + /// produce what asking for no filter produces. The search compares every + /// candidate against leaving the data alone, and that has to mean the bytes + /// the writer would really emit. + fn encode_plain( + &self, + data: &[u8], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result>; + + /// Encode with these filters applied. Never called with an empty list. + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result>; +} + +pub(crate) type FilterChoice = (Buffer, Buffer); +type Finalist = (Buffer, Option>); +type TableRegions = Buffer<(Range, usize), B>; + +/// Search owners cannot detach bounded byte storage while candidates compete. +pub(crate) trait OwnedSearch { + type Options: Copy + PartialEq; + type Memory: Budget; + fn allowance(&self) -> &Self::Memory; + fn screened_kinds(&self, data: &[u8]) -> Result>; + fn detects_x86(&self) -> bool; + fn max_delta_channels(&self) -> usize; + fn screen_options(&self, options: Self::Options) -> Self::Options; + fn filtered_bytes( + &self, + data: &[u8], + filters: &[FilterSpec], + ) -> Result>; + fn encode_plain( + &self, + data: &[u8], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result>; + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result>; +} +struct UnlimitedSearch<'a, S>(&'a S, Allowance); +impl OwnedSearch for UnlimitedSearch<'_, S> { + type Options = S::Options; + type Memory = Allowance; + fn allowance(&self) -> &Allowance { + &self.1 + } + fn screened_kinds(&self, data: &[u8]) -> Result> { + Ok(Buffer::from_vec(self.0.screened_kinds(data))) + } + fn detects_x86(&self) -> bool { + self.0.detects_x86() + } + fn max_delta_channels(&self) -> usize { + self.0.max_delta_channels() + } + fn screen_options(&self, options: Self::Options) -> Self::Options { + self.0.screen_options(options) + } + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + self.0.filtered_bytes(data, filters).map(Buffer::from_vec) + } + fn encode_plain( + &self, + data: &[u8], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + self.0 + .encode_plain(data, options, progress) + .map(Buffer::from_vec) + } + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: Self::Options, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + self.0 + .encode_filtered(data, filters, options, progress) + .map(Buffer::from_vec) + } +} + +/// Internal events: codec positions are absolute only within one encode pass. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum EncodeProgress { + PassStarted, + Advanced(usize), +} + +/// Adapt a single codec pass without inferring restarts from byte positions. +pub(crate) fn encode_pass( + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, + encode: impl FnOnce(Option<&mut dyn FnMut(usize) -> bool>) -> Result, +) -> Result { + match progress { + Some(progress) => { + if !progress(EncodeProgress::PassStarted) { + return Err(crate::Error::Cancelled); + } + encode(Some(&mut |position| { + progress(EncodeProgress::Advanced(position)) + })) + } + None => encode(None), + } +} + +/// Observe every encode in a search, including sample screens which previously +/// discarded the caller's progress/cancellation callback. The codec adapter and +/// search decisions remain unchanged. +struct ReportingSearch<'a, S> { + search: &'a S, + progress: std::cell::RefCell<&'a mut dyn FnMut(EncodeProgress) -> bool>, +} +impl OwnedSearch for ReportingSearch<'_, S> { + type Options = S::Options; + type Memory = S::Memory; + fn allowance(&self) -> &Self::Memory { + self.search.allowance() + } + fn screened_kinds(&self, data: &[u8]) -> Result> { + self.search.screened_kinds(data) + } + fn detects_x86(&self) -> bool { + self.search.detects_x86() + } + fn max_delta_channels(&self) -> usize { + self.search.max_delta_channels() + } + fn screen_options(&self, options: Self::Options) -> Self::Options { + self.search.screen_options(options) + } + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + self.search.filtered_bytes(data, filters) + } + fn encode_plain( + &self, + data: &[u8], + options: Self::Options, + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + encode_pass(Some(&mut **self.progress.borrow_mut()), |progress| { + self.search.encode_plain(data, options, progress) + }) + } + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: Self::Options, + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + encode_pass(Some(&mut **self.progress.borrow_mut()), |progress| { + self.search + .encode_filtered(data, filters, options, progress) + }) + } +} + +/// Whether looking for a filter is worth starting at all. +/// +/// An empty member has nothing to filter, and text does not benefit from any of +/// them, so neither should cost a single encode to find that out. +pub(crate) fn search_applies(data: &[u8]) -> bool { + !data.is_empty() && !is_text_like(data) +} + +fn is_text_like(data: &[u8]) -> bool { + let sample_len = data.len().min(8192); + // `search_applies` screens empty members before calling this helper. + let sample = &data[..sample_len]; + let text_bytes = sample + .iter() + .filter(|&&byte| matches!(byte, b'\t' | b'\n' | b'\r' | 0x20..=0x7e)) + .count(); + text_bytes * 100 / sample_len >= 95 +} + +fn screen_wins(filtered: usize, baseline: usize) -> bool { + filtered * 100 < baseline * (100 - SCREEN_MARGIN_PERCENT) +} + +/// A window from the middle of the member, used to screen the filters that have +/// nothing but a trial encode to go on. +fn screen_sample(data: &[u8]) -> &[u8] { + if data.len() <= SCREEN_SAMPLE_LEN { + return data; + } + let middle = (data.len() - SCREEN_SAMPLE_LEN) / 2; + let start = middle / SCREEN_SAMPLE_ALIGNMENT * SCREEN_SAMPLE_ALIGNMENT; + &data[start..start + SCREEN_SAMPLE_LEN] +} + +/// What the screen made of one filter kind. +struct ScreenedKind { + kind: FilterKind, + /// The bytes, when the screen encoded the whole member the way the writer + /// would write it, so the search can take this as its measurement. + measured: Option>, + /// Whether it beat leaving the data alone by enough to be worth spending + /// another encode on a narrower range of the same filter. + worth_a_range: bool, +} + +/// What the screen learned, along with any encodes the search can reuse. +struct ScreenOutcome { + kinds: Buffer, B>, + plain: Option>, +} + +/// Which of the detectorless filters shrink a sample of the member. +/// +/// These used to cost a whole-member encode each to prove they made the member +/// bigger, which on a binary is most of the search. Whether they help is a local +/// property of the byte layout, so a slice of the member answers it for a few +/// per cent of the price. This measures the real filter rather than a statistic +/// standing in for it, because the wins do not all show up as entropy: RAR's +/// delta reorders into planes first, and what that buys is repetition the +/// encoder can match, not a flatter byte histogram. +/// +/// A member no bigger than one sample is a special case worth taking. There is +/// no slice to approximate with, so the screen encodes it the way the writer +/// would and every number it produces is the measurement the search was going to +/// spend an encode on anyway. That skips a second encode per surviving kind, and +/// it lets kinds that win by too little to be worth chasing stay in the running, +/// because keeping a candidate the screen has already paid for costs nothing. +fn screen_kinds( + search: &S, + data: &[u8], + options: S::Options, +) -> Result> { + let sample = screen_sample(data); + let mut outcome = ScreenOutcome { + kinds: Buffer::new(search.allowance()), + plain: None, + }; + if sample.len() < SCREEN_SAMPLE_ALIGNMENT { + return Ok(outcome); + } + let screen_options = search.screen_options(options); + // Only when the screen measures at the settings the finalists will use. A + // format that screens at reduced effort, which RAR 2.9 does, is measuring + // something else and keeps the two-encode path. + let measures_the_member = sample.len() == data.len() && screen_options == options; + let baseline = search.encode_plain(sample, screen_options, None)?; + for kind in search.screened_kinds(data)? { + let filters = [FilterSpec::whole(kind)]; + let packed = if measures_the_member { + search.encode_filtered(data, &filters, options, None)? + } else { + let transformed = search.filtered_bytes(sample, &filters)?; + search.encode_plain(&transformed, screen_options, None)? + }; + let worth_a_range = screen_wins(packed.len(), baseline.len()); + if measures_the_member { + outcome.kinds.try_push(ScreenedKind { + kind, + measured: Some(packed), + worth_a_range, + })?; + } else if worth_a_range { + // The screen measured the transform, not the encode the writer + // would emit, so this is evidence for a finalist rather than a + // measurement the search can reuse. + outcome.kinds.try_push(ScreenedKind { + kind, + measured: None, + worth_a_range, + })?; + } + } + if measures_the_member { + outcome.plain = Some(baseline); + } + Ok(outcome) +} + +/// Where the scanner thinks x86 code lives, merged into disjoint regions. +fn x86_code_regions(data: &[u8], allowance: &B) -> Result, B>> { + disjoint_ranges(crate::x86_filter_scan::ranges_with_allowance( + data, true, allowance, + )?) +} + +/// Which of the scanner's regions the x86 filter should cover, empty when none +/// of them is worth filtering. +/// +/// Byte patterns that look like call opcodes turn up in compressed data by +/// chance, and the scanner cannot tell those from a real code section. A sample +/// encode inside a region separates the two for a fraction of what a +/// whole-member encode costs. +/// +/// Every region gets its own sample, because on an unstripped binary the biggest +/// region is the debug data rather than the code. Screening only the largest, as +/// this did, declined the filter on every unstripped binary measured: it read +/// DWARF, saw no win, and stopped before anything measured the member. Regions +/// are disjoint, so the samples together never come to more than the member. +/// +/// A region the filter makes bigger is dropped rather than counted against the +/// rest, which is what keeps the debug data out of the ranged candidate. On a +/// 20 MB unstripped binary that turns a filter worth 0.2% into one worth +/// 0.4%; leaving it in was worse than not filtering at all. Ties are kept: a +/// sample with no convertible opcodes in it is not evidence against the region +/// it came from. +/// +/// A kept region is then asked the second question: does leaving the jump +/// opcodes alone beat converting them as well. That decides whether the E8-only +/// filter is worth a whole-member encode of its own, and the answer is usually +/// no. Over twenty-four members it won seven times and never by more than +/// 0.21%, while carrying the pair cost a third of the search; screening it here +/// keeps the wins and spends the encode only where a sample gives a reason to. +fn x86_screened_regions( + search: &S, + data: &[u8], + regions: &[Range], + options: S::Options, +) -> Result> { + let mut kept = Buffer::new(search.allowance()); + let mut helped = false; + for region in regions { + let sample = screen_sample(&data[region.clone()]); + if sample.len() < SCREEN_SAMPLE_ALIGNMENT { + // Scanner padding makes this possible only when the entire + // member is too short to provide a useful x86 sample. + continue; + } + // Measured at the caller's real settings, not the cheaper screen ones. + // The detectorless screens rank many candidates against each other, + // where a reduced parse ranks them the same way; this is a yes or no + // with no margin under it, and a sample encode is cheap enough to get + // right. + let baseline = search.encode_plain(sample, options, None)?; + let transformed = search.filtered_bytes(sample, &[FilterSpec::whole(FilterKind::E8E9)])?; + let filtered = search.encode_plain(&transformed, options, None)?; + if filtered.len() > baseline.len() { + continue; + } + // No margin here, unlike the detectorless filters: the scanner has + // already ruled on where code is, so a small win on this sample is + // evidence rather than noise. + helped |= filtered.len() < baseline.len(); + kept.try_push((region.clone(), filtered.len()))?; + } + let rejected_a_region = kept.len() < regions.len(); + if !helped { + return Ok(X86Screen { + kept: Buffer::new(search.allowance()), + rejected_a_region: false, + jumps_cost_more: false, + }); + } + + // Held back until the regions are known to be worth filtering at all. Asking + // per region inside the loop above priced the jump opcodes on members that + // then declined every filter, which is a sample encode each for an answer + // nothing reads. + let mut jumps_cost_more = false; + for (region, e8e9) in kept.iter() { + let sample = screen_sample(&data[region.clone()]); + let e8_only = search.filtered_bytes(sample, &[FilterSpec::whole(FilterKind::E8)])?; + let e8_only = search.encode_plain(&e8_only, options, None)?; + jumps_cost_more |= e8_only.len() < *e8e9; + } + + Ok(X86Screen { + rejected_a_region, + kept: Buffer::collect( + kept.into_iter().map(|(region, _)| region), + search.allowance(), + )?, + jumps_cost_more, + }) +} + +/// What the x86 screen made of the regions the scanner proposed. +struct X86Screen { + /// The regions worth filtering, empty when none of them is. + kept: Buffer, B>, + /// Whether any region came out bigger under the filter, which rules out + /// filtering the member end to end. + rejected_a_region: bool, + /// Whether any kept region did better with the jump opcodes left alone, + /// which is the only reason to price the E8-only filter separately. A tie + /// does not count: it usually means the sample held no jump opcodes at all, + /// so it is an absence of evidence, and acting on it costs a whole-member + /// encode. + jumps_cost_more: bool, +} + +/// The x86 filter specs worth measuring against the whole member, given what the +/// screen made of the regions the scanner proposed. +/// +/// The scanner proposes overlapping regions at several clustering distances, and +/// the search this replaced priced every one of them with its own whole-member +/// encode. Measured at full effort the whole spread is worth about a third of a +/// percent, so this keeps the two that are structurally different: filter +/// everything, or filter only where the screen saw code. +/// +/// Which of the two is worth an encode is mostly already known. Filtering +/// everything covers the regions the screen rejected as well, so once it has +/// rejected one, that candidate is asking to be told again that those bytes come +/// out bigger; on all seven binaries measured the kept regions beat it. Filtering +/// only the regions is the same thing as filtering everything when they cover +/// nearly the whole member. So each case is worth one candidate per kind, not +/// two. +/// +/// And usually one kind rather than two, because the screen has already asked +/// whether the jump opcodes are worth converting. That takes an unstripped +/// binary from five whole-member encodes to two. +fn x86_finalists( + data: &[u8], + screen: &X86Screen, +) -> Result, B>> { + let allowance = screen.kept.allowance(); + let regions = &screen.kept; + let covered: usize = regions.iter().map(|range| range.len()).sum(); + let (numerator, denominator) = X86_CODE_COVERAGE_RATIO; + let sparse = covered * denominator < data.len() * numerator; + let mut finalists = Buffer::new(&allowance); + for kind in [FilterKind::E8E9, FilterKind::E8] + .into_iter() + .take(if screen.jumps_cost_more { 2 } else { 1 }) + { + if screen.rejected_a_region || sparse { + finalists.try_push(Buffer::collect( + regions + .iter() + .map(|range| FilterSpec::range(kind, range.clone())), + &allowance, + )?)?; + } + if !screen.rejected_a_region { + finalists.try_push(Buffer::collect([FilterSpec::whole(kind)], &allowance)?)?; + } + } + Ok(finalists) +} + +/// The record stride this window repeats at, when it looks like an array of +/// fixed-size records at all. +/// +/// An array of structs repeats at its record size: most fields hold the same or +/// a slowly moving value from one record to the next, so the byte one stride +/// back predicts this one. Code and text have no such period. The score is how +/// many bytes land within [`TABLE_STRIDE_NEAR`] of the byte a stride back, +/// and the shortest stride within [`TABLE_STRIDE_TIE_PERCENT`] of the best +/// wins, because a period repeats at its own multiples. +fn table_stride(window: &[u8], max_stride: usize) -> Option { + // table_regions supplies a full scan window and caps the stride, so the + // only caller-side case without a candidate is a format with no delta. + if max_stride == 0 { + return None; + } + let mut hits = [0usize; MAX_TABLE_STRIDE + 1]; + for index in max_stride..window.len() { + let byte = window[index]; + for stride in 1..=max_stride { + let diff = (byte.wrapping_sub(window[index - stride]) as i8).unsigned_abs(); + hits[stride] += usize::from(diff <= TABLE_STRIDE_NEAR); + } + } + let total = window.len() - max_stride; + let best = *hits[1..=max_stride] + .iter() + .max() + .expect("there is at least one stride"); + if best * 100 < total * TABLE_STRIDE_HIT_PERCENT { + return None; + } + (1..=max_stride).find(|&stride| hits[stride] * 100 >= best * TABLE_STRIDE_TIE_PERCENT) +} + +/// Where the member holds arrays of fixed-size records, each with the stride +/// it repeats at. +/// +/// This is what the whole-member delta screens cannot see: a relocation table +/// is a few hundred kilobytes of 24-byte records inside a binary that delta +/// with stride 24 nearly halves, while the same filter over the whole member +/// is a disaster. On a 3.6 MB shared object the table packed to 32,767 bytes +/// against 59,512 unfiltered; delta 24 over the whole member came out 85% +/// *bigger* than no filter at all. The filter has to cover the table and stop. +fn table_regions( + data: &[u8], + max_stride: usize, + allowance: &B, +) -> Result, usize), B>> { + let max_stride = max_stride.min(MAX_TABLE_STRIDE); + let mut regions: Buffer<(Range, usize), B> = Buffer::new(allowance); + for start in (0..).map(|window| window * TABLE_SCAN_WINDOW) { + let Some(window) = data.get(start..start + TABLE_SCAN_WINDOW) else { + break; + }; + let Some(stride) = table_stride(window, max_stride) else { + continue; + }; + match regions.last_mut() { + Some((last, last_stride)) if *last_stride == stride && last.end == start => { + last.end = start + TABLE_SCAN_WINDOW; + } + _ => regions.try_push((start..start + TABLE_SCAN_WINDOW, stride))?, + } + } + regions.retain(|(range, _)| range.len() >= MIN_TABLE_REGION); + Ok(regions) +} + +/// Which of the scanner's table regions the delta filter actually shrinks. +/// +/// The scanner reads byte statistics, and repetition at a stride is also +/// something the match finder can sometimes reach on its own; a run of +/// constant bytes scores as a table at every stride and needs no filter at +/// all. A sample encode inside the region separates the tables delta helps +/// from the ones LZ was already handling, the same way the x86 screen checks +/// its scanner. +fn table_screened_regions( + search: &S, + data: &[u8], + regions: &[(Range, usize)], + options: S::Options, +) -> Result> { + let screen_options = search.screen_options(options); + let mut kept = Buffer::new(search.allowance()); + for (region, stride) in regions { + let sample = screen_sample(&data[region.clone()]); + if sample.len() < SCREEN_SAMPLE_ALIGNMENT { + continue; + } + let baseline = search.encode_plain(sample, screen_options, None)?; + let filters = [FilterSpec::whole(FilterKind::Delta { channels: *stride })]; + let transformed = search.filtered_bytes(sample, &filters)?; + let filtered = search.encode_plain(&transformed, screen_options, None)?; + if screen_wins(filtered.len(), baseline.len()) { + kept.try_push((region.clone(), *stride))?; + } + } + Ok(kept) +} + +/// `range` with the `removed` ranges cut out of it. `removed` must be sorted +/// and disjoint. +fn subtract_owned( + range: Range, + removed: &[Range], + allowance: &B, +) -> Result, B>> { + let mut kept = Buffer::new(allowance); + let mut start = range.start; + for cut in removed { + if cut.end <= start { + continue; + } + if cut.start >= range.end { + break; + } + if cut.start > start { + kept.try_push(start..cut.start)?; + } + start = start.max(cut.end); + } + if start < range.end { + kept.try_push(start..range.end)?; + } + Ok(kept) +} + +/// A finalist with the screened tables riding along: the table ranges are cut +/// out of whatever the specs covered, and delta at the record stride takes +/// their place. Empty specs come out as a tables-only candidate. +/// +/// The tables win where the two overlap. A verified table stride is worth +/// tens of percent of its region where the x86 filter is worth a few. This +/// used to build one bundled candidate that competed with the x86 finalists +/// instead, and on an unstripped binary the x86-only finalist won, taking the +/// tables down with the debug data they were bundled against. Grafting the +/// tables into every finalist lets them ride with whichever x86 variant wins. +fn graft_owned( + specs: Buffer, + tables: &[(Range, usize)], + member: usize, +) -> Result> { + if tables.is_empty() { + return Ok(specs); + } + let allowance = specs.allowance(); + let table_ranges = Buffer::collect(tables.iter().map(|(range, _)| range.clone()), &allowance)?; + let mut grafted = Buffer::new(&allowance); + for spec in specs { + let covered = spec.range.clone().unwrap_or(0..member); + for range in subtract_owned(covered, &table_ranges, &allowance)? { + grafted.try_push((grafted.len(), FilterSpec::range(spec.kind, range)))?; + } + } + for (range, stride) in tables { + grafted.try_push(( + grafted.len(), + FilterSpec::range(FilterKind::Delta { channels: *stride }, range.clone()), + ))?; + } + // Explicit original order preserves stable ties without an unaccounted sort allocation. + grafted.sort_unstable_by_key(|(order, spec)| { + (spec.range.as_ref().map_or(0, |range| range.start), *order) + }); + Ok(Buffer::collect( + grafted.into_iter().map(|(_, spec)| spec), + &allowance, + )?) +} + +/// The filter specs worth measuring against the whole member, paired with the +/// bytes for any the screen already measured. +/// +/// Everything expensive happens downstream of this, one whole-member encode per +/// unmeasured finalist, so the job here is to hand back a handful rather than the +/// several dozen the scanner and the delta widths can between them suggest. +fn finalists( + search: &S, + data: &[u8], + options: S::Options, +) -> Result, S::Memory>> { + let screen = screen_kinds(search, data, options)?; + let allowance = search.allowance(); + let mut finalists = Buffer::collect([(Buffer::new(allowance), screen.plain)], allowance)?; + + let table_regions = table_regions(data, search.max_delta_channels(), allowance)?; + let tables = table_screened_regions(search, data, &table_regions, options)?; + + // The tables graft into every x86 finalist rather than competing against + // them, so when the x86 screen kept anything they cost no encode of their + // own. Only a member with tables and no code pays for a tables-only + // candidate. + let mut tables_carried = false; + if search.detects_x86() { + let screen = + x86_screened_regions(search, data, &x86_code_regions(data, allowance)?, options)?; + if !screen.kept.is_empty() { + tables_carried = !tables.is_empty(); + for specs in x86_finalists(data, &screen)? { + finalists.try_push((graft_owned(specs, &tables, data.len())?, None))?; + } + } + } + if !tables.is_empty() && !tables_carried { + finalists.try_push(( + graft_owned(Buffer::new(allowance), &tables, data.len())?, + None, + ))?; + } + + for screened in screen.kinds { + finalists.try_push(( + Buffer::collect([FilterSpec::whole(screened.kind)], allowance)?, + screened.measured, + ))?; + if let (true, FilterKind::Delta { channels }) = (screened.worth_a_range, screened.kind) { + if let Some(range) = auto_delta_filter_range(data, channels) { + finalists.try_push(( + Buffer::collect([FilterSpec::range(screened.kind, range)], allowance)?, + None, + ))?; + } + } + } + + Ok(finalists) +} + +/// The candidate filter lists, screened but not ranked. +/// +/// The screens still run: whether a filter has any chance on this member is a +/// property of the member's own bytes, and a sample answers it the same way +/// whoever is going to measure the survivors. What this hands back is the +/// ranking, for a caller whose real encoder is not the one +/// [`FilterSearch::encode_filtered`] describes. +/// +/// A solid chain is that caller. Its members code against everything before +/// them, so a candidate encoded on its own has not been measured at all, and +/// the bytes [`choose_filter`] returns are bytes the chain would never write. +pub(crate) fn filter_candidates( + search: &S, + data: &[u8], + options: S::Options, +) -> Result>> { + Ok(finalists( + &UnlimitedSearch(search, Allowance::default()), + data, + options, + )? + .into_iter() + .map(|(specs, _measured)| specs.into_vec()) + .collect()) +} + +/// Picks the filter for a member, returning the winning specs together with the +/// bytes they produced so the caller does not have to encode the winner again. +/// +/// Which filter suits a member is a property of the data, not of how hard the +/// encoder is trying, so this is worth doing once even when several encoder +/// settings are going to be compared afterwards. +pub(crate) fn choose_filter( + search: &S, + data: &[u8], + options: S::Options, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Result<(Vec, Vec)> { + choose_owned( + &UnlimitedSearch(search, Allowance::default()), + data, + options, + progress, + ) + .map(|(specs, bytes)| (specs.into_vec(), bytes.into_vec())) +} + +pub(crate) fn choose_owned( + search: &S, + data: &[u8], + options: S::Options, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Result> { + match progress { + Some(progress) => choose_filter_inner( + &ReportingSearch { + search, + progress: std::cell::RefCell::new(progress), + }, + data, + options, + ), + None => choose_filter_inner(search, data, options), + } +} + +fn choose_filter_inner( + search: &S, + data: &[u8], + options: S::Options, +) -> Result> { + let mut best: Option> = None; + for (specs, measured) in finalists(search, data, options)? { + let packed = match measured { + Some(packed) => packed, + None if specs.is_empty() => search.encode_plain(data, options, None)?, + None => search.encode_filtered(data, &specs, options, None)?, + }; + if best + .as_ref() + .is_none_or(|(_, best)| packed.len() < best.len()) + { + best = Some((specs, packed)); + } + } + Ok(best.expect("the unfiltered member is always a finalist")) +} + +/// How many bytes the encoder will walk while this search runs. +/// +/// Progress is reported by encoder position, and the search walks the member +/// several times over, so the reporter needs the total to scale by. What +/// survives the screens is not knowable without doing the work, so this assumes +/// one detectorless filter does, and that the x86 detector finds code and +/// proposes its usual pair of specs. +/// +/// Deliberately does not run the detector to find out. This is called for every +/// member before anything is compressed, and scanning here only to scan again +/// inside the search cost a second pass over the member to sharpen a percentage. +/// A progress bar that finishes a little early or a little late is not worth +/// that. +pub(crate) fn walk_bytes_for_kinds(data: &[u8], screened: u64, encoder_candidates: usize) -> u64 { + let member = data.len() as u64; + let encoder_candidates = encoder_candidates.max(1) as u64; + let sample = screen_sample(data).len() as u64; + // Two sample encodes per region for the x86 screen, and the two specs it + // proposes when the detector does find code. How many regions there are is + // not knowable without scanning, so this assumes [`X86_ASSUMED_REGIONS`], + // bounded by the member: the regions are disjoint, so however many the + // scanner finds, their samples together cannot come to more than that. + let x86_screen = (sample * X86_ASSUMED_REGIONS).min(member) * 2; + let x86_finalists = 2; + // And two more per table region, on the same assumption and with the same + // bound. Tables graft into the x86 finalists rather than earning an encode + // of their own, and this already assumes the detector finds code, so they + // add nothing beyond their screens here. + let table_screen = (sample * TABLE_ASSUMED_REGIONS).min(member) * 2; + let screen = sample * (screened + 1) + x86_screen + table_screen; + // The unfiltered member, the x86 finalists, and one assumed screen + // survivor. When the sample is the whole member the screen encodes it the + // way the writer would, so the unfiltered member and the survivor are + // already counted in `screen`. That reads the sample rather than asking + // whether this format screens at full effort, which needs the caller's + // settings; RAR 5 is the only format that reports progress through here + // and it always does. + let finalists = if sample == member { + x86_finalists + } else { + 2 + x86_finalists + }; + screen + member * (finalists + encoder_candidates - 1) +} + +/// The bytes a ranged delta filter covers: the member minus its edges, trimmed +/// so the planes stay aligned. +pub(crate) fn auto_delta_filter_range(data: &[u8], channels: usize) -> Option> { + if channels == 0 || data.len() <= AUTO_DELTA_EDGE_SKIP * 2 + channels * 8 { + return None; + } + let start = AUTO_DELTA_EDGE_SKIP; + let end = data.len() - AUTO_DELTA_EDGE_SKIP; + let aligned_start = start + ((channels - start % channels) % channels); + let aligned_end = end - (end - aligned_start) % channels; + (aligned_start + channels * 8 <= aligned_end).then_some(aligned_start..aligned_end) +} + +/// Merges overlapping and touching ranges. +/// +/// Merging rather than dropping: two ranges that overlap describe one region, +/// and keeping only the first loses coverage of the rest of it. +#[cfg(test)] +pub(crate) fn disjoint_filter_ranges(ranges: Vec>) -> Vec> { + disjoint_ranges(Buffer::from_vec(ranges)) + .expect("unlimited ranges") + .into_vec() +} +fn disjoint_ranges( + mut ranges: Buffer, B>, +) -> Result, B>> { + ranges.sort_unstable_by_key(|range| (range.start, range.end)); + let mut disjoint: Buffer, B> = Buffer::new(&ranges.allowance()); + for range in ranges { + if let Some(last) = disjoint.last_mut() { + if range.start <= last.end { + last.end = last.end.max(range.end); + continue; + } + } + disjoint.try_push(range)?; + } + Ok(disjoint) +} + +#[cfg(test)] +mod tests { + fn screen_kinds( + search: &S, + data: &[u8], + options: S::Options, + ) -> Result> { + super::screen_kinds( + &UnlimitedSearch(search, Allowance::default()), + data, + options, + ) + } + fn x86_code_regions(data: &[u8]) -> Vec> { + super::x86_code_regions(data, &Allowance::default()) + .unwrap() + .into_vec() + } + fn x86_screened_regions( + search: &S, + data: &[u8], + regions: &[Range], + options: S::Options, + ) -> Result> { + super::x86_screened_regions( + &UnlimitedSearch(search, Allowance::default()), + data, + regions, + options, + ) + } + fn x86_finalists(data: &[u8], screen: &X86Screen) -> Vec> { + super::x86_finalists(data, screen) + .unwrap() + .into_iter() + .map(Buffer::into_vec) + .collect() + } + fn delta_table_regions(data: &[u8], max_stride: usize) -> Vec<(Range, usize)> { + table_regions(data, max_stride, &Allowance::default()) + .unwrap() + .into_vec() + } + fn table_screened_regions( + search: &S, + data: &[u8], + regions: &[(Range, usize)], + options: S::Options, + ) -> Result, usize)>> { + super::table_screened_regions( + &UnlimitedSearch(search, Allowance::default()), + data, + regions, + options, + ) + } + fn subtract_ranges(range: Range, removed: &[Range]) -> Vec> { + subtract_owned(range, removed, &Allowance::default()) + .unwrap() + .into_vec() + } + fn graft_tables( + specs: Vec, + tables: &[(Range, usize)], + member: usize, + ) -> Vec { + graft_owned(Buffer::from_vec(specs), tables, member) + .unwrap() + .into_vec() + } + + #[test] + fn search_reports_each_sample_pass_and_can_cancel_during_screening() { + use std::cell::RefCell; + struct CountingSearch(RefCell>); + impl FilterSearch for CountingSearch { + type Options = (); + fn screened_kinds(&self, _: &[u8]) -> Vec { + vec![FilterKind::Delta { channels: 1 }] + } + fn detects_x86(&self) -> bool { + false + } + fn max_delta_channels(&self) -> usize { + 1 + } + fn filtered_bytes(&self, data: &[u8], _: &[FilterSpec]) -> Result> { + Ok(data.to_vec()) + } + fn encode_plain( + &self, + data: &[u8], + _: (), + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + self.0.borrow_mut().push(data.len()); + // Short codec passes may report only their final position. + if progress.is_some_and(|report| !report(data.len())) { + return Err(crate::Error::Cancelled); + } + Ok(vec![0; 10]) + } + fn encode_filtered( + &self, + data: &[u8], + _: &[FilterSpec], + options: (), + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + self.encode_plain(data, options, progress) + } + } + let data = vec![0; SCREEN_SAMPLE_LEN * 2]; + let search = CountingSearch(RefCell::new(Vec::new())); + let mut events = Vec::new(); + let observed = choose_filter( + &search, + &data, + (), + Some(&mut |event| { + events.push(event); + true + }), + ) + .unwrap(); + let calls = search.0.borrow().clone(); + assert!(calls.len() >= 3); + assert!(calls[..calls.len() - 1] + .iter() + .all(|&len| len == SCREEN_SAMPLE_LEN)); + assert_eq!(calls.last(), Some(&data.len())); + assert_eq!( + events, + calls + .iter() + .flat_map(|&len| [EncodeProgress::PassStarted, EncodeProgress::Advanced(len)]) + .collect::>() + ); + assert_eq!(observed, choose_filter(&search, &data, (), None).unwrap()); + search.0.borrow_mut().clear(); + assert_eq!( + choose_filter( + &search, + &data, + (), + Some(&mut |event| matches!(event, EncodeProgress::PassStarted)) + ), + Err(crate::Error::Cancelled) + ); + assert_eq!(*search.0.borrow(), [SCREEN_SAMPLE_LEN]); + } + + use super::*; + use crate::codec::rar50::{ + encode_lz_member_with_options, encode_lz_member_with_options_and_progress, EncodeOptions, + Unpack50Encoder, + }; + + /// A stand-in format that measures candidates the way RAR 5 does. The + /// driver is generic, but it still has to be exercised against a real + /// encoder for the screens to mean anything. + #[derive(Clone, Copy)] + struct TestSearch { + cheap_screens: bool, + } + + impl FilterSearch for TestSearch { + type Options = EncodeOptions; + + fn screened_kinds(&self, _data: &[u8]) -> Vec { + vec![ + FilterKind::Arm, + FilterKind::Delta { channels: 1 }, + FilterKind::Delta { channels: 2 }, + FilterKind::Delta { channels: 3 }, + FilterKind::Delta { channels: 4 }, + ] + } + + fn max_delta_channels(&self) -> usize { + crate::codec::rar50::MAX_DELTA_CHANNELS + } + + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + crate::codec::rar50::filtered_lz_member(data, filters) + .map(|(filtered, _)| filtered) + .map_err(crate::Error::from) + } + + fn screen_options(&self, options: EncodeOptions) -> EncodeOptions { + if self.cheap_screens { + EncodeOptions::new(4).with_max_match_distance(options.max_match_distance) + } else { + options + } + } + + fn encode_plain( + &self, + data: &[u8], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + match progress { + Some(progress) => { + encode_lz_member_with_options_and_progress(data, 0, options, progress) + } + None => encode_lz_member_with_options(data, 0, options), + } + .map_err(crate::Error::from) + } + + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: EncodeOptions, + _progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Unpack50Encoder::with_options(options) + .encode_member_with_filters(data, 0, filters) + .map_err(crate::Error::from) + } + } + + const FULL: TestSearch = TestSearch { + cheap_screens: false, + }; + + #[test] + fn tiny_scanner_regions_do_not_trigger_sample_encodes() { + let data = b"abcdefgh"; + let region = 0..data.len(); + let x86 = + x86_screened_regions(&FULL, data, std::slice::from_ref(®ion), options()).unwrap(); + assert!(x86.kept.is_empty()); + assert!(!x86.rejected_a_region); + let tables = table_screened_regions(&FULL, data, &[(0..data.len(), 1)], options()).unwrap(); + assert!(tables.is_empty()); + assert!(auto_delta_filter_range(data, 0).is_none()); + assert!(!search_applies(b"")); + } + + fn options() -> EncodeOptions { + EncodeOptions::new(64).with_max_match_distance(128 * 1024) + } + + /// Interleaved counters: RAR's delta reorders them into planes of near + /// constants, which is a huge win the byte histogram cannot see. + fn interleaved_counters() -> Vec { + let mut data = Vec::new(); + for index in 0..20_000u32 { + data.push(0xe8); + data.extend_from_slice(&index.to_le_bytes()); + data.extend_from_slice(b"\x55\x89\xe5"); + } + data + } + + fn incompressible(len: usize) -> Vec { + let mut state = 0x2545_f491_4f6c_dd1du64; + std::iter::repeat_with(|| { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + state as u8 + }) + .take(len) + .collect() + } + + #[test] + fn the_screen_keeps_a_delta_width_that_pays_off() { + let kinds: Vec<_> = screen_kinds(&FULL, &interleaved_counters(), options()) + .unwrap() + .kinds + .into_iter() + .map(|screened| screened.kind) + .collect(); + assert!( + kinds.contains(&FilterKind::Delta { channels: 4 }), + "delta 4 turns this into planes of constants, so it has to survive: {kinds:?}" + ); + } + + #[test] + fn the_screen_rejects_filters_on_incompressible_data() { + assert!( + screen_kinds(&FULL, &incompressible(400_000), options()) + .unwrap() + .kinds + .is_empty(), + "nothing helps random bytes, and finding that out must not cost whole-member encodes" + ); + } + + /// A member that fits in one sample has no slice to approximate with, so + /// the screen encodes it the way the writer would and the search keeps every + /// number rather than paying for the winners twice. + #[test] + fn a_short_member_is_measured_by_the_screen_rather_than_encoded_twice() { + let data = interleaved_counters()[..100_000].to_vec(); + assert!(data.len() <= SCREEN_SAMPLE_LEN); + let screen = screen_kinds(&FULL, &data, options()).unwrap(); + + assert!(screen.plain.is_some(), "the unfiltered encode is reusable"); + assert_eq!( + screen.kinds.len(), + FULL.screened_kinds(&data).len(), + "a kind the screen has already encoded is worth keeping whether or \ + not it won by the margin" + ); + for screened in screen.kinds.iter() { + let measured = screened + .measured + .as_ref() + .unwrap_or_else(|| panic!("{:?} came back without its bytes", screened.kind)); + // Not just present: the same bytes the writer would emit for it. + // Anything else is a number the search cannot stand on. + let written = FULL + .encode_filtered(&data, &[FilterSpec::whole(screened.kind)], options(), None) + .unwrap(); + assert_eq!(*measured, written, "{:?}", screened.kind); + } + } + + /// A screen run at cheaper settings measured something the finalists will + /// not be measured at, so it cannot stand in for a real measurement even + /// when the sample happens to be the whole member. + #[test] + fn cheaper_screens_are_not_reused_as_measurements() { + let data = interleaved_counters()[..100_000].to_vec(); + let cheap = TestSearch { + cheap_screens: true, + }; + let screen = screen_kinds(&cheap, &data, options()).unwrap(); + assert!(screen.plain.is_none()); + assert!(screen + .kinds + .iter() + .all(|screened| screened.measured.is_none())); + } + + /// A member big enough that the screens have to sample it, with a filter in + /// it worth finding. The call targets here are absolute rather than + /// relative, so it is the delta filter that pays off on it, not the x86 + /// one; see [`calls_to_fixed_addresses`] for code shaped the way the x86 + /// filter wants. + fn x86_like(len: usize) -> Vec { + let mut state = 0x2545_f491u32; + let mut data = Vec::with_capacity(len); + while data.len() < len { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + if state.is_multiple_of(11) { + // A call to one of a few fixed addresses, which the filter turns + // into a handful of repeated relative offsets. + let target = 0x4000u32 + (state >> 28) * 0x400; + data.push(0xe8); + data.extend_from_slice(&target.to_le_bytes()); + } else { + data.extend_from_slice(&[0x48, 0x89, (state >> 16) as u8, 0xe5]); + } + } + data.truncate(len); + data + } + + /// The search has to end up with the filter when one plainly helps. + #[test] + fn the_screen_finds_a_filter_worth_having_on_a_sampled_member() { + let data = x86_like(SCREEN_SAMPLE_LEN * 4); + let (specs, packed) = choose_filter(&FULL, &data, options(), None).unwrap(); + let plain = FULL.encode_plain(&data, options(), None).unwrap(); + + assert!( + !specs.is_empty(), + "the search left the filter on the table: {} against {} unfiltered", + packed.len(), + plain.len() + ); + assert!(packed.len() < plain.len()); + } + + /// Calls to a handful of fixed addresses, in bodies that repeat. Unfiltered + /// the call breaks every repeat, because the displacement counts from wherever + /// the call sits; converted to an absolute address the bodies match each + /// other again. That is what the x86 filter is for, and it is why a stretch + /// of real code screens as a win. + fn calls_to_fixed_addresses(len: usize) -> Vec { + const BODIES: [[u8; 11]; 4] = [ + [ + 0x55, 0x48, 0x89, 0xe5, 0x48, 0x83, 0xec, 0x20, 0x89, 0x7d, 0xfc, + ], + [ + 0x48, 0x8b, 0x45, 0xf8, 0x48, 0x8b, 0x00, 0x48, 0x89, 0xc7, 0x90, + ], + [ + 0x8b, 0x45, 0xfc, 0x83, 0xc0, 0x01, 0x89, 0x45, 0xfc, 0x66, 0x90, + ], + [ + 0x48, 0x8d, 0x35, 0x00, 0x00, 0x00, 0x00, 0x31, 0xc0, 0x0f, 0x1f, + ], + ]; + let mut state = 0x2545_f491u32; + let mut data = Vec::with_capacity(len); + while data.len() < len { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + data.extend_from_slice(&BODIES[(state >> 28) as usize % BODIES.len()]); + // Far enough ahead that the address stays in the range the filter + // converts however the member is sliced. + let target = 0x0010_0000u32 + ((state >> 24) & 7) * 0x400; + let call_end = (data.len() + 5) as u32; + data.push(0xe8); + data.extend_from_slice(&target.wrapping_sub(call_end).to_le_bytes()); + } + data.truncate(len); + data + } + + /// Debug data: strings and symbol names, with enough stray call opcodes in + /// the numbers between them for the scanner to call it code. + /// + /// The numbers behind those opcodes repeat, so converting them by position + /// is the wrong way round: it turns a handful of repeated values into a + /// different one every time and costs the encoder the matches. That is why + /// filtering a whole unstripped binary makes it bigger. + fn debug_like(len: usize) -> Vec { + const WORDS: [&[u8]; 6] = [ + b"_ZN4llvm12FunctionPassE", + b"/usr/include/c++/14/bits/", + b"DW_AT_decl_file", + b"unsigned long long int", + b"__gnu_cxx::__normal_iterator", + b"DW_TAG_subprogram", + ]; + let mut state = 0x9e37_79b9u32; + let mut data = Vec::with_capacity(len); + while data.len() < len { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + if state.is_multiple_of(37) { + data.push(0xe8); + data.extend_from_slice( + &(0x0004_0000u32 + ((state >> 20) & 3) * 0x40).to_le_bytes(), + ); + } else { + data.extend_from_slice(WORDS[(state >> 28) as usize % WORDS.len()]); + data.push(0); + data.extend_from_slice(&state.rotate_left(7).to_le_bytes()); + } + } + data.truncate(len); + data + } + + /// An unstripped binary in miniature: a code section, then a debug section + /// several times its size that carries enough stray call opcodes to look + /// like code to the scanner. Returns the member and where the code ends. + fn code_then_debug() -> (Vec, usize) { + let code_len = 132 * 1024; + // Wider than the scanner's clustering gap, so the two stay separate + // regions rather than merging into one. + let gap = 48 * 1024; + let mut data = calls_to_fixed_addresses(code_len); + data.resize(code_len + gap, 0x5a); + data.extend_from_slice(&debug_like(220 * 1024)); + (data, code_len) + } + + /// The screen has to look past the biggest region. On an unstripped binary + /// the biggest thing the scanner calls code is the debug data, and sampling + /// only that declined the filter on every unstripped binary measured. + #[test] + fn the_x86_screen_looks_past_the_largest_region_to_the_code() { + let (data, code_len) = code_then_debug(); + let regions = x86_code_regions(&data); + let largest = regions + .iter() + .max_by_key(|range| range.len()) + .expect("the scanner has to find something"); + assert!( + largest.start >= code_len, + "this proves nothing unless the debug section is the largest region: {regions:?}" + ); + + let screen = x86_screened_regions(&FULL, &data, ®ions, options()).unwrap(); + assert_eq!( + screen.kept.len(), + 1, + "the code region is the only one worth filtering: {:?}", + screen.kept + ); + assert!( + screen.kept[0].end <= code_len + 1024, + "kept {:?}", + screen.kept + ); + assert!(screen.rejected_a_region); + } + + #[test] + fn x86_region_scan_releases_all_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + + let data = calls_to_fixed_addresses(256 * 1024); + let baseline = RefusingBudget::new(usize::MAX); + let regions = super::x86_code_regions(&data, &baseline).unwrap(); + assert!(!regions.is_empty()); + drop(regions); + assert_eq!(baseline.used(), 0); + assert!(baseline.attempts() > 0); + + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + super::x86_code_regions(&data, &budget).unwrap_err(), + crate::Error::Cancelled, + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + #[test] + fn x86_candidate_construction_releases_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + + let run = |budget: &RefusingBudget| -> Result<()> { + let screen = X86Screen { + rejected_a_region: true, + kept: Buffer::collect(std::iter::once(0..3), budget)?, + jumps_cost_more: true, + }; + let finalists = super::x86_finalists(&[0; 100], &screen)?; + assert_eq!(finalists.len(), 2); + assert!(finalists.iter().all(|specs| specs.len() == 1)); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + run(&budget), + Err(crate::Error::Cancelled), + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + #[test] + fn table_grafting_releases_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + + let run = |budget: &RefusingBudget| -> Result<()> { + let specs = Buffer::collect([FilterSpec::whole(FilterKind::E8E9)], budget)?; + let grafted = super::graft_owned(specs, &[(20..40, 2)], 100)?; + assert_eq!(grafted.len(), 3); + assert_eq!(grafted[0].range, Some(0..20)); + assert_eq!(grafted[1].range, Some(20..40)); + assert_eq!(grafted[2].range, Some(40..100)); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + run(&budget), + Err(crate::Error::Cancelled), + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + #[test] + fn candidate_search_preserves_codec_cancellation() { + struct CancelledCodec; + + impl FilterSearch for CancelledCodec { + type Options = (); + + fn screened_kinds(&self, _: &[u8]) -> Vec { + Vec::new() + } + + fn detects_x86(&self) -> bool { + false + } + + fn max_delta_channels(&self) -> usize { + 0 + } + + fn filtered_bytes(&self, _: &[u8], _: &[FilterSpec]) -> Result> { + unreachable!("no filters are proposed") + } + + fn encode_plain( + &self, + _: &[u8], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Err(crate::Error::Cancelled) + } + + fn encode_filtered( + &self, + _: &[u8], + _: &[FilterSpec], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + unreachable!("no filters are proposed") + } + } + + assert_eq!( + filter_candidates(&CancelledCodec, b"binary\0member", ()), + Err(crate::Error::Cancelled) + ); + } + + #[test] + fn bounded_delta_finalists_release_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + + struct DeltaSearch(RefusingBudget); + impl OwnedSearch for DeltaSearch { + type Options = (); + type Memory = RefusingBudget; + + fn allowance(&self) -> &Self::Memory { + &self.0 + } + fn screened_kinds(&self, _: &[u8]) -> Result> { + Ok(Buffer::collect( + [1, 2, 3].map(|channels| FilterKind::Delta { channels }), + &self.0, + )?) + } + fn detects_x86(&self) -> bool { + false + } + fn max_delta_channels(&self) -> usize { + 0 + } + fn screen_options(&self, options: ()) { + options + } + fn filtered_bytes( + &self, + _: &[u8], + _: &[FilterSpec], + ) -> Result> { + unreachable!("the whole member is measured directly") + } + fn encode_plain( + &self, + _: &[u8], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Ok(Buffer::collect([0; 10], &self.0)?) + } + fn encode_filtered( + &self, + _: &[u8], + _: &[FilterSpec], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Ok(Buffer::collect([0], &self.0)?) + } + } + + let run = |budget: &RefusingBudget| -> Result<()> { + let finalists = super::finalists(&DeltaSearch(budget.clone()), &[0; 512], ())?; + assert_eq!(finalists.len(), 7); + assert!(finalists[1].0[0].range.is_none()); + assert!(finalists[2].0[0].range.is_some()); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + run(&budget), + Err(crate::Error::Cancelled), + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + #[test] + fn x86_screen_releases_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + use std::cell::Cell; + + struct ScreenSearch { + budget: RefusingBudget, + encodes: Cell, + } + impl OwnedSearch for ScreenSearch { + type Options = (); + type Memory = RefusingBudget; + + fn allowance(&self) -> &Self::Memory { + &self.budget + } + fn screened_kinds(&self, _: &[u8]) -> Result> { + Ok(Buffer::new(&self.budget)) + } + fn detects_x86(&self) -> bool { + true + } + fn max_delta_channels(&self) -> usize { + 0 + } + fn screen_options(&self, options: ()) { + options + } + fn filtered_bytes( + &self, + data: &[u8], + _: &[FilterSpec], + ) -> Result> { + Ok(Buffer::collect(data.iter().copied(), &self.budget)?) + } + fn encode_plain( + &self, + _: &[u8], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + let pass = self.encodes.get(); + self.encodes.set(pass + 1); + let size = [10, 5, 6][pass]; + Ok(Buffer::collect(std::iter::repeat_n(0, size), &self.budget)?) + } + fn encode_filtered( + &self, + _: &[u8], + _: &[FilterSpec], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + unreachable!("the x86 screen encodes filtered bytes as plain data") + } + } + + let run = |budget: &RefusingBudget| -> Result<()> { + let search = ScreenSearch { + budget: budget.clone(), + encodes: Cell::new(0), + }; + let region = 0..64; + let result = + super::x86_screened_regions(&search, &[0; 64], std::slice::from_ref(®ion), ())?; + assert_eq!(result.kept.len(), 1); + assert!(!result.jumps_cost_more); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + run(&budget), + Err(crate::Error::Cancelled), + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + #[test] + fn table_only_candidate_releases_storage_on_each_admission_failure() { + use crate::codec::workspace::RefusingBudget; + + struct TableSearch(RefusingBudget); + impl OwnedSearch for TableSearch { + type Options = (); + type Memory = RefusingBudget; + + fn allowance(&self) -> &Self::Memory { + &self.0 + } + fn screened_kinds(&self, _: &[u8]) -> Result> { + Ok(Buffer::new(&self.0)) + } + fn detects_x86(&self) -> bool { + false + } + fn max_delta_channels(&self) -> usize { + MAX_TABLE_STRIDE + } + fn screen_options(&self, options: ()) { + options + } + fn filtered_bytes( + &self, + _: &[u8], + _: &[FilterSpec], + ) -> Result> { + Ok(Buffer::collect([0], &self.0)?) + } + fn encode_plain( + &self, + data: &[u8], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + let size = if data.len() == 1 { 1 } else { 10 }; + Ok(Buffer::collect(std::iter::repeat_n(0, size), &self.0)?) + } + fn encode_filtered( + &self, + _: &[u8], + _: &[FilterSpec], + _: (), + _: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + unreachable!("the candidate search only screens the table") + } + } + + let data = reloc_table(2048); + let run = |budget: &RefusingBudget| -> Result<()> { + let finalists = super::finalists(&TableSearch(budget.clone()), &data, ())?; + assert_eq!(finalists.len(), 2); + assert!(matches!( + &finalists[1].0[..], + [FilterSpec { + kind: FilterKind::Delta { channels: 24 }, + range: Some(_), + }] + )); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + assert_eq!( + run(&budget), + Err(crate::Error::Cancelled), + "admission {index}" + ); + assert_eq!(budget.used(), 0, "admission {index}"); + } + } + + /// The E8-only filter costs a whole-member encode to ask whether leaving + /// the jump opcodes alone packs better. Over twenty-four members it won + /// seven times and never by more than 0.21%, so it only earns that encode + /// when a sample says it might. + #[test] + fn the_jump_opcodes_are_priced_on_a_sample_before_they_earn_an_encode() { + let (data, _) = code_then_debug(); + let regions = x86_code_regions(&data); + let screen = x86_screened_regions(&FULL, &data, ®ions, options()).unwrap(); + let kinds: Vec<_> = x86_finalists(&data, &screen) + .iter() + .map(|specs| specs[0].kind) + .collect(); + + // Every call here goes to a fixed address, which is what the jump + // conversion is for, so this member is one where converting both pays. + assert!(!screen.jumps_cost_more, "{kinds:?}"); + assert_eq!( + kinds, + [FilterKind::E8E9], + "the E8-only candidate cost an encode nothing asked for" + ); + } + + #[test] + fn dense_x86_code_uses_a_whole_member_finalist() { + let data = calls_to_fixed_addresses(256 * 1024); + let regions = x86_code_regions(&data); + let screen = x86_screened_regions(&FULL, &data, ®ions, options()).unwrap(); + assert!(!screen.rejected_a_region, "{regions:?}"); + let finalists = x86_finalists(&data, &screen); + assert!(!finalists.is_empty()); + assert!(finalists + .iter() + .all(|specs| specs.iter().all(|spec| spec.range.is_none()))); + } + + #[test] + fn sparse_x86_code_prices_region_and_whole_member_finalists() { + let code = calls_to_fixed_addresses(32 * 1024); + let mut data = code.clone(); + data.resize(512 * 1024, 0); + let regions = x86_code_regions(&data); + let screen = x86_screened_regions(&FULL, &data, ®ions, options()).unwrap(); + assert_eq!(screen.kept.len(), 1, "{regions:?}"); + assert!(!screen.rejected_a_region); + let finalists = x86_finalists(&data, &screen); + assert!(finalists + .iter() + .any(|specs| specs.iter().all(|spec| spec.range.is_some()))); + assert!(finalists + .iter() + .any(|specs| specs.iter().all(|spec| spec.range.is_none()))); + } + + /// And the member as a whole has to come out smaller for it. + #[test] + fn the_search_filters_the_code_in_an_unstripped_binary() { + let (data, _) = code_then_debug(); + let plain = FULL.encode_plain(&data, options(), None).unwrap(); + let (specs, packed) = choose_filter(&FULL, &data, options(), None).unwrap(); + + assert!( + matches!( + specs.as_slice(), + [FilterSpec { + kind: FilterKind::E8E9 | FilterKind::E8, + range: Some(_) + }] + ), + "expected a ranged x86 filter, got {specs:?} at {} against {} unfiltered", + packed.len(), + plain.len() + ); + assert!(packed.len() * 100 < plain.len() * 97); + } + + /// A relocation table in miniature: 24-byte records of three 8-byte fields + /// that creep or repeat from one record to the next. What makes it a filter + /// case is that the creeping fields never repeat exactly, so the match + /// finder gets nothing, while their stride-24 differences are constants. + fn reloc_table(records: usize) -> Vec { + let mut data = Vec::with_capacity(records * 24); + for index in 0..records as u64 { + data.extend_from_slice(&(0x7f80_1234_0000 + index * 24).to_le_bytes()); + data.extend_from_slice(&0x0102_0304_0506_0708u64.to_le_bytes()); + data.extend_from_slice(&(0x4455_6677_0000 | ((index * 7) & 0xffff)).to_le_bytes()); + } + data + } + + #[test] + fn a_struct_table_scans_as_its_record_stride() { + let data = reloc_table(20_000); + let regions = delta_table_regions(&data, MAX_TABLE_STRIDE); + assert_eq!(regions.len(), 1, "{regions:?}"); + let (region, stride) = ®ions[0]; + assert_eq!(*stride, 24, "the record size is the shortest true period"); + assert!( + region.len() * 10 >= data.len() * 9, + "the region has to cover the table: {region:?} of {}", + data.len() + ); + } + + #[test] + fn a_table_without_code_gets_its_own_filter_candidate() { + let mut data = reloc_table(2048); + for byte in &mut data { + if matches!(*byte, 0xe8 | 0xe9) { + *byte = 0xe7; + } + } + assert!(x86_code_regions(&data).is_empty()); + let candidates = filter_candidates(&FULL, &data, options()).unwrap(); + assert!(candidates.iter().any(|specs| matches!( + specs.as_slice(), + [FilterSpec { + kind: FilterKind::Delta { channels: 24 }, + range: Some(_), + }] + ))); + } + + #[test] + fn adjacent_struct_tables_with_different_record_sizes_stay_separate() { + let mut data = reloc_table(4096); + let boundary = data.len(); + for index in 0..8192u64 { + data.extend_from_slice(&(0x7f80_1234_0000 + index * 8).to_le_bytes()); + } + let regions = delta_table_regions(&data, MAX_TABLE_STRIDE); + assert_eq!(regions.len(), 2, "{regions:?}"); + assert_eq!(regions[0].1, 24); + assert_eq!(regions[1].1, 8); + assert_eq!(regions[0].0.end, boundary); + assert_eq!(regions[1].0.start, boundary); + } + + #[test] + fn matching_table_strides_do_not_merge_across_a_non_table_gap() { + let mut data = reloc_table(4096); + let first_end = data.len(); + data.extend(incompressible(2 * TABLE_SCAN_WINDOW)); + let second_start = data.len(); + data.extend(reloc_table(4096)); + let regions = delta_table_regions(&data, MAX_TABLE_STRIDE); + assert_eq!(regions.len(), 2, "{regions:?}"); + assert_eq!(regions[0], (0..first_end, 24)); + assert_eq!(regions[1], (second_start..data.len(), 24)); + } + + #[test] + fn text_and_random_bytes_do_not_scan_as_tables() { + for data in [ + b"the quick brown fox jumps over the lazy dog ".repeat(6_000), + incompressible(256 * 1024), + ] { + assert_eq!( + delta_table_regions(&data, MAX_TABLE_STRIDE), + vec![], + "{} bytes", + data.len() + ); + } + } + + /// x86 instructions are variable length, so code has no byte period for the + /// scanner to lock onto. [`calls_to_fixed_addresses`] is no use for proving + /// that: it emits a fixed 16-byte unit, which really is a record array as + /// far as any stride test can tell. This mixes instruction lengths the way + /// a compiler does, so a false table here would be a false table on a real + /// `.text`. + fn variable_length_code(len: usize) -> Vec { + const INSTRUCTIONS: [&[u8]; 7] = [ + &[0x55], // push rbp + &[0x48, 0x89, 0xe5], // mov rbp, rsp + &[0x8b, 0x45, 0xfc], // mov eax, [rbp-4] + &[0x48, 0x83, 0xec, 0x20], // sub rsp, 32 + &[0x0f, 0xb6, 0x54, 0x18, 0x01], // movzx edx, [rax+rbx+1] + &[0x48, 0x8d, 0x35, 0x12, 0x00, 0x00, 0x00], // lea rsi, [rip+18] + &[0x66, 0x0f, 0x1f, 0x84, 0x00, 0, 0, 0, 0], // nop word [rax+rax] + ]; + let mut state = 0x2545_f491u32; + let mut data = Vec::with_capacity(len); + while data.len() < len { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + data.extend_from_slice(INSTRUCTIONS[(state >> 27) as usize % INSTRUCTIONS.len()]); + } + data.truncate(len); + data + } + + #[test] + fn real_shaped_code_does_not_scan_as_a_table() { + let data = variable_length_code(256 * 1024); + assert_eq!( + delta_table_regions(&data, MAX_TABLE_STRIDE), + vec![], + "variable-length instructions have no record stride to find" + ); + } + + /// And the property that actually matters: even where the scanner does fire + /// on code, nothing reaches the encoder unless a sample encode agrees. + #[test] + fn code_never_reaches_the_encoder_as_a_delta_candidate() { + for data in [ + variable_length_code(256 * 1024), + calls_to_fixed_addresses(256 * 1024), + ] { + let regions = delta_table_regions(&data, MAX_TABLE_STRIDE); + assert_eq!( + table_screened_regions(&FULL, &data, ®ions, options()).unwrap(), + vec![], + "the screen let a delta filter onto code: {regions:?}" + ); + } + } + + /// A format that cannot encode a wide delta must never be handed one. The + /// scan is bounded by what the writer can say, not only by the data. + #[test] + fn the_scan_stays_inside_what_the_format_can_encode() { + let data = reloc_table(20_000); + assert_eq!(delta_table_regions(&data, MAX_TABLE_STRIDE)[0].1, 24); + for (region, stride) in delta_table_regions(&data, 8) { + assert!(stride <= 8, "{region:?} asked for {stride} channels"); + } + assert_eq!(delta_table_regions(&data, 0), vec![]); + } + + /// Constant bytes repeat at every stride, so the scanner calls them a + /// table, but the encoder handles a run perfectly well on its own. The + /// sample encode is what stops a useless filter there. + #[test] + fn a_run_of_constant_bytes_screens_out_of_the_table_regions() { + let data = vec![0u8; 200 * 1024]; + let regions = delta_table_regions(&data, MAX_TABLE_STRIDE); + assert!(!regions.is_empty(), "the scanner sees repetition in a run"); + assert_eq!( + table_screened_regions(&FULL, &data, ®ions, options()).unwrap(), + vec![] + ); + } + + #[test] + fn subtracting_ranges_cuts_the_tables_out_of_the_code() { + assert_eq!( + subtract_ranges(0..1000, &[200..300, 600..700]), + vec![0..200, 300..600, 700..1000] + ); + assert_eq!( + subtract_ranges(100..200, &[0..250, 300..400]), + Vec::>::new() + ); + assert_eq!( + subtract_ranges(100..200, &[0..50, 300..400]), + vec![100..200] + ); + assert_eq!( + subtract_ranges(100..200, &[150..400, 500..600]), + vec![100..150] + ); + } + + /// The point of the whole scanner: a binary with a table in it comes out + /// with delta at the record stride over the table, and only there. + #[test] + fn the_search_deltas_the_table_inside_a_binary() { + let code_len = 132 * 1024; + let mut data = calls_to_fixed_addresses(code_len); + let table_start = data.len(); + data.extend_from_slice(&reloc_table(20_000)); + + let plain = FULL.encode_plain(&data, options(), None).unwrap(); + let (specs, packed) = choose_filter(&FULL, &data, options(), None).unwrap(); + + let delta = specs + .iter() + .find(|spec| matches!(spec.kind, FilterKind::Delta { channels: 24 })) + .unwrap_or_else(|| panic!("no stride-24 delta among {specs:?}")); + let range = delta.range.clone().expect("the table filter is ranged"); + assert!( + range.start >= table_start.saturating_sub(TABLE_SCAN_WINDOW) + && range.start < table_start + TABLE_SCAN_WINDOW, + "the filter starts at the table, not the code: {range:?} against {table_start}" + ); + for spec in &specs { + let other = spec.range.clone().expect("every spec here is ranged"); + assert!( + spec == delta || other.end <= range.start || other.start >= range.end, + "{specs:?} overlap" + ); + } + assert!( + packed.len() * 100 < plain.len() * 90, + "the table filter is worth a lot more than this: {} against {}", + packed.len(), + plain.len() + ); + } + + #[test] + fn grafting_cuts_the_tables_out_of_whatever_the_specs_covered() { + let tables = [(200..300, 24), (600..700, 8)]; + assert_eq!( + graft_tables(vec![FilterSpec::whole(FilterKind::E8E9)], &tables, 1000), + vec![ + FilterSpec::range(FilterKind::E8E9, 0..200), + FilterSpec::range(FilterKind::Delta { channels: 24 }, 200..300), + FilterSpec::range(FilterKind::E8E9, 300..600), + FilterSpec::range(FilterKind::Delta { channels: 8 }, 600..700), + FilterSpec::range(FilterKind::E8E9, 700..1000), + ] + ); + assert_eq!( + graft_tables(Vec::new(), &tables[..1], 1000), + vec![FilterSpec::range( + FilterKind::Delta { channels: 24 }, + 200..300 + )] + ); + let code_only = vec![FilterSpec::range(FilterKind::E8, 0..100)]; + assert_eq!(graft_tables(code_only.clone(), &[], 1000), code_only); + } + + /// The member this change exists for: an unstripped binary with a + /// relocation table in it. The bundled candidate this replaces lost to the + /// x86-only finalist here, because it carried the tables and the trimmed + /// code coverage as one bet, and the table went unfiltered with it. + #[test] + fn the_winner_filters_the_code_and_deltas_the_table_in_one_member() { + let (mut data, code_len) = code_then_debug(); + let table_start = data.len(); + data.extend_from_slice(&reloc_table(20_000)); + + let (specs, _) = choose_filter(&FULL, &data, options(), None).unwrap(); + let filters_the_code = specs.iter().any(|spec| { + matches!(spec.kind, FilterKind::E8 | FilterKind::E8E9) + && spec + .range + .as_ref() + .is_some_and(|range| range.start < code_len) + }); + let deltas_the_table = specs.iter().any(|spec| { + matches!(spec.kind, FilterKind::Delta { channels: 24 }) + && spec + .range + .as_ref() + .is_some_and(|range| range.start >= table_start - TABLE_SCAN_WINDOW) + }); + assert!( + filters_the_code && deltas_the_table, + "one of the two regions went unfiltered: {specs:?}" + ); + } + + #[test] + fn the_search_never_loses_to_no_filter() { + for data in [ + interleaved_counters(), + b"the quick brown fox ".repeat(20_000), + (0..300_000u32).map(|index| (index / 3) as u8).collect(), + incompressible(200_000), + ] { + let plain = FULL.encode_plain(&data, options(), None).unwrap(); + let (specs, packed) = choose_filter(&FULL, &data, options(), None).unwrap(); + assert!( + packed.len() <= plain.len(), + "{specs:?} came out at {} against {} unfiltered", + packed.len(), + plain.len() + ); + } + } + + #[test] + fn the_screen_sample_sits_in_the_middle_and_keeps_delta_planes_aligned() { + let data = vec![0u8; 5 * SCREEN_SAMPLE_LEN + 7]; + let sample = screen_sample(&data); + assert_eq!(sample.len(), SCREEN_SAMPLE_LEN); + let start = sample.as_ptr() as usize - data.as_ptr() as usize; + assert_eq!(start % SCREEN_SAMPLE_ALIGNMENT, 0); + assert!(start > 0 && start + sample.len() < data.len()); + } + + #[test] + fn a_ranged_delta_filter_skips_container_edges_and_aligns_planes() { + let data = vec![0u8; 512]; + let range = auto_delta_filter_range(&data, 3).unwrap(); + + assert!(range.start >= AUTO_DELTA_EDGE_SKIP); + assert!(range.end <= data.len() - AUTO_DELTA_EDGE_SKIP); + assert_eq!(range.start % 3, 0); + assert_eq!((range.end - range.start) % 3, 0); + assert!(auto_delta_filter_range(&data[..80], 3).is_none()); + } + + /// Two ranges describing one region must come out as one range. Dropping + /// the second instead, which one copy of this used to do, loses coverage of + /// everything past the overlap. + #[test] + fn overlapping_ranges_merge_rather_than_drop() { + assert_eq!( + disjoint_filter_ranges(vec![0..100, 50..200, 400..500]), + vec![0..200, 400..500] + ); + assert_eq!(disjoint_filter_ranges(vec![0..100, 100..200]), vec![0..200]); + } +} diff --git a/arca-rar/vendor/rars/src/io_util.rs b/arca-rar/vendor/rars/src/io_util.rs new file mode 100644 index 00000000..80950d83 --- /dev/null +++ b/arca-rar/vendor/rars/src/io_util.rs @@ -0,0 +1,33 @@ +use crate::{Error, Result}; +use std::io::{Read, Seek, SeekFrom}; + +pub(crate) fn read_exact_at( + file: &mut (impl Read + Seek), + offset: usize, + len: usize, +) -> Result> { + file.seek(SeekFrom::Start(offset as u64))?; + let mut data = vec![0; len]; + file.read_exact(&mut data)?; + Ok(data) +} + +pub(crate) fn read_u16(input: &[u8], offset: usize) -> Result { + let end = offset.checked_add(2).ok_or(Error::TooShort)?; + let bytes = input.get(offset..end).ok_or(Error::TooShort)?; + Ok(u16::from_le_bytes([bytes[0], bytes[1]])) +} + +pub(crate) fn read_u32(input: &[u8], offset: usize) -> Result { + let end = offset.checked_add(4).ok_or(Error::TooShort)?; + let bytes = input.get(offset..end).ok_or(Error::TooShort)?; + Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])) +} + +#[cfg(feature = "encryption")] +pub(crate) fn align16(value: usize, overflow_message: &'static str) -> Result { + value + .checked_add(15) + .map(|value| value & !15) + .ok_or(Error::InvalidHeader(overflow_message)) +} diff --git a/arca-rar/vendor/rars/src/lib.rs b/arca-rar/vendor/rars/src/lib.rs new file mode 100644 index 00000000..c3efb74b --- /dev/null +++ b/arca-rar/vendor/rars/src/lib.rs @@ -0,0 +1,5822 @@ +//! High-level RAR archive API. +//! +//! This crate is the supported public Rust API for `rars`. It is the facade +//! over the version-specific format modules, detects archive families, exposes +//! common member metadata, and streams extraction or recovery output to +//! caller-provided writers without requiring callers to buffer whole archives +//! in memory. New Rust users should depend on this crate rather than the +//! lower-level `rars-*` implementation crates, which ended at 0.3.x. +//! +//! All capabilities are enabled by default. Set `default-features = false` for +//! sequential parsing and decoding without encoders, recovery algorithms, crypto +//! dependencies or Rayon. Select `write`, `recovery`, `encryption` and `parallel` +//! independently as needed. Encrypted writing needs `write` and `encryption`; +//! writing recovery records needs `write` and `recovery`. Recovery repair does +//! not require `write`. Unavailable encrypted or recovery operations report +//! [`Error::FeatureDisabled`], while metadata remains readable where the format +//! permits it. Buffered extraction falls back to sequential execution without +//! `parallel`, and on bare WebAssembly. + +/// Where the unit tests write their files. Shared with the integration tests +/// by path rather than by API. +#[cfg(test)] +#[path = "../tests/support/scratch.rs"] +mod scratch; + +#[cfg(test)] +mod test_features; + +#[cfg(all(test, feature = "write", feature = "encryption"))] +#[path = "../tests/support/read_errors.rs"] +mod read_errors; + +mod atomic64; +#[cfg(feature = "write")] +pub mod builder; +#[doc(hidden)] +pub mod codec; +pub mod crc32; +#[doc(hidden)] +pub mod crypto; +pub mod detect; +#[cfg(any(feature = "write", all(feature = "recovery", feature = "encryption")))] +mod entropy; +pub mod error; +pub mod features; +pub mod filename; +pub mod filter; +#[cfg(feature = "write")] +mod filter_search; +mod io_util; +mod member; +pub use member::{ArchiveIndex, ArchiveMemberRef, ArchiveMemberRefs}; +mod member_read; +pub use member_read::{read_volume_members_at, read_volume_members_at_with_options}; +mod output_limit; +mod parallel; +mod parse_budget; +#[cfg(any(feature = "write", feature = "recovery"))] +mod pending_archive; +#[cfg(any(feature = "write", feature = "recovery"))] +mod progress; +mod read_control; +pub use read_control::ReadCancellation; +mod extraction_control; +mod file_times; +pub mod rar13; +pub mod rar15_40; +pub mod rar50; +mod reader_scratch; +#[doc(hidden)] +pub mod recovery; +#[cfg(feature = "write")] +mod rewrite; +#[cfg(feature = "write")] +mod rewrite_staging; +#[cfg(feature = "write")] +pub use rewrite_staging::RewriteStaging; +mod source; +#[cfg(feature = "write")] +mod streaming; +mod temp_file; +pub mod timestamp; +pub use file_times::{FileTimes, FileTimestamp}; +mod tzif; +pub mod version; +mod volume_extract; +#[cfg(feature = "write")] +pub mod write_plan; +#[cfg(feature = "write")] +mod write_progress; +mod writer_option; +pub use writer_option::WriterOption; +#[cfg(feature = "write")] +mod write_stream; +#[cfg(feature = "write")] +mod x86_filter_scan; + +#[cfg(feature = "write")] +pub use builder::Builder; +pub use detect::{detect_archive_family, find_archive_start, ArchiveSignature, SFX_SCAN_LIMIT}; +pub use error::{Error, ErrorKind, Result}; +pub use extraction_control::{ExtractionDecision, ExtractionErrorAction, ExtractionOutcome}; +pub use features::{Feature, FeatureSet}; +pub use filename::{entry_relative_path, validate_entry_name}; +pub use filter::{ + formats_supporting_filter, FilterKind, FilterPolicy, FilterSpec, UnsupportedFilterKind, +}; +#[cfg(any(feature = "write", feature = "recovery"))] +pub use progress::{WriteOperation, WriteProgress, WriteProgressEvent}; +pub use reader_scratch::Rar50Scratch; +use std::io::{Read, Write}; +use std::path::Path; +#[cfg(feature = "write")] +pub use streaming::output::{WriterOutput, WriterVolumes}; +#[cfg(feature = "write")] +pub use streaming::{ + EntryReader, EntrySource, WriteCancellation, WriterResources, DEFAULT_WRITER_MEMORY_LIMIT, +}; +pub use timestamp::StoredTimestamp; +pub use version::{ArchiveFamily, ArchiveVersion}; +#[cfg(feature = "write")] +pub use write_plan::{formats_supporting, supported_features, supports, MemberCoding, PlanShape}; + +#[derive(Debug, Clone, Copy, Default)] +#[non_exhaustive] +/// Options used while parsing archives, extracting members, decoding comments or repairing. +pub struct ArchiveReadOptions<'a> { + /// Filename interpretation for application display/path adapters. Parsing and + /// core extraction callbacks retain original names; use `filename::decoded_name`. + pub legacy_name_encoding: Option, + /// Password bytes used for encrypted headers or payloads. + pub password: Option<&'a [u8]>, + /// Cooperative cancellation for this parsing, extraction or repair call. Parsing + /// does not retain the token for later extraction. A cancelled token stays + /// cancelled; use a new token for a new operation. Partial output may remain. + /// Blocked caller I/O and indivisible library work cannot be preempted. + pub cancellation: Option<&'a ReadCancellation>, + /// Inclusive top-level header count for one physical archive parse. + /// Counts main, encryption, file/directory, service, unknown and end headers; + /// standalone signatures/markers and nested records are not separate headers. + /// None preserves defaults; zero refuses even an empty archive's main header. + /// Each parsing call (including each independently parsed volume) starts fresh. + /// Extraction does not apply this policy retroactively. + pub max_header_count: Option, + /// Inclusive cumulative plaintext header bytes for one physical archive parse. + /// Includes CRC/size fields, names and extras; nested records count once in + /// their enclosing header. Excludes payloads, SFX and standalone signatures, + /// and encryption salt/IV/padding. RAR1.3's embedded signature counts as part + /// of its main header. Encrypted sizes require first-block decryption. + /// + /// Admission precedes full-header allocation; bounded prefixes and encryption + /// framing can consume additional space. This is not a total RAM/CPU limit: + /// source copies, metadata overhead and key derivation are outside the quota. + /// None preserves defaults; zero refuses the main header. Resets per parse, + /// not across a caller's separately parsed volume set. No partial Archive is + /// returned on refusal. Existing end-record and tolerant-tail handling stays. + pub max_header_bytes: Option, + /// Optional RAR 5 whole-member buffered decode limit, including logical + /// members split across volumes. This does not bound decoder dictionaries. + /// + /// Compressed members above this limit use the streaming path. Without + /// `rar50_scratch`, filtered streams return a typed buffered-decode-limit + /// error. With scratch enabled, member bytes and filter records live on disk + /// and each filter uses the scratch policy's separate workspace limit. + pub rar50_buffered_decode_limit: Option, + /// Optional disk-backed decoding above the whole-member buffering threshold. + /// Uses separate scratch-disk and filter-workspace quotas; it does not bound + /// dictionaries or aggregate process RAM. Scratch-backed members publish only + /// after integrity verification and parallel entry points run sequentially. + pub rar50_scratch: Option<&'a Rar50Scratch>, + /// Inclusive ceiling on a compressed RAR5/7 member's declared dictionary size. + /// `None` leaves dictionary sizes unrestricted; zero rejects compressed members. + /// Stored entries, directories and redirections are exempt. This is not a + /// total-memory budget: history copies, buffered output and parallel jobs + /// consume additional memory. + /// + /// Supply this option to extraction, including volume extraction. Parsing + /// does not retain it. Options-aware comment decoding also applies it. + /// Legacy formats, recovery helpers and direct + /// codec calls are outside its scope. Earlier members may already be emitted + /// when a later member exceeds the limit; its output callback is not opened. + pub rar50_dictionary_size_limit: Option, + /// Inclusive logical member output ceiling for every archive family, independent of RAM usage. + /// None preserves defaults; zero permits empty output. Apply to extraction, + /// not parsing. Known oversized members and unsupported unknown-size members + /// are refused before opening output. Runtime failures can leave partial output. + /// The ceiling resets per logical member, not per volume fragment. Discarding + /// a solid member's bytes does not exempt it; retries and history copies are + /// not counted twice. Direct codecs, password-only default wrappers and + /// recovery helpers are outside this explicit policy. Options-aware comment + /// decoding treats the archive comment as one logical member. + pub max_member_output_bytes: Option, + /// Inclusive total logical output ceiling for one extraction call, across + /// all members and volumes. Counts bytes accepted by output writers, including + /// discarded solid contents; retries and history copies do not count twice. + /// None preserves defaults; zero permits empty output. Known sizes are + /// admitted before opening output; unknown-size logical members are refused. + /// Errors can leave earlier output and a failing member's prefix. + /// Short writes charge only accepted bytes; refused chunks need not fill + /// the remaining allowance. A per-member refusal takes precedence when both + /// output ceilings reject the same admission or write. Separate extraction + /// calls, including calls for nested archives, do not share this budget. + /// + /// Configuring this option makes parallel entry points extract sequentially + /// for deterministic admission and accounting. This can reduce throughput. + /// It is not a CPU/RAM budget: buffered decoding can precede the output guard. + /// Parsing does not retain policy; password-only wrappers, direct codecs and + /// recovery helpers keep defaults. Each extraction starts a new budget. + /// Options-aware comment decoding starts a separate single-comment budget. + pub max_total_output_bytes: Option, + /// Aggregate capacity ceiling for reader-owned payload workspace in one + /// extraction or options-aware comment call, across all members and volumes. + /// Includes decoder/model state, packed and cipher staging, filter scratch, + /// checkpoints, split cursors and queued parallel results. None is unlimited. + /// Capacity growth charges old and replacement allocations while both live. + /// Parsed archive/source storage, metadata, caller sinks and collected final + /// output, allocator overhead and executor/control storage are excluded. + /// This is not a process RAM limit. Parsing and direct codecs do not apply it. + /// Parallel jobs receive fixed allowances before dispatch; a worker cannot + /// borrow a sibling's spare. Insufficient allowance returns ResourceLimit; + /// increase the limit or use sequential extraction. Partial output can remain. + pub max_reader_workspace_bytes: Option, +} + +impl<'a> ArchiveReadOptions<'a> { + /// Uses a shared cancellation signal without retaining policy in the archive. + pub fn with_cancellation(mut self, token: &'a ReadCancellation) -> Self { + self.cancellation = Some(token); + self + } + + pub(crate) fn check_cancelled(&self) -> Result<()> { + if self + .cancellation + .is_some_and(ReadCancellation::is_cancelled) + { + return Err(Error::Cancelled); + } + Ok(()) + } + /// Creates read options without a password. + pub fn new() -> Self { + Self::default() + } + + /// Sets the top-level header ceiling for each physical archive parse. + pub fn with_max_header_count(mut self, limit: u64) -> Self { + self.max_header_count = Some(limit); + self + } + + /// Sets the cumulative plaintext-header byte ceiling for each parse. + pub fn with_max_header_bytes(mut self, limit: u64) -> Self { + self.max_header_bytes = Some(limit); + self + } + + /// Creates read options with a password. + pub fn with_password(password: &'a [u8]) -> Self { + Self { + password: Some(password), + ..Self::default() + } + } + + /// Creates read options with an optional password. + pub fn with_optional_password(password: Option<&'a [u8]>) -> Self { + Self { + password, + ..Self::default() + } + } + + /// Sets the aggregate reader workspace capacity ceiling for each call. + pub fn with_max_reader_workspace_bytes(mut self, limit: u64) -> Self { + self.max_reader_workspace_bytes = Some(limit); + self + } + + /// Sets the logical member output ceiling. + pub fn with_max_member_output_bytes(mut self, limit: u64) -> Self { + self.max_member_output_bytes = Some(limit); + self + } + + /// Sets the total logical output ceiling and selects sequential extraction. + pub fn with_max_total_output_bytes(mut self, limit: u64) -> Self { + self.max_total_output_bytes = Some(limit); + self + } + + /// Sets the RAR5/7 declared dictionary-size ceiling for member extraction. + pub fn with_rar50_dictionary_size_limit(mut self, limit: u64) -> Self { + self.rar50_dictionary_size_limit = Some(limit); + self + } + + /// Sets the RAR 5 whole-member buffered decode limit. + pub fn with_rar50_buffered_decode_limit(mut self, limit: u64) -> Self { + self.rar50_buffered_decode_limit = Some(limit); + self + } + + /// Enables caller-configured disk scratch for large RAR5/7 members. + pub fn with_rar50_scratch(mut self, scratch: &'a Rar50Scratch) -> Self { + self.rar50_scratch = Some(scratch); + self + } +} + +#[derive(Debug, Clone)] +#[non_exhaustive] +/// A parsed RAR archive, preserving the concrete archive family. +pub enum Archive { + /// RAR 1.3/1.4 archive. + Rar13(rar13::Archive), + /// RAR 1.5 through RAR 4.x archive. + Rar15To40(rar15_40::Archive), + /// RAR 5.0 or later archive, including RAR 7 archives. + Rar50Plus(rar50::Archive), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +/// Metadata supplied to extraction and verification callbacks. +pub struct ExtractedEntryMeta { + /// The format supplied Unicode; legacy encoding overrides must not apply. + pub name_is_unicode: bool, + /// Raw entry name bytes as stored by the archive family. + pub name: Vec, + /// Stored modification time: DOS/FAT for legacy RAR, Unix seconds for RAR5. + /// `None` means absent; `Some(0)` is a valid RAR5 Unix epoch timestamp. + pub file_time: Option, + /// File attributes widened to a common integer type, exactly as stored. + pub file_attr: u64, + /// How to read `file_attr`, from the host OS the entry records. + pub attr_source: AttrSource, + /// Detail `file_time` is too coarse to hold, when the archive carries it. + pub mtime_refinement: Option, + /// Whether the entry is a directory. + pub is_directory: bool, +} + +impl ExtractedEntryMeta { + /// Creates common metadata for extraction callbacks. + /// Pass `None` for an absent timestamp; a numeric value means it is present. + pub fn new( + name: Vec, + file_time: impl Into>, + file_attr: u64, + is_directory: bool, + ) -> Self { + Self { + name_is_unicode: false, + name, + file_time: file_time.into(), + file_attr, + attr_source: AttrSource::Unknown, + mtime_refinement: None, + is_directory, + } + } + + /// Records how `file_attr` should be read. + #[must_use] + pub fn with_attr_source(mut self, attr_source: AttrSource) -> Self { + self.attr_source = attr_source; + self + } + + /// Records detail `file_time` is too coarse to hold. + #[must_use] + pub fn with_mtime_refinement(mut self, refinement: Option) -> Self { + self.mtime_refinement = refinement; + self + } + + /// Raw entry name bytes as stored by the archive family. + pub fn name_bytes(&self) -> &[u8] { + &self.name + } + + /// Returns the entry name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + String::from_utf8_lossy(&self.name).into_owned() + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +/// Common member view plus family-specific detail. +pub struct ArchiveMember { + /// Metadata shared across archive families. + pub meta: ArchiveMemberMeta, + /// Extra metadata that is meaningful only for one archive family. + pub detail: ArchiveMemberDetail, +} + +impl ArchiveMember { + /// Whether this member declares a dependency on preceding decoded history. + /// RAR 1.3 has no member-level solid flag; consult its archive main header. + pub fn is_solid(&self) -> bool { + match &self.detail { + ArchiveMemberDetail::Rar15To40 { solid, .. } => *solid, + ArchiveMemberDetail::Rar50Plus { + compression_info, .. + } => compression_info & 0x40 != 0, + ArchiveMemberDetail::Rar13 { .. } => false, + } + } + + /// Name interpretation for display or destination adapters. Stored bytes and + /// rewrite identity remain unchanged; Unicode metadata takes precedence. + pub fn decoded_name( + &self, + encoding: Option, + ) -> Result> { + filename::decoded_name(&self.meta.name, self.name_is_unicode(), encoding) + } + + /// Whether the format supplied Unicode rather than unspecified legacy bytes. + pub fn name_is_unicode(&self) -> bool { + match &self.detail { + ArchiveMemberDetail::Rar13 { .. } => false, + ArchiveMemberDetail::Rar15To40 { unicode_name, .. } => unicode_name.is_some(), + _ => true, + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +/// Family-independent metadata for a file-like archive member. +pub struct ArchiveMemberMeta { + /// Archive family that produced this member. + pub family: ArchiveFamily, + /// Raw entry name bytes as stored by the archive. + pub name: Vec, + /// Packed payload size in bytes. + pub packed_size: u64, + /// Unpacked file size in bytes. + pub unpacked_size: u64, + /// DOS local wall-clock fields for RAR 1.3-4.x, or Unix seconds for RAR5. + /// RAR5 includes the extended modification-time fallback; `None` is distinct + /// from an explicitly stored Unix epoch (`Some(0)`). + pub file_time: Option, + /// Odd-second and subsecond detail, kept separate from the raw time field. + pub mtime_refinement: Option, + /// File attributes widened to a common integer type. + pub file_attr: u64, + /// Host OS discriminator when present in the archive format. + pub host_os: Option, + /// Whether the member is a directory. + pub is_directory: bool, + /// Whether the member carries a RAR5 link or other redirection record. + pub is_redirection: bool, + /// Whether the member payload is encrypted. + pub is_encrypted: bool, + /// Whether the member payload is stored without compression. + pub is_stored: bool, + /// Whether the member continues from a previous volume. + pub is_split_before: bool, + /// Whether the member continues into the next volume. + pub is_split_after: bool, +} + +impl ArchiveMemberMeta { + /// Stored modification time with its encoding attached, before refinements. + /// + /// Legacy DOS values remain local wall-clock fields; RAR5 values are Unix + /// seconds, including the existing extended-time fallback. This accessor + /// does not validate or reinterpret the raw value. Absence stays `None`, + /// and odd-second/subsecond detail remains in `mtime_refinement`. + pub fn stored_modification_time(&self) -> Option { + self.file_time + .map(|raw| StoredTimestamp::from_family(self.family, raw)) + } + + /// Modification time as an instant. Legacy DOS values use the same local + /// zone and refinement policy as CLI extraction; RAR5 values are absolute. + pub fn modification_time(&self) -> Option { + let raw = self.file_time?; + if self.family == ArchiveFamily::Rar50Plus { + let nanos = self.mtime_refinement.map_or(0, |detail| detail.nanoseconds); + return std::time::UNIX_EPOCH + .checked_add(std::time::Duration::new(u64::from(raw), nanos)); + } + timestamp::extracted_system_time(self.family, Some(raw), self.mtime_refinement) + } + + /// How to interpret this member's attributes, using the archive family's + /// host numbering and the same compatibility rules as extraction. + pub fn attr_source(&self) -> AttrSource { + match self.family { + ArchiveFamily::Rar13 => AttrSource::Dos, + ArchiveFamily::Rar15To40 => self + .host_os + .and_then(|host| u8::try_from(host).ok()) + .map(AttrSource::rar15_40) + .unwrap_or_default(), + ArchiveFamily::Rar50Plus => self.host_os.map(AttrSource::rar50).unwrap_or_default(), + } + } + + /// Raw member name bytes as stored by the archive family. + pub fn name_bytes(&self) -> &[u8] { + &self.name + } + + /// Returns the member name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + String::from_utf8_lossy(&self.name).into_owned() + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +/// Family-specific member metadata. +pub enum ArchiveMemberDetail { + /// RAR 1.3/1.4 member fields. + #[non_exhaustive] + Rar13 { + /// Compression method byte from the file header. + method: u8, + /// Minimum unpacker version byte from the file header. + unpack_version: u8, + /// Legacy 16-bit file checksum. + file_checksum: u16, + /// Whether the member carries a file-comment extension. + has_file_comment: bool, + }, + /// RAR 1.5 through RAR 4.x member fields. + #[non_exhaustive] + Rar15To40 { + /// Compression method byte from the file header. + method: u8, + /// Minimum unpacker version byte from the file header. + unpack_version: u8, + /// Stored CRC-32 of the unpacked data. + crc32: u32, + /// Whether this member participates in a solid stream. + solid: bool, + /// Original Unicode wire name, including the legacy fallback. + unicode_name: Option>, + /// Raw legacy extended timestamp record. + extended_times: Vec, + /// Per-file salt when file encryption is used. + salt: Option<[u8; 8]>, + /// Whether the member carries a file-comment extension. + has_file_comment: bool, + }, + /// RAR 5.0 and later member fields. + #[non_exhaustive] + Rar50Plus { + /// Raw compression-info field from the RAR5 file header. + compression_info: u64, + /// Stored CRC-32 when present. + crc32: Option, + /// Complete supported RAR5 high-precision file times. + file_times: Option, + /// Redirection metadata, including the raw target name. + redirection: Option, + /// Strong file hash when present. + hash: Option, + }, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +/// Strong hash metadata attached to an archive member. +pub enum ArchiveMemberHash { + /// RAR5 BLAKE2sp file hash. + Blake2sp([u8; 32]), + /// Unknown hash record retained for inspection. + Other { hash_type: u64, data: Vec }, +} + +#[derive(Debug, Clone)] +#[non_exhaustive] +/// Lazy iterator returned by [`Archive::members`]. +pub struct ArchiveMembers<'a> { + inner: ArchiveMemberRefs<'a>, +} + +impl Iterator for ArchiveMembers<'_> { + type Item = ArchiveMember; + + fn next(&mut self) -> Option { + self.inner.next().map(|member| member.to_owned()) + } + + fn nth(&mut self, n: usize) -> Option { + self.inner.nth(n).map(|member| member.to_owned()) + } +} + +/// A `Write` that appends into a buffer someone else holds, for the extraction +/// callbacks that hand their writer away and need the bytes back. +struct SharedBuffer(std::sync::Arc>>>); + +impl SharedBuffer { + fn lock(&self) -> std::sync::MutexGuard<'_, Option>> { + // Only private buffer operations run under this lock. A panic while + // appending unwinds extraction before its owner can read the result; + // no callback runs with the guard held or can resume that extraction. + self.0.lock().expect("member buffer mutex is not poisoned") + } +} + +impl Write for SharedBuffer { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.lock() + .get_or_insert_with(Vec::new) + .extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl Archive { + /// Returns the detected archive family. + pub fn family(&self) -> ArchiveFamily { + match self { + Self::Rar13(_) => ArchiveFamily::Rar13, + Self::Rar15To40(_) => ArchiveFamily::Rar15To40, + Self::Rar50Plus(_) => ArchiveFamily::Rar50Plus, + } + } + + /// Returns the byte offset where the RAR archive begins after any SFX stub. + pub fn sfx_offset(&self) -> usize { + match self { + Self::Rar13(archive) => archive.sfx_offset, + Self::Rar15To40(archive) => archive.sfx_offset, + Self::Rar50Plus(archive) => archive.sfx_offset, + } + } + + /// Iterates over file-like members using a common cross-version metadata view. + pub fn members(&self) -> ArchiveMembers<'_> { + ArchiveMembers { + inner: self.member_refs(), + } + } + + /// Traverses member headers without allocating names or copying metadata. + /// The borrow prevents mutation of the archive while these views are in use. + pub fn member_refs(&self) -> ArchiveMemberRefs<'_> { + ArchiveMemberRefs::new(self) + } + + /// Builds an optional zero-copy metadata index for repeated lookup. + /// The archive cannot be mutated while this index remains in use. + /// + /// ```compile_fail + /// # fn example(archive: &mut rars::Archive) { + /// let index = archive.index(); + /// if let rars::Archive::Rar13(legacy) = archive { + /// legacy.entries.clear(); + /// } + /// println!("{}", index.len()); + /// # } + /// ``` + pub fn index(&self) -> ArchiveIndex<'_> { + ArchiveIndex::new(self) + } + + /// Streams extracted entries to caller-provided writers. + /// + /// Output is not transactional: integrity checks can fail after all bytes of + /// a member have been written, and decode/filter or sink failures can leave + /// a partial member. Earlier entries and callback side effects are not rolled + /// back. The amount written before an error depends on the decoding path; + /// even a complete payload must not be treated as verified on failure. + /// + /// For verified publication, write to caller-owned staging storage and + /// publish it only after extraction succeeds. Output quotas do not provide + /// staging or rollback. This method does not flush or sync returned writers; + /// callers must check any required flush/sync before publishing staged output. + pub fn extract_to(&self, password: Option<&[u8]>, open: F) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.extract_to_with_options(read_options(password), open) + } + + /// Streams extracted entries to caller-provided writers with read options. + /// Has the failure and staging semantics of [`Self::extract_to`]. + pub fn extract_to_with_options( + &self, + options: ArchiveReadOptions<'_>, + mut open: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + match self { + Self::Rar13(archive) => { + archive.extract_to_with_options(options, |meta| open(&rar13_meta(meta))) + } + Self::Rar15To40(archive) => { + archive.extract_to(options, |meta| open(&rar15_40_meta(meta))) + } + Self::Rar50Plus(archive) => archive.extract_to(options, |meta| open(&rar50_meta(meta))), + } + } + + /// Visits members in archive order, choosing whether to extract, skip or stop. + /// + /// The callback receives full metadata before payload limits, dictionary + /// admission, password checks or decoding. It can skip an oversized or + /// encrypted independent member without reading its payload. Skipped output + /// does not consume output quotas and is not verified. Parsing limits and + /// passwords needed to read encrypted headers still apply before this call. + /// + /// `Extract` uses the same decoding and output accounting as [`Self::extract_to`]. + /// Its writer can already have been opened when admission fails. Callback, + /// source, decoding, integrity and sink errors stop extraction immediately; + /// partial output has the failure semantics documented on that method. + /// `Stop` returns [`ExtractionOutcome::Stopped`], distinct from reaching the end. + /// Cancellation takes precedence over a successful callback decision. + /// + /// Skipping file data is conservatively refused in any solid archive with + /// [`Error::CannotSkipSolidMember`]. To discard solid output while retaining + /// history, return `Extract(Box::new(std::io::sink()))`; this still decodes, + /// verifies, requires passwords and counts against output quotas. + /// Directories can be skipped. RAR5 redirections can be skipped or stop the + /// scan but cannot be extracted through this writer-only callback. + /// This sequential API handles a single physical archive; extracting split + /// members still requires the existing multivolume extraction API. + /// + /// ``` + /// # fn scan(archive: &rars::Archive) -> rars::Result<()> { + /// use rars::{ArchiveReadOptions, ExtractionDecision}; + /// archive.extract_with_control(ArchiveReadOptions::new(), |member| { + /// if member.meta.is_encrypted || member.meta.unpacked_size > 1024 * 1024 { + /// Ok(ExtractionDecision::Skip) + /// } else { + /// Ok(ExtractionDecision::Extract(Box::new(std::io::sink()))) + /// } + /// })?; + /// # Ok(()) + /// # } + /// ``` + pub fn extract_with_control( + &self, + options: ArchiveReadOptions<'_>, + mut decide: F, + ) -> Result + where + F: FnMut(&ArchiveMember) -> Result, + { + match self { + Self::Rar13(archive) => archive.extract_controlled(options, &mut decide, None), + Self::Rar15To40(archive) => archive.extract_controlled(options, &mut decide, None), + Self::Rar50Plus(archive) => archive.extract_controlled(options, &mut decide, None), + } + } + + /// Like [`Self::extract_with_control`], with explicit recovery after independent + /// member failures. `on_error` can return [`ExtractionErrorAction::Continue`] + /// to attempt the next member with fresh decoder state. Partial output is not + /// removed, and bytes already accepted remain charged to the total quota. + /// `Complete` means the traversal ended, not that every member was verified. + /// + /// Solid or split-member failures, resource-limit failures, cancellation and + /// errors returned by either callback are fatal and cannot be continued. + /// Parsing errors occur before this API and cannot be recovered here. + pub fn extract_with_control_and_errors( + &self, + options: ArchiveReadOptions<'_>, + mut decide: F, + mut on_error: E, + ) -> Result + where + F: FnMut(&ArchiveMember) -> Result, + E: FnMut(&ArchiveMember, &Error) -> Result, + { + match self { + Self::Rar13(archive) => { + archive.extract_controlled(options, &mut decide, Some(&mut on_error)) + } + Self::Rar15To40(archive) => { + archive.extract_controlled(options, &mut decide, Some(&mut on_error)) + } + Self::Rar50Plus(archive) => { + archive.extract_controlled(options, &mut decide, Some(&mut on_error)) + } + } + } + + /// Extracts independent non-solid members in parallel, buffering decoded + /// file bytes before replaying writes in archive order. + /// Batches are published before decoding the next batch, so a later failure + /// can leave earlier output published. Legacy RAR 1.5–4.0 batches retain at + /// most one result per worker; this is not a byte or total-memory ceiling. + /// + /// Solid archives, split members, multivolume sets, and RAR 1.3/1.4 + /// archives use the regular streaming extractor. + pub fn extract_to_parallel_buffered(&self, password: Option<&[u8]>, open: F) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.extract_to_parallel_buffered_with_options(read_options(password), open) + } + + /// Extracts independent non-solid members in parallel with read options. + /// Uses the batch publication semantics of [`Self::extract_to_parallel_buffered`]. + /// A configured total output ceiling selects sequential extraction. + pub fn extract_to_parallel_buffered_with_options( + &self, + options: ArchiveReadOptions<'_>, + mut open: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + match self { + Self::Rar13(archive) => { + archive.extract_to_with_options(options, |meta| open(&rar13_meta(meta))) + } + Self::Rar15To40(archive) => { + archive.extract_to_parallel_buffered(options, |meta| open(&rar15_40_meta(meta))) + } + Self::Rar50Plus(archive) => { + archive.extract_to_parallel_buffered(options, |meta| open(&rar50_meta(meta))) + } + } + } + + /// Returns one member's decoded bytes, or `None` when the archive has no + /// file of that name. + /// + /// Only the selected payload and solid predecessors are decoded and verified. + /// Unrelated independent files and later payloads are skipped. Use [`test`](Self::test) + /// to verify the whole archive. Duplicate names select the last payload member; + /// use [`read_member_at`](Self::read_member_at) for unambiguous identity. + /// Reading several solid members separately repeats predecessor decoding; + /// use [`extract_to`](Self::extract_to) to take them all in one pass. + pub fn read_member(&self, name: &[u8], password: Option<&[u8]>) -> Result>> { + self.read_member_with_options(name, read_options(password)) + } + + /// Read one named payload with cancellation and extraction resource policies. + /// Selection matches [`read_member`](Self::read_member): the last payload with + /// this name, plus required solid predecessors. Output budgets include those + /// predecessors even though their bytes are discarded. Parsing-only limits + /// are not reapplied. No partial byte buffer is returned on failure. + pub fn read_member_with_options( + &self, + name: &[u8], + options: ArchiveReadOptions<'_>, + ) -> Result>> { + options.check_cancelled()?; + let index = self + .member_refs() + .enumerate() + .filter(|(_, member)| { + member.name_bytes() == name && !member.is_directory() && !member.is_redirection() + }) + .map(|(index, _)| index) + .last(); + match index { + Some(index) => self.read_member_at_with_options(index, options), + None => Ok(None), + } + } + + /// Returns one member's decoded bytes by archive-order index. + /// + /// Unlike name lookup this remains unambiguous when an archive contains + /// duplicate names or names that are not valid UTF-8. + /// Indices include directories and redirections, which return no file bytes. + /// Missing indices also return `None` without decoding. Only the selected + /// payload and solid predecessors are verified; later payloads are not read. + pub fn read_member_at(&self, index: usize, password: Option<&[u8]>) -> Result>> { + self.read_member_at_with_options(index, read_options(password)) + } + + /// Identity-based counterpart to [`read_member_with_options`](Self::read_member_with_options). + /// Indices include directories and redirections, which return `None`. + /// Cancellation is checked even for a missing or non-payload selection. + /// A failed call returns no buffer; each call starts fresh output budgets. + pub fn read_member_at_with_options( + &self, + index: usize, + options: ArchiveReadOptions<'_>, + ) -> Result>> { + options.check_cancelled()?; + let Some(member) = self.member_refs().nth(index) else { + return Ok(None); + }; + if member.is_directory() || member.is_redirection() { + return Ok(None); + } + // Match controlled extraction's conservative solid admission policy, + // including member flags in archives without a main solid flag. + let solid = self.is_solid(); + let collected = std::sync::Arc::new(std::sync::Mutex::new(None::>)); + let mut current = 0usize; + self.extract_with_control(options, |member| { + let this = current; + current += 1; + if this > index { + return Ok(ExtractionDecision::Stop); + } + if this != index { + return Ok( + if solid && !member.meta.is_directory && !member.meta.is_redirection { + ExtractionDecision::Extract(Box::new(std::io::sink())) + } else { + ExtractionDecision::Skip + }, + ); + } + let sink = SharedBuffer(std::sync::Arc::clone(&collected)); + *sink.lock() = Some(Vec::new()); + Ok(ExtractionDecision::Extract(Box::new(sink))) + })?; + let taken = collected + .lock() + .expect("member buffer mutex is not poisoned") + .take(); + Ok(taken) + } + + /// Decodes every member and discards the bytes, so a bad checksum or a + /// wrong password is reported and nothing is written. + pub fn test(&self, password: Option<&[u8]>) -> Result<()> { + self.test_with_options(read_options(password)) + } + + /// Verify all member payloads with cancellation and extraction resource policies. + /// Discarding output does not exempt it from member or total output limits. + /// Parsing-only limits are not reapplied; comments and recovery are outside + /// this payload test. Each call starts fresh output budgets. + pub fn test_with_options(&self, options: ArchiveReadOptions<'_>) -> Result<()> { + self.test_with_options_and_callback(options, |_| Ok(())) + } + + /// Verifies payloads and reports regular entries and directories once, in + /// archive order. Redirections are skipped, as in ordinary extraction. + /// + /// Callbacks do not receive payload bytes. A callback can precede that + /// member's verification; earlier callbacks can have run when the call fails. + /// Only successful completion verifies every payload. Cancellation is checked + /// around callbacks, and a callback error aborts the operation. + /// + /// RAR5 verification discards each worker's decoded output rather than + /// retaining another buffer for publication. Buffered, streaming and scratch + /// decoding retain their extraction routing. All output, dictionary and + /// workspace limits also apply to discarded output. + pub fn test_with_options_and_callback( + &self, + options: ArchiveReadOptions<'_>, + mut tested: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result<()>, + { + options.check_cancelled()?; + if let Self::Rar50Plus(archive) = self { + return archive.test_to(options, |meta| tested(&rar50_meta(meta))); + } + self.extract_to_parallel_buffered_with_options(options, |meta| { + tested(meta)?; + Ok(Box::new(std::io::sink()) as Box) + }) + } + + /// The archive comment, decrypting its payload with the supplied password. + pub fn comment(&self, password: Option<&[u8]>) -> Result>> { + self.comment_with_options(ArchiveReadOptions::with_optional_password(password)) + } + + /// Decodes the archive comment with per-call cancellation and output limits. + /// Both output ceilings apply to this single comment, with fresh budgets. + /// Admission precedes payload allocation; no partial comment is returned. + /// RAR5 dictionary and buffered/scratch policies also apply. Parsing limits + /// are not reapplied. Existing format-specific checksum behaviour is retained. + /// The default RAR5 comment path remains buffered; set an explicit buffering + /// threshold to use streaming/scratch decoding. The returned Vec, packed input + /// and decoder workspace are not an aggregate RAM quota. Unknown-size RAR5 + /// comments are refused when either output ceiling is configured. + /// + /// ```no_run + /// # fn example(archive: &rars::Archive) -> rars::Result<()> { + /// let options = rars::ArchiveReadOptions::new() + /// .with_max_member_output_bytes(64 * 1024) + /// .with_rar50_dictionary_size_limit(8 * 1024 * 1024); + /// let comment = archive.comment_with_options(options)?; + /// # Ok(()) + /// # } + /// ``` + pub fn comment_with_options(&self, options: ArchiveReadOptions<'_>) -> Result>> { + match self { + Self::Rar13(archive) => archive.archive_comment_with_options(options), + Self::Rar15To40(archive) => archive.archive_comment_with_options(options), + Self::Rar50Plus(archive) => archive.archive_comment_with_options(options), + } + } + + /// Returns full repaired archive bytes using the archive's embedded + /// recovery records. + pub fn repair_recovery(&self) -> Result> { + Ok(self.repair_recovery_with_report(None)?.data) + } + + /// Repaired archive bytes together with what the repair had to change. + /// + /// `password` unlocks the recovery record of a header-encrypted RAR 5 + /// archive, and frames its replacement end-of-archive header. + pub fn repair_recovery_with_report( + &self, + password: Option<&[u8]>, + ) -> Result { + self.repair_recovery_with_options(ArchiveReadOptions::with_optional_password(password)) + } + + /// Repairs embedded recovery data with a password and cooperative cancellation. + /// Only password and cancellation apply; parsing and member-output limits do + /// not describe repair workspace or the complete repaired archive. + pub fn repair_recovery_with_options( + &self, + options: ArchiveReadOptions<'_>, + ) -> Result { + if !cfg!(feature = "recovery") { + return Err(Error::FeatureDisabled { + feature: "recovery", + }); + } + options.check_cancelled()?; + match self { + Self::Rar15To40(archive) => archive.repair_protect_head_with_options(options), + Self::Rar50Plus(archive) => archive.repair_recovery_with_options(options), + Self::Rar13(_) => Err(Error::UnsupportedFamilyFeature { + family: ArchiveFamily::Rar13, + feature: "recovery repair for RAR 1.3/1.4 archives", + }), + } + } + + /// Streams full repaired archive bytes to `writer` using embedded recovery + /// records. + pub fn repair_recovery_to(&self, writer: &mut dyn Write) -> Result<()> { + self.repair_recovery_to_with_report(writer, None) + .map(|_| ()) + } + + pub fn repair_recovery_to_with_report( + &self, + writer: &mut dyn Write, + password: Option<&[u8]>, + ) -> Result { + if !cfg!(feature = "recovery") { + return Err(Error::FeatureDisabled { + feature: "recovery", + }); + } + match self { + Self::Rar15To40(archive) => { + let repaired = archive.repair_protect_head_with_report()?; + writer.write_all(&repaired.data)?; + Ok(repaired.report) + } + Self::Rar50Plus(archive) => archive.repair_recovery_to_with_report(writer, password), + Self::Rar13(_) => Err(Error::UnsupportedFamilyFeature { + family: ArchiveFamily::Rar13, + feature: "recovery repair for RAR 1.3/1.4 archives", + }), + } + } + + /// Returns the concrete RAR 1.3/1.4 archive when this archive has that family. + pub fn as_rar13(&self) -> Option<&rar13::Archive> { + match self { + Self::Rar13(archive) => Some(archive), + Self::Rar15To40(_) => None, + Self::Rar50Plus(_) => None, + } + } + + /// Returns the concrete RAR 1.5 through RAR 4.x archive when applicable. + pub fn as_rar15_40(&self) -> Option<&rar15_40::Archive> { + match self { + Self::Rar13(_) => None, + Self::Rar15To40(archive) => Some(archive), + Self::Rar50Plus(_) => None, + } + } + + /// Returns the concrete RAR 5.0 or later archive when applicable. + pub fn as_rar50(&self) -> Option<&rar50::Archive> { + match self { + Self::Rar13(_) | Self::Rar15To40(_) => None, + Self::Rar50Plus(archive) => Some(archive), + } + } +} + +fn rar13_member(entry: &rar13::Entry) -> ArchiveMember { + ArchiveMember { + meta: ArchiveMemberMeta { + family: ArchiveFamily::Rar13, + name: entry.name.clone(), + packed_size: u64::from(entry.header.pack_size), + unpacked_size: u64::from(entry.header.unp_size), + file_time: Some(entry.header.file_time), + mtime_refinement: None, + file_attr: u64::from(entry.header.file_attr), + host_os: None, + is_directory: entry.is_directory(), + is_redirection: false, + is_encrypted: entry.is_encrypted(), + is_stored: entry.is_stored(), + is_split_before: entry.is_split_before(), + is_split_after: entry.is_split_after(), + }, + detail: ArchiveMemberDetail::Rar13 { + method: entry.header.method, + unpack_version: entry.header.unp_ver, + file_checksum: entry.header.file_crc, + has_file_comment: entry.has_file_comment(), + }, + } +} + +fn rar15_40_member(file: &rar15_40::FileHeader) -> ArchiveMember { + ArchiveMember { + meta: ArchiveMemberMeta { + family: ArchiveFamily::Rar15To40, + name: file.name.clone(), + packed_size: file.pack_size, + unpacked_size: file.unp_size, + file_time: Some(file.file_time), + mtime_refinement: file.mtime_refinement(), + file_attr: u64::from(file.attr), + host_os: Some(u64::from(file.host_os)), + is_directory: file.is_directory(), + is_redirection: false, + is_encrypted: file.is_encrypted(), + is_stored: file.is_stored(), + is_split_before: file.is_split_before(), + is_split_after: file.is_split_after(), + }, + detail: ArchiveMemberDetail::Rar15To40 { + method: file.method, + unpack_version: file.unp_ver, + crc32: file.file_crc, + solid: file.is_solid(), + salt: file.salt, + unicode_name: file.unicode_name.clone(), + extended_times: file.ext_time.clone(), + has_file_comment: file.has_file_comment(), + }, + } +} + +fn rar50_member(file: &rar50::FileHeader) -> ArchiveMember { + ArchiveMember { + meta: ArchiveMemberMeta { + family: ArchiveFamily::Rar50Plus, + name: file.name.clone(), + packed_size: file.packed_size(), + unpacked_size: file.unpacked_size, + file_time: file.modification_time(), + mtime_refinement: file.modification_time_refinement(), + file_attr: file.attributes, + host_os: Some(file.host_os), + is_directory: file.is_directory(), + is_redirection: file.is_redirection(), + is_encrypted: file.encrypted, + is_stored: file.is_stored(), + is_split_before: file.is_split_before(), + is_split_after: file.is_split_after(), + }, + detail: ArchiveMemberDetail::Rar50Plus { + compression_info: file.compression_info, + crc32: file.data_crc32, + hash: file.hash.as_ref().map(rar50_member_hash), + redirection: file.redirection.clone(), + file_times: file.file_times, + }, + } +} + +fn rar50_member_hash(hash: &rar50::FileHash) -> ArchiveMemberHash { + match hash.hash_type { + 0 if hash.data.len() == 32 => { + let mut data = [0; 32]; + data.copy_from_slice(&hash.data); + ArchiveMemberHash::Blake2sp(data) + } + _ => ArchiveMemberHash::Other { + hash_type: hash.hash_type, + data: hash.data.clone(), + }, + } +} + +#[derive(Debug, Clone, Copy, Default)] +#[non_exhaustive] +/// Archive reader facade with signature-based dispatch. +pub struct ArchiveReader; + +/// Describes what an embedded recovery repair changed. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct RecoveryRepairReport { + pub changed: bool, + pub data_repaired: bool, + pub recovery_record_rebuilt: bool, + pub end_record_rebuilt: bool, + pub available_recovery_shards: Option, + pub expected_recovery_shards: Option, +} + +/// Repaired archive bytes together with a precise repair report. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RecoveryRepairResult { + pub data: Vec, + pub report: RecoveryRepairReport, +} + +#[cfg(feature = "recovery")] +impl RecoveryRepairResult { + /// Publishes repaired bytes beside the destination, replacing it only after + /// writing, syncing and a final cancellation check succeed. Cancellation + /// after the final check cannot interrupt the rename. Temporary output is + /// removed on failure; the destination is untouched until publication. + pub fn write_to_path( + &self, + path: &std::path::Path, + cancellation: Option<&ReadCancellation>, + ) -> Result<()> { + let control = crate::read_control::ReadControl::new(cancellation); + self.write_to_path_controlled(path, &control) + } + + fn write_to_path_controlled( + &self, + path: &std::path::Path, + control: &crate::read_control::ReadControl, + ) -> Result<()> { + control.check()?; + let (mut pending, output) = crate::pending_archive::PendingArchive::create(path)?; + { + let mut output = output; + control.finish( + control + .write_all(&mut output, &self.data) + .map_err(Error::from), + )?; + output.sync_all()?; + } + control.check()?; + std::fs::rename(pending.path.as_ref().unwrap(), path)?; + pending.path = None; + Ok(()) + } +} + +impl ArchiveReader { + /// Detects the archive signature in a byte slice. + pub fn detect(input: &[u8]) -> Result { + detect_archive_family(input).ok_or(Error::UnsupportedSignature) + } + + /// Parses an archive from memory with default read options. + pub fn read(input: &[u8]) -> Result { + Self::read_with_options(input, ArchiveReadOptions::default()) + } + + /// Parses an archive from an owned memory buffer with default read options. + pub fn read_owned(input: Vec) -> Result { + Self::read_owned_with_options(input, ArchiveReadOptions::default()) + } + + /// Parses an archive from memory using explicit read options. + pub fn read_with_options(input: &[u8], options: ArchiveReadOptions<'_>) -> Result { + options.check_cancelled()?; + let signature = + find_archive_start(input, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + match signature.family { + ArchiveFamily::Rar13 => Ok(Archive::Rar13(rar13::Archive::parse_with_options( + input, options, + )?)), + ArchiveFamily::Rar15To40 => Ok(Archive::Rar15To40( + rar15_40::Archive::parse_with_options(input, options)?, + )), + ArchiveFamily::Rar50Plus => Ok(Archive::Rar50Plus(rar50::Archive::parse_with_options( + input, options, + )?)), + } + } + + /// Parses an archive from an owned memory buffer using explicit read options. + pub fn read_owned_with_options( + input: Vec, + options: ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let signature = + find_archive_start(&input, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + match signature.family { + ArchiveFamily::Rar13 => Ok(Archive::Rar13(rar13::Archive::parse_owned_with_options( + input, options, + )?)), + ArchiveFamily::Rar15To40 => Ok(Archive::Rar15To40( + rar15_40::Archive::parse_owned_with_options(input, options)?, + )), + ArchiveFamily::Rar50Plus => Ok(Archive::Rar50Plus( + rar50::Archive::parse_owned_with_options(input, options)?, + )), + } + } + + /// Parses an archive from a path with default read options. + /// + /// See [`Self::read_reader`] to retain an already-open file handle instead. + pub fn read_path(path: impl AsRef) -> Result { + Self::read_path_with_options(path, ArchiveReadOptions::default()) + } + + /// Parses an owned seekable source without copying the complete archive. + /// + /// Reads from offset zero regardless of the source's initial position. The + /// archive and its clones retain the source until they are dropped. Its + /// contents and length must remain unchanged throughout that lifetime. + /// Sources borrowed from a shorter-lived owner are not supported; an owned + /// file, memory-map wrapper, or shared virtual-file handle can be supplied. + /// + /// Source I/O is serialized, with a separate position per reader; parallel + /// decoding still runs concurrently. Parsing reads the signature scan and + /// headers, while extraction reads payloads on demand. Individual codecs + /// may buffer payloads. Cancellation cannot interrupt a blocked source call. + /// + /// ```no_run + /// # fn example() -> rars::Result<()> { + /// let file = std::fs::File::open("archive.rar")?; + /// let archive = rars::ArchiveReader::read_reader(file)?; + /// archive.extract_to(None, |_| Ok(Box::new(std::io::sink())))?; + /// # Ok(()) + /// # } + /// ``` + pub fn read_reader(reader: R) -> Result { + Self::read_reader_with_options(reader, ArchiveReadOptions::default()) + } + + /// Parses an owned seekable source with the same policies as [`Self::read_with_options`]. + /// Ownership, positioning and concurrency follow [`Self::read_reader`]. + pub fn read_reader_with_options( + reader: R, + options: ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let reader = crate::source::ReaderSource::new(reader)?; + let source = crate::source::ArchiveSource::Reader(reader.clone()); + let len = source.len()?; + let mut cursor = reader.cursor(); + let signature = read_archive_signature( + &mut crate::read_control::ReadControl::new(options.cancellation).reader(&mut cursor), + len.min(SFX_SCAN_LIMIT), + )?; + options.check_cancelled()?; + let signature = signature.ok_or(Error::UnsupportedSignature)?; + match signature.family { + ArchiveFamily::Rar13 => Ok(Archive::Rar13(rar13::Archive::parse_seekable( + cursor, + len as u64, + signature.offset, + source, + options, + )?)), + ArchiveFamily::Rar15To40 => Ok(Archive::Rar15To40(rar15_40::Archive::parse_seekable( + cursor, + len as u64, + signature.offset, + source, + options, + )?)), + ArchiveFamily::Rar50Plus => Ok(Archive::Rar50Plus(rar50::Archive::parse_file_backed( + &mut cursor, + len, + signature.offset, + source, + options, + )?)), + } + } + + /// Parses an archive from a path using explicit read options. + pub fn read_path_with_options( + path: impl AsRef, + options: ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let path = path.as_ref(); + let mut file = std::fs::File::open(path)?; + let len = file.metadata()?.len(); + let signature = read_archive_signature(&mut file, len.min(SFX_SCAN_LIMIT as u64) as usize)?; + options.check_cancelled()?; + let signature = signature.ok_or(Error::UnsupportedSignature)?; + match signature.family { + ArchiveFamily::Rar13 => Ok(Archive::Rar13( + rar13::Archive::parse_path_with_signature_and_options(path, signature, options)?, + )), + ArchiveFamily::Rar15To40 => Ok(Archive::Rar15To40( + rar15_40::Archive::parse_path_with_signature(path, signature, options)?, + )), + ArchiveFamily::Rar50Plus => Ok(Archive::Rar50Plus( + rar50::Archive::parse_path_with_signature(path, signature, options)?, + )), + } + } +} + +fn read_archive_signature( + reader: &mut impl Read, + scan_len: usize, +) -> Result> { + let mut prefix = [0; 8]; + let prefix_len = scan_len.min(prefix.len()); + reader.read_exact(&mut prefix[..prefix_len])?; + if let Some(signature) = detect_archive_family(&prefix[..prefix_len]) + .filter(|signature| signature.family != ArchiveFamily::Rar13) + { + // The first strong signature wins the full scan too. RAR 1.3 still + // scans because a later RAR 1.5/5 signature takes precedence over it. + return Ok(Some(signature)); + } + if scan_len <= prefix.len() { + return Ok(find_archive_start(&prefix[..prefix_len], SFX_SCAN_LIMIT)); + } + let mut scan = vec![0; scan_len]; + scan[..prefix_len].copy_from_slice(&prefix[..prefix_len]); + reader.read_exact(&mut scan[prefix_len..])?; + Ok(find_archive_start(&scan, SFX_SCAN_LIMIT)) +} + +#[cfg(test)] +#[path = "reader_signature_tests.rs"] +mod reader_signature_tests; + +fn read_options(password: Option<&[u8]>) -> ArchiveReadOptions<'_> { + match password { + Some(password) => ArchiveReadOptions::with_password(password), + None => ArchiveReadOptions::new(), + } +} + +/// Streams a multivolume archive set to caller-provided writers. +/// Has the failure and staging semantics of [`Archive::extract_to`], including +/// partial output from a split member when a later volume fails. +pub fn extract_volumes_to(archives: &[Archive], password: Option<&[u8]>, open: F) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + extract_volumes_to_with_options(archives, read_options(password), open) +} + +/// Streams a multivolume archive set to caller-provided writers with read options. +/// Has the failure and staging semantics of [`Archive::extract_to`]. +pub fn extract_volumes_to_with_options( + archives: &[Archive], + options: ArchiveReadOptions<'_>, + mut open: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + options.check_cancelled()?; + let Some(first) = archives.first() else { + return Err(Error::InvalidHeader("volume set is empty")); + }; + + match first.family() { + ArchiveFamily::Rar13 => { + let typed = rar13_volumes(archives)?; + rar13::extract_volumes_to_with_options(&typed, options, |meta| open(&rar13_meta(meta))) + } + ArchiveFamily::Rar15To40 => { + let typed = rar15_40_volumes(archives)?; + rar15_40::extract_volumes_to(&typed, options, |meta| open(&rar15_40_meta(meta))) + } + ArchiveFamily::Rar50Plus => { + let typed = rar50_volumes(archives)?; + rar50::extract_volumes_to(&typed, options, |meta| open(&rar50_meta(meta))) + } + } +} + +/// Verifies every logical payload in a volume set and discards decoded output. +/// Has the resource and cancellation policies of [`Archive::test_with_options`]. +pub fn test_volumes_with_options( + archives: &[Archive], + options: ArchiveReadOptions<'_>, +) -> Result<()> { + test_volumes_with_options_and_callback(archives, options, |_| Ok(())) +} + +/// Verifies a volume set with metadata callbacks. Split members produce one +/// callback at their final fragment, in logical archive order. Has the callback +/// and failure semantics of [`Archive::test_with_options_and_callback`]. +pub fn test_volumes_with_options_and_callback( + archives: &[Archive], + options: ArchiveReadOptions<'_>, + mut tested: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result<()>, +{ + options.check_cancelled()?; + let Some(first) = archives.first() else { + return Err(Error::InvalidHeader("volume set is empty")); + }; + if first.family() == ArchiveFamily::Rar50Plus { + let typed = rar50_volumes(archives)?; + return rar50::test_volumes_to(&typed, options, |meta| tested(&rar50_meta(meta))); + } + extract_volumes_to_with_options(archives, options, |meta| { + tested(meta)?; + Ok(Box::new(std::io::sink()) as Box) + }) +} + +/// Returns the logical members in a volume set in archive order. +/// +/// Continuation headers are folded into the member that began on an earlier +/// volume. Packed sizes are accumulated across all fragments. +pub fn volume_members(archives: &[Archive]) -> Result> { + let Some(first) = archives.first() else { + return Err(Error::InvalidHeader("volume set is empty")); + }; + if archives + .iter() + .any(|archive| archive.family() != first.family()) + { + return Err(Error::InvalidHeader("mixed archive families in volume set")); + } + + let mut members: Vec = Vec::new(); + for archive in archives { + for member in archive.members() { + if member.meta.is_split_before { + let Some(previous) = members.last_mut() else { + return Err(Error::InvalidHeader( + "volume set starts with a continuation", + )); + }; + previous.meta.packed_size = previous + .meta + .packed_size + .saturating_add(member.meta.packed_size); + previous.meta.is_split_after = member.meta.is_split_after; + } else { + members.push(member); + } + } + } + Ok(members) +} + +/// Returns one logical member from a volume set by archive-order index. +pub fn read_volume_member_at( + archives: &[Archive], + index: usize, + password: Option<&[u8]>, +) -> Result>> { + read_volume_member_at_with_options( + archives, + index, + ArchiveReadOptions::with_optional_password(password), + ) +} + +/// Reads one logical volume member with per-call policies. The current volume +/// traversal decodes the whole set; discarded output also counts against quotas. +pub fn read_volume_member_at_with_options( + archives: &[Archive], + index: usize, + options: ArchiveReadOptions<'_>, +) -> Result>> { + options.check_cancelled()?; + let mut output_indices = member_read::volume_output_indices(archives); + let collected = std::sync::Arc::new(std::sync::Mutex::new(None::>)); + extract_volumes_to_with_options(archives, options, |meta| { + if output_indices.next() != Some(index) || meta.is_directory { + return Ok(Box::new(std::io::sink()) as Box); + } + let sink = SharedBuffer(std::sync::Arc::clone(&collected)); + *sink.lock() = Some(Vec::new()); + Ok(Box::new(sink) as Box) + })?; + let taken = collected + .lock() + .expect("member buffer mutex is not poisoned") + .take(); + Ok(taken) +} + +/// Detail a coarse timestamp cannot hold, carried alongside it. +/// +/// A DOS timestamp counts in two-second steps, so RAR 1.5-4.x archives put the +/// odd second and any sub-second precision in a separate extended field. This +/// is that field decoded: add [`add_second`](Self::add_second) whole seconds +/// and then [`nanoseconds`](Self::nanoseconds) to the base time. +/// RAR5 extended times also use this detail, with `add_second` always false. +/// +/// Kept apart from the timestamp rather than folded into it because +/// [`ExtractedEntryMeta::file_time`] is the DOS value as stored, which has +/// nowhere to put either part. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct TimeRefinement { + /// Whether the true time is one second later than the DOS value. + pub add_second: bool, + /// Sub-second remainder, below 1_000_000_000. + pub nanoseconds: u32, +} + +/// How to read [`ExtractedEntryMeta::file_attr`], which depends on the host +/// that wrote the entry. +/// +/// The grouping is measured, not assumed, because it is not the obvious one. +/// Against RAR 7.12 on Linux at umask 022, extracting one file with only +/// `HOST_OS` and `ATTR` changed: +/// +/// | RAR 1.5-4.x `HOST_OS` | attr `0x21` | reading | +/// |---|---|---| +/// | 0 MS-DOS, 1 OS/2, 2 Win32, 4 Mac OS | 444 | DOS attributes | +/// | 3 Unix, 5 BeOS | 041 | raw `st_mode` | +/// | 6 WinCE, 7+ | 644 | ignored | +/// +/// Mac OS sits with the DOS hosts and BeOS with the Unix ones, the reverse of +/// how the two are usually grouped. RAR 5.0 numbers its hosts separately: 0 is +/// Windows, 1 is Unix, and RAR 7.12 ignores the attributes of anything else. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +#[non_exhaustive] +pub enum AttrSource { + /// Windows `FILE_ATTRIBUTE_*` bits. + Dos, + /// POSIX `st_mode`. + Unix, + /// A host this build does not know; attributes carry no meaning. + #[default] + Unknown, +} + +impl AttrSource { + fn rar15_40(host_os: u8) -> Self { + match host_os { + 0 | 1 | 2 | 4 => Self::Dos, + 3 | 5 => Self::Unix, + _ => Self::Unknown, + } + } + + fn rar50(host_os: u64) -> Self { + match host_os { + 0 => Self::Dos, + 1 => Self::Unix, + _ => Self::Unknown, + } + } +} + +fn rar13_meta(meta: &rar13::ExtractedEntryMeta) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name_is_unicode: false, + name: meta.name.clone(), + file_time: Some(meta.file_time), + file_attr: u64::from(meta.file_attr), + // RAR 1.3/1.4 is MS-DOS only. + attr_source: AttrSource::Dos, + // RAR 1.3/1.4 predates the extended time field. + mtime_refinement: None, + is_directory: meta.is_directory, + } +} + +fn rar15_40_meta(meta: &rar15_40::ExtractedEntryMeta) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name_is_unicode: meta.name_is_unicode, + name: meta.name.clone(), + file_time: Some(meta.file_time), + file_attr: u64::from(meta.attr), + attr_source: AttrSource::rar15_40(meta.host_os), + mtime_refinement: meta.mtime_refinement, + is_directory: meta.is_directory, + } +} + +/// Converts RAR 5.0 entry metadata into the common form, resolving the +/// attributes against the host OS as extraction needs them. +/// +/// Public so a caller doing its own extraction gets the same resolution the +/// built-in paths do; getting it wrong loses the read-only bit or applies a +/// Windows attribute word as a Unix mode. +pub fn rar50_meta(meta: &rar50::ExtractedEntryMeta) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name_is_unicode: true, + name: meta.name.clone(), + file_time: meta.file_time, + file_attr: meta.attr, + attr_source: AttrSource::rar50(meta.host_os), + mtime_refinement: meta.mtime_refinement, + is_directory: meta.is_directory, + } +} + +fn rar13_volumes(archives: &[Archive]) -> Result> { + archives + .iter() + .map(|archive| match archive { + Archive::Rar13(archive) => Ok(archive.clone()), + Archive::Rar15To40(_) | Archive::Rar50Plus(_) => { + Err(Error::InvalidHeader("mixed archive families in volume set")) + } + }) + .collect() +} + +fn rar15_40_volumes(archives: &[Archive]) -> Result> { + archives + .iter() + .map(|archive| match archive { + Archive::Rar15To40(archive) => Ok(archive.clone()), + Archive::Rar13(_) | Archive::Rar50Plus(_) => { + Err(Error::InvalidHeader("mixed archive families in volume set")) + } + }) + .collect() +} + +fn rar50_volumes(archives: &[Archive]) -> Result> { + archives + .iter() + .map(|archive| match archive { + Archive::Rar50Plus(archive) => Ok(archive.clone()), + Archive::Rar13(_) | Archive::Rar15To40(_) => { + Err(Error::InvalidHeader("mixed archive families in volume set")) + } + }) + .collect() +} + +#[cfg(all(test, feature = "write"))] +mod tests { + use super::*; + use std::cell::RefCell; + use std::path::{Path, PathBuf}; + use std::rc::Rc; + + #[test] + fn facade_buffer_flush_preserves_written_bytes() { + let bytes = std::sync::Arc::new(std::sync::Mutex::new(None)); + let mut writer = SharedBuffer(bytes.clone()); + writer.flush().unwrap(); + assert!(bytes.lock().unwrap().is_none()); + assert_eq!(writer.write(b"").unwrap(), 0); + writer.write_all(b"a").unwrap(); + writer.flush().unwrap(); + writer.write_all(b"bc").unwrap(); + writer.flush().unwrap(); + writer.flush().unwrap(); + assert_eq!(*bytes.lock().unwrap(), Some(b"abc".to_vec())); + } + + #[test] + fn facade_family_accessors_and_public_hash_models_preserve_information() { + for version in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let mut archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.as_rar13().is_some(), + version == ArchiveVersion::Rar13 + ); + assert_eq!( + archive.as_rar15_40().is_some(), + version == ArchiveVersion::Rar29 + ); + assert_eq!( + archive.as_rar50().is_some(), + version == ArchiveVersion::Rar50 + ); + if !matches!(archive, Archive::Rar50Plus(_)) { + continue; + } + for (hash_type, data) in [ + (0, vec![7; 32]), + (0, vec![7; 31]), + (0, vec![7; 33]), + (1, vec![7; 32]), + (u64::MAX, vec![]), + ] { + let Archive::Rar50Plus(modern) = &mut archive else { + unreachable!() + }; + let file = modern + .blocks + .iter_mut() + .find_map(|block| match block { + rar50::Block::File(file) => Some(file), + _ => None, + }) + .unwrap(); + file.hash = Some(rar50::FileHash { + hash_type, + data: data.clone(), + }); + let member = archive.members().next().unwrap(); + let ArchiveMemberDetail::Rar50Plus { hash, .. } = member.detail else { + panic!("modern member must retain its family") + }; + let expected = if hash_type == 0 && data.len() == 32 { + ArchiveMemberHash::Blake2sp([7; 32]) + } else { + ArchiveMemberHash::Other { hash_type, data } + }; + assert_eq!(hash, Some(expected)); + } + } + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_publication_rename_failure_preserves_destination_and_cleans_staging() { + let root = crate::scratch::case("recovery-publication-rename-failure"); + let destination = root.join("destination"); + std::fs::create_dir(&destination).unwrap(); + let sentinel = destination.join("existing"); + std::fs::write(&sentinel, b"keep these bytes").unwrap(); + let result = RecoveryRepairResult { + data: b"repaired bytes".to_vec(), + report: RecoveryRepairReport::default(), + }; + let error = result.write_to_path(&destination, None).unwrap_err(); + assert_eq!(error.kind(), ErrorKind::Io); + assert_eq!(std::fs::read(&sentinel).unwrap(), b"keep these bytes"); + assert_eq!(std::fs::read_dir(&destination).unwrap().count(), 1); + assert_eq!(std::fs::read_dir(&root).unwrap().count(), 1); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_publication_cancellation_at_each_checkpoint_preserves_destination() { + let root = crate::scratch::case("recovery-publication-checkpoints"); + let destination = root.join("archive.rar"); + let result = RecoveryRepairResult { + // Three writes, including a partial final chunk. + data: vec![7; 2 * 64 * 1024 + 1], + report: RecoveryRepairReport::default(), + }; + for successful_checks in 0..=6 { + std::fs::write(&destination, b"original archive").unwrap(); + let token = ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(successful_checks); + let published = result.write_to_path_controlled(&destination, &control); + if successful_checks < 6 { + assert_eq!(published.unwrap_err(), Error::Cancelled); + assert!(token.is_cancelled()); + assert_eq!(std::fs::read(&destination).unwrap(), b"original archive"); + } else { + published.unwrap(); + assert!(!token.is_cancelled()); + assert_eq!(std::fs::read(&destination).unwrap(), result.data); + } + assert_eq!(std::fs::read_dir(&root).unwrap().count(), 1); + } + } + + #[test] + fn member_mtime_matches_rar50_extraction_without_losing_absence() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"time".to_vec(), vec![], None, None) + .unwrap(); + let archive = rar50::Archive::parse(&builder.to_bytes().unwrap()).unwrap(); + let mut file = archive.files().next().unwrap().clone(); + for (base, extended, expected) in [ + (None, None, None), + (Some(0), None, Some(0)), + (None, Some(0), Some(0)), + (None, Some(1_700_000_002), Some(1_700_000_002)), + (Some(123), Some(456), Some(123)), + (Some(0), Some(456), Some(0)), + ] { + file.mtime = base; + file.htime_mtime = extended; + assert_eq!(rar50_member(&file).meta.file_time, expected); + assert_eq!( + rar50_member(&file).meta.stored_modification_time(), + expected.map(StoredTimestamp::UnixSeconds) + ); + assert_eq!(file.metadata().file_time, expected); + } + } + + struct CollectWriter { + data: Rc>>, + } + + #[derive(Debug, Clone, PartialEq, Eq)] + // Historical numeric snapshots; timestamp presence has dedicated regression tests. + struct CollectedEntry { + name: Vec, + data: Vec, + file_time: u32, + file_attr: u64, + is_directory: bool, + } + + fn deterministic_noise(len: usize) -> Vec { + let mut state = 0x1234_5678u32; + (0..len) + .map(|_| { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (state >> 24) as u8 + }) + .collect() + } + + fn rar15_40_fixture(name: &str) -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("tests/fixtures/rar15_40") + .join(name) + } + + /// Which hosts store DOS attributes and which store `st_mode` is measured + /// against RAR 7.12, and the grouping is not the obvious one: Mac OS reads + /// as a DOS host and BeOS as a Unix one. + #[test] + fn attr_source_follows_the_measured_host_grouping() { + for host in [0u8, 1, 2, 4] { + assert_eq!(AttrSource::rar15_40(host), AttrSource::Dos, "host {host}"); + } + for host in [3u8, 5] { + assert_eq!(AttrSource::rar15_40(host), AttrSource::Unix, "host {host}"); + } + for host in [6u8, 7, 255] { + assert_eq!( + AttrSource::rar15_40(host), + AttrSource::Unknown, + "host {host}" + ); + } + + assert_eq!(AttrSource::rar50(0), AttrSource::Dos); + assert_eq!(AttrSource::rar50(1), AttrSource::Unix); + for host in [2u64, 5, 99] { + assert_eq!(AttrSource::rar50(host), AttrSource::Unknown, "host {host}"); + } + + // A caller building metadata by hand gets no host, and no host means + // no attribute is applied rather than one guessed at. + assert_eq!( + ExtractedEntryMeta::new(b"x".to_vec(), 0, 0x21, false).attr_source, + AttrSource::Unknown + ); + } + + #[test] + fn extracted_entry_meta_exposes_raw_and_lossy_names() { + let meta = ExtractedEntryMeta { + name_is_unicode: false, + name: vec![0xff, b'.', b't', b'x', b't'], + file_time: None, + file_attr: 0, + attr_source: AttrSource::Unknown, + mtime_refinement: None, + is_directory: false, + }; + + assert_eq!(meta.name_bytes(), [0xff, b'.', b't', b'x', b't']); + assert_eq!(meta.name_lossy(), "\u{fffd}.txt"); + } + + impl Write for CollectWriter { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.data.borrow_mut().extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + fn collect_extract(archive: &Archive, password: Option<&[u8]>) -> Result> { + let entries = RefCell::new(Vec::new()); + archive.extract_to(password, |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter { data })) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time.unwrap_or(0), + file_attr: meta.file_attr, + is_directory: meta.is_directory, + }) + .collect()) + } + + fn collect_rar15_40(archive: &rar15_40::Archive) -> Result> { + let entries = RefCell::new(Vec::new()); + archive.extract_to(ArchiveReadOptions::default(), |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter { data })) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time, + file_attr: u64::from(meta.attr), + is_directory: meta.is_directory, + }) + .collect()) + } + + fn collect_rar15_40_volumes( + archives: &[rar15_40::Archive], + password: Option<&[u8]>, + ) -> Result> { + let entries = RefCell::new(Vec::new()); + rar15_40::extract_volumes_to(archives, read_options(password), |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter { data })) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time, + file_attr: u64::from(meta.attr), + is_directory: meta.is_directory, + }) + .collect()) + } + + fn collect_rar50_volumes( + archives: &[rar50::Archive], + password: Option<&[u8]>, + ) -> Result> { + let entries = RefCell::new(Vec::new()); + rar50::extract_volumes_to(archives, read_options(password), |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter { data })) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time.unwrap_or(0), + file_attr: meta.attr, + is_directory: meta.is_directory, + }) + .collect()) + } + + fn collect_rar50_file( + archive: &rar50::Archive, + file: &rar50::FileHeader, + ) -> Result { + let meta = file.metadata(); + let data = Rc::new(RefCell::new(Vec::new())); + file.write_to( + archive, + None, + &mut CollectWriter { + data: Rc::clone(&data), + }, + )?; + let data = data.borrow().clone(); + Ok(CollectedEntry { + name: meta.name, + data, + file_time: meta.file_time.unwrap_or(0), + file_attr: meta.attr, + is_directory: meta.is_directory, + }) + } + + fn rar13_options(target: ArchiveVersion) -> rar13::WriterOptions { + rar13::WriterOptions::new(target, FeatureSet::store_only()) + } + + fn rar15_options(target: ArchiveVersion) -> rar15_40::WriterOptions { + rar15_options_with_features(target, FeatureSet::store_only()) + } + + fn rar15_options_with_features( + target: ArchiveVersion, + features: FeatureSet, + ) -> rar15_40::WriterOptions { + rar15_40::WriterOptions::new(target, features) + } + + fn rar50_options(target: ArchiveVersion) -> rar50::WriterOptions { + rar50_options_with_features(target, FeatureSet::store_only()) + } + + fn rar50_options_with_features( + target: ArchiveVersion, + features: FeatureSet, + ) -> rar50::WriterOptions { + rar50::WriterOptions::new(target, features) + } + + /// Builds a member from bytes the test already holds. + fn rar50_entry(name: &[u8], data: &[u8]) -> rar50::ArchiveEntry { + rar50::ArchiveEntry::new( + name.to_vec(), + EntrySource::from_bytes(std::sync::Arc::<[u8]>::from(data.to_vec())), + ) + } + + fn write_rar50_volume_set( + entries: &[rar50::ArchiveEntry], + options: rar50::WriterOptions, + max_payload_per_volume: u64, + recovery_percent: Option, + ) -> Vec> { + let mut sink = rar50::CollectedVolumes::new(); + rar50::write_streaming_volumes_to( + entries, + options, + rar50::ArchiveExtras::default().with_recovery_percent(recovery_percent), + max_payload_per_volume, + &mut sink, + &WriterResources::default(), + ) + .unwrap(); + sink.take() + } + + fn write_rar29_filter( + options: rar15_40::WriterOptions, + entries: &[rar15_40::FileEntry<'_>], + kind: rar15_40::FilterKind, + ) -> Result> { + rar15_40::write_rar29_compressed_archive_with_filter_policy( + entries, + options, + rar15_40::FilterPolicy::Explicit(rar15_40::FilterSpec::whole(kind)), + ) + } + + fn write_rar29_filter_range( + options: rar15_40::WriterOptions, + entries: &[rar15_40::FileEntry<'_>], + kind: rar15_40::FilterKind, + range: std::ops::Range, + ) -> Result> { + rar15_40::write_rar29_compressed_archive_with_filter_policy( + entries, + options, + rar15_40::FilterPolicy::Explicit(rar15_40::FilterSpec::range(kind, range)), + ) + } + + #[cfg(feature = "recovery")] + fn assert_rar50_volume_recovery_records(archives: &[rar50::Archive], percent: u64) { + assert!(archives.iter().all(|archive| archive.main.is_volume())); + assert!(archives + .iter() + .all(|archive| archive.main.has_recovery_record())); + for archive in archives { + let service = archive.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, percent); + let data = collect_rar50_file(archive, service).unwrap().data; + assert!(data.starts_with(b"{RB}")); + assert_eq!( + u32::from_le_bytes(data[0x0c..0x10].try_into().unwrap()) as usize, + data.len() + ); + } + } + + #[test] + fn direct_writer_creates_rar15_stored_archive() { + let bytes = rar15_40::write_stored_archive( + &[rar15_40::StoredEntry { + name: b"hello.txt", + data: b"hello via facade\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar15), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar15To40); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].data, b"hello via facade\n"); + } + + #[test] + fn archive_reader_accepts_owned_buffers_without_changing_dispatch() { + let rar13_bytes = rar13::write_stored_archive( + &[rar13::StoredEntry { + name: b"old.txt", + data: b"owned rar13\n", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }], + rar13_options(ArchiveVersion::Rar14), + ) + .unwrap(); + let rar13_archive = ArchiveReader::read_owned(rar13_bytes).unwrap(); + assert_eq!(rar13_archive.family(), ArchiveFamily::Rar13); + assert_eq!( + collect_extract(&rar13_archive, None).unwrap()[0].data, + b"owned rar13\n" + ); + + let rar15_bytes = rar15_40::write_stored_archive( + &[rar15_40::StoredEntry { + name: b"mid.txt", + data: b"owned rar15\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar15), + ) + .unwrap(); + let rar15_archive = ArchiveReader::read_owned(rar15_bytes).unwrap(); + assert_eq!(rar15_archive.family(), ArchiveFamily::Rar15To40); + assert_eq!( + collect_extract(&rar15_archive, None).unwrap()[0].data, + b"owned rar15\n" + ); + + let rar50_bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entries( + [rar50_entry(b"new.txt", b"owned rar50\n") + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .finish() + .unwrap(); + let rar50_archive = ArchiveReader::read_owned(rar50_bytes).unwrap(); + assert_eq!(rar50_archive.family(), ArchiveFamily::Rar50Plus); + assert_eq!( + collect_extract(&rar50_archive, None).unwrap()[0].data, + b"owned rar50\n" + ); + } + + #[test] + fn direct_writer_keeps_rar13_methods_version_typed() { + let err = + rar13::write_stored_archive(&[], rar13_options(ArchiveVersion::Rar15)).unwrap_err(); + + assert!(matches!( + err, + Error::UnsupportedVersion(ArchiveVersion::Rar15) + )); + } + + #[test] + fn archive_members_exposes_rar13_common_metadata_and_typed_detail() { + let bytes = rar13::write_stored_archive( + &[rar13::StoredEntry { + name: b"old.txt", + data: b"old rar member", + file_time: 0x1234_5678, + file_attr: 0x20, + password: None, + file_comment: Some(b"note"), + }], + rar13_options(ArchiveVersion::Rar14), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + + assert_eq!(members.len(), 1); + assert_eq!(members[0].meta.family, ArchiveFamily::Rar13); + assert_eq!(members[0].meta.name, b"old.txt"); + assert_eq!(members[0].meta.name_bytes(), b"old.txt"); + assert_eq!(members[0].meta.name_lossy(), "old.txt"); + assert_eq!(members[0].meta.packed_size, b"old rar member".len() as u64); + assert_eq!( + members[0].meta.unpacked_size, + b"old rar member".len() as u64 + ); + assert_eq!(members[0].meta.file_time, Some(0x1234_5678)); + assert_eq!(members[0].meta.file_attr, 0x20); + assert_eq!(members[0].meta.host_os, None); + assert!(members[0].meta.is_stored); + assert!(!members[0].meta.is_encrypted); + assert!(!members[0].meta.is_split_before); + assert!(!members[0].meta.is_split_after); + assert!(matches!( + members[0].detail, + ArchiveMemberDetail::Rar13 { + method: 0, + unpack_version: _, + file_checksum: _, + has_file_comment: true, + .. + } + )); + } + + #[test] + fn archive_members_exposes_rar15_40_common_metadata_and_typed_detail() { + let features = FeatureSet::store_only(); + let payload = b"rar 2.9 member metadata ".repeat(32); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"newer.txt", + data: &payload, + file_time: 0x0102_0304, + file_attr: 0x20, + host_os: 2, + password: None, + file_comment: Some(b"rar29 note"), + }], + rar15_options_with_features(ArchiveVersion::Rar29, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + + assert_eq!(members.len(), 1); + assert_eq!(members[0].meta.family, ArchiveFamily::Rar15To40); + assert_eq!(members[0].meta.name, b"newer.txt"); + assert_eq!(members[0].meta.unpacked_size, payload.len() as u64); + assert_eq!(members[0].meta.file_time, Some(0x0102_0304)); + assert_eq!(members[0].meta.file_attr, 0x20); + assert_eq!(members[0].meta.host_os, Some(2)); + assert!(!members[0].meta.is_stored); + assert!(!members[0].meta.is_encrypted); + assert!(matches!( + members[0].detail, + ArchiveMemberDetail::Rar15To40 { + method: 0x33 | 0x35, + unpack_version: 29, + solid: false, + salt: None, + has_file_comment: true, + .. + } + )); + } + + #[test] + fn archive_members_exposes_rar50_common_metadata_and_typed_detail() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entries( + [rar50_entry(b"five.txt", b"rar 5 member metadata") + .with_mtime(Some(0x1111_2222)) + .with_attributes(0x1_0000_0020) + .with_host_os(3)] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + + assert_eq!(members.len(), 1); + assert_eq!(members[0].meta.family, ArchiveFamily::Rar50Plus); + assert_eq!(members[0].meta.name, b"five.txt"); + assert_eq!( + members[0].meta.packed_size, + b"rar 5 member metadata".len() as u64 + ); + assert_eq!( + members[0].meta.unpacked_size, + b"rar 5 member metadata".len() as u64 + ); + assert_eq!(members[0].meta.file_time, Some(0x1111_2222)); + assert_eq!(members[0].meta.file_attr, 0x1_0000_0020); + assert_eq!(members[0].meta.host_os, Some(3)); + assert!(members[0].meta.is_stored); + assert!(!members[0].meta.is_encrypted); + assert!(matches!( + members[0].detail, + ArchiveMemberDetail::Rar50Plus { .. } + )); + } + + #[test] + fn extraction_metadata_preserves_rar50_u64_file_attributes() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entries( + [rar50_entry(b"wide-attrs.txt", b"wide RAR5 file attributes") + .with_mtime(Some(0)) + .with_attributes(0x1_0000_0020) + .with_host_os(3)] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].name, b"wide-attrs.txt"); + assert_eq!(extracted[0].file_attr, 0x1_0000_0020); + } + + #[test] + fn direct_writer_creates_rar15_compressed_archive() { + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"text.txt", + data: b"facade compressed facade compressed facade compressed\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar15), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar15To40); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade compressed facade compressed facade compressed\n" + ); + } + + #[test] + fn direct_writer_creates_rar29_compressed_archive_with_default_auto_policy() { + let payload = + b"facade rar29 default auto text alpha beta gamma alpha beta gamma\n".repeat(256); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar29-default-auto.txt", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar29), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + // The byte is the level that was asked for, and nothing here asked for + // one, so it is the default 0x33. Which engine answered is signalled in + // the stream, which is why the round trip below is what proves PPMd + // read back. WinRAR stamps 0x34 on the PPMd archive it writes at -m4. + assert_eq!(raw.files().next().unwrap().method, 0x33); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_e8_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar29 e8 filter payload\n".repeat(12); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-e8.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::E8, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_auto_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar29 auto filter payload\n".repeat(12); + let bytes = rar15_40::write_rar29_compressed_archive_with_filter_policy( + &[rar15_40::FileEntry { + name: b"rar29-auto.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar29), + rar15_40::FilterPolicy::Auto, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_ppmd_compressed_archive() { + let payload = b"facade rar29 ppmd text payload alpha beta gamma\n".repeat(64); + let bytes = rar15_40::write_rar29_compressed_archive_with_filter_policy( + &[rar15_40::FileEntry { + name: b"rar29-ppmd.txt", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar29).with_method(rar15_40::Rar29Method::Ppmd), + rar15_40::FilterPolicy::None, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + // Forcing PPMd does not change the level, so this is still the default + // 0x33; extracting it is what shows PPMd was used. + assert_eq!(file.method, 0x33); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_segmented_e8_filtered_compressed_archive() { + let mut payload = b"facade unfiltered prefix before x86 segment ".to_vec(); + let filter_start = payload.len(); + payload.extend_from_slice(b"\xe8\0\0\0\0facade segmented e8 filter payload\n"); + let filter_end = payload.len(); + payload.extend_from_slice(b"facade unfiltered suffix after x86 segment\n"); + let bytes = write_rar29_filter_range( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-segmented-e8.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::E8, + filter_start..filter_end, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_solid_e8_filtered_compressed_archive() { + let first = b"\xe8\0\0\0\0facade rar29 solid e8 first payload\n".repeat(12); + let second = b"\xe8\0\0\0\0facade rar29 solid e8 second payload\n".repeat(12); + let mut features = FeatureSet::store_only(); + features.solid = true; + let bytes = write_rar29_filter( + rar15_options_with_features(ArchiveVersion::Rar29, features), + &[ + rar15_40::FileEntry { + name: b"rar29-solid-e8-first.bin", + data: &first, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_40::FileEntry { + name: b"rar29-solid-e8-second.bin", + data: &second, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + ], + rar15_40::FilterKind::E8, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let files: Vec<_> = raw.files().collect(); + assert!(raw.main.is_solid()); + assert!(!files[0].is_solid()); + assert!(files[1].is_solid()); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].data, second); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar29_encrypted_e8_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar29 encrypted e8 payload\n".repeat(12); + let features = FeatureSet::store_only(); + let bytes = write_rar29_filter( + rar15_options_with_features(ArchiveVersion::Rar29, features), + &[rar15_40::FileEntry { + name: b"rar29-encrypted-e8.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_40::FilterKind::E8, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert!(file.is_encrypted()); + assert!(file.salt.is_some()); + assert!(matches!( + collect_extract(&archive, Some(b"wrong")), + Err(Error::WrongPasswordOrCorruptData) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_header_encrypted_e8_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar30 header encrypted e8 payload\n".repeat(12); + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = write_rar29_filter( + rar15_options_with_features(ArchiveVersion::Rar30, features), + &[rar15_40::FileEntry { + name: b"rar30-header-encrypted-e8.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_40::FilterKind::E8, + ) + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.has_encrypted_headers()); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_e8e9_filtered_compressed_archive() { + let payload = b"\xe9\0\0\0\0facade rar29 e8e9 filter payload\n".repeat(12); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-e8e9.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::E8E9, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_delta_filtered_compressed_archive() { + let payload: Vec = (0..384).map(|index| (index * 19 + 5) as u8).collect(); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-delta.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Delta { channels: 3 }, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_segmented_delta_filtered_compressed_archive() { + let mut payload = b"facade unfiltered prefix before delta segment ".to_vec(); + let filter_start = payload.len(); + payload.extend((0..384).map(|index| (index * 19 + 5) as u8)); + let filter_end = payload.len(); + payload.extend_from_slice(b"facade unfiltered suffix after delta segment\n"); + let bytes = write_rar29_filter_range( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-segmented-delta.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Delta { channels: 3 }, + filter_start..filter_end, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_itanium_filtered_compressed_archive() { + let mut payload = vec![0u8; 48]; + payload[16] = 22; + payload[21] = 20; + payload.extend_from_slice(b"facade rar29 itanium filter payload\n"); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-itanium.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Itanium, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_segmented_itanium_filtered_compressed_archive() { + let mut payload = b"facade unfiltered prefix before itanium segment ".to_vec(); + let filter_start = payload.len(); + payload.extend_from_slice(&[0; 48]); + payload[filter_start + 16] = 22; + payload[filter_start + 21] = 20; + payload.extend_from_slice(b"facade segmented itanium filter payload\n"); + let filter_end = payload.len(); + payload.extend_from_slice(b"facade unfiltered suffix after itanium segment\n"); + let bytes = write_rar29_filter_range( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-segmented-itanium.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Itanium, + filter_start..filter_end, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_rgb_filtered_compressed_archive() { + let width = 12; + let payload: Vec = (0..96).map(|index| (index * 37 + 17) as u8).collect(); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-rgb.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Rgb { width, pos_r: 0 }, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_segmented_rgb_filtered_compressed_archive() { + let width = 12; + let mut payload = b"facade unfiltered prefix before rgb segment ".to_vec(); + let filter_start = payload.len(); + payload.extend((0..96).map(|index| (index * 37 + 17) as u8)); + let filter_end = payload.len(); + payload.extend_from_slice(b"facade unfiltered suffix after rgb segment\n"); + let bytes = write_rar29_filter_range( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-segmented-rgb.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Rgb { width, pos_r: 0 }, + filter_start..filter_end, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_audio_filtered_compressed_archive() { + let payload: Vec = (0..160) + .map(|index| (index * 11 + index / 7) as u8) + .collect(); + let bytes = write_rar29_filter( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-audio.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Audio { channels: 2 }, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_segmented_audio_filtered_compressed_archive() { + let mut payload = b"facade unfiltered prefix before audio segment ".to_vec(); + let filter_start = payload.len(); + payload.extend((0..160).map(|index| (index * 11 + index / 7) as u8)); + let filter_end = payload.len(); + payload.extend_from_slice(b"facade unfiltered suffix after audio segment\n"); + let bytes = write_rar29_filter_range( + rar15_options(ArchiveVersion::Rar29), + &[rar15_40::FileEntry { + name: b"rar29-segmented-audio.bin", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_40::FilterKind::Audio { channels: 2 }, + filter_start..filter_end, + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar20_compressed_archive() { + let payload = b"facade rar20 literal compressed payload\n".repeat(32); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar20.txt", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar20), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar15To40); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 20); + assert_eq!(file.method, 0x33); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_compressed_archive() { + let payload = b"facade rar29 literal compressed payload\n".repeat(32); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar29.txt", + data: &payload, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar29), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar15To40); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 29); + assert!(matches!(file.method, 0x33 | 0x35)); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar29_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let bytes = rar15_40::write_compressed_archive( + &[ + rar15_40::FileEntry { + name: b"one.txt", + data: b"facade rar29 solid one alpha beta\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_40::FileEntry { + name: b"two.txt", + data: b"facade rar29 solid two alpha beta\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + ], + rar15_options_with_features(ArchiveVersion::Rar29, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.is_solid()); + let files: Vec<_> = raw.files().collect(); + assert!(!files[0].is_solid()); + assert!(files[1].is_solid()); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar29 solid one alpha beta\n"); + assert_eq!(extracted[1].data, b"facade rar29 solid two alpha beta\n"); + } + + #[test] + fn direct_writer_creates_rar20_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let first = b"facade rar20 solid shared line alpha beta gamma\n".repeat(48); + let second = b"facade rar20 solid shared line alpha beta gamma\nsecond\n".repeat(24); + let bytes = rar15_40::write_compressed_archive( + &[ + rar15_40::FileEntry { + name: b"one.txt", + data: &first, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_40::FileEntry { + name: b"two.txt", + data: &second, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + ], + rar15_options_with_features(ArchiveVersion::Rar20, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.is_solid()); + let files: Vec<_> = raw.files().collect(); + assert_eq!(files[0].unp_ver, 20); + assert_eq!(files[1].unp_ver, 20); + assert!(!files[0].is_solid()); + assert!(files[1].is_solid()); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].data, second); + } + + #[test] + fn direct_writer_creates_rar15_archive_comment() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive_with_comment( + &[rar15_40::FileEntry { + name: b"commented.txt", + data: b"facade commented payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar15, features), + Some(b"facade note\n"), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let archive = archive.as_rar15_40().unwrap(); + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&b"facade note\n"[..]) + ); + assert_eq!( + collect_rar15_40(archive).unwrap()[0].data, + b"facade commented payload\n" + ); + } + + #[test] + fn direct_writer_creates_rar15_file_comment() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_stored_archive( + &[rar15_40::StoredEntry { + name: b"file-comment.txt", + data: b"facade file comment payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: Some(b"facade file note"), + }], + rar15_options_with_features(ArchiveVersion::Rar15, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let archive = archive.as_rar15_40().unwrap(); + let file = archive.files().next().unwrap(); + assert_eq!( + file.file_comment().unwrap().as_deref(), + Some(&b"facade file note"[..]) + ); + assert_eq!( + collect_rar15_40(archive).unwrap()[0].data, + b"facade file comment payload\n" + ); + } + + #[test] + fn direct_writer_creates_rar20_old_style_comments() { + let archive_features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive_with_comment( + &[rar15_40::FileEntry { + name: b"rar20-commented.txt", + data: b"facade rar20 archive comment payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar20, archive_features), + Some(b"facade rar20 archive note"), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.has_archive_comment()); + assert_eq!( + raw.archive_comment().unwrap().as_deref(), + Some(b"facade rar20 archive note".as_slice()) + ); + + let file_features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar20-file-commented.txt", + data: b"facade rar20 file comment payload payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: Some(b"facade rar20 file note"), + }], + rar15_options_with_features(ArchiveVersion::Rar20, file_features), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 20); + assert_eq!( + file.file_comment().unwrap().as_deref(), + Some(b"facade rar20 file note".as_slice()) + ); + } + + #[test] + fn direct_writer_creates_rar29_old_style_comments() { + let archive_features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive_with_comment( + &[rar15_40::FileEntry { + name: b"rar29-commented.txt", + data: b"facade rar29 archive comment payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar29, archive_features), + Some(b"facade rar29 archive note"), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.has_archive_comment()); + assert_eq!( + raw.archive_comment().unwrap().as_deref(), + Some(b"facade rar29 archive note".as_slice()) + ); + + let file_features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar29-file-commented.txt", + data: b"facade rar29 file comment payload payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: Some(b"facade rar29 file note"), + }], + rar15_options_with_features(ArchiveVersion::Rar29, file_features), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 29); + assert_eq!( + file.file_comment().unwrap().as_deref(), + Some(b"facade rar29 file note".as_slice()) + ); + } + + #[test] + fn direct_writer_creates_rar30_newsub_archive_comment() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive_with_comment( + &[rar15_40::FileEntry { + name: b"rar30-commented.txt", + data: b"facade rar30 NEWSUB archive comment payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar30, features), + Some(b"facade rar30 NEWSUB note"), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(!raw.main.has_archive_comment()); + let subblock = raw.new_subs().next().unwrap(); + assert_eq!(subblock.kind, rar15_40::NewSubKind::ArchiveComment); + assert_eq!(subblock.file.name, b"CMT"); + assert_eq!( + raw.archive_comment().unwrap().as_deref(), + Some(b"facade rar30 NEWSUB note".as_slice()) + ); + } + + #[test] + fn direct_writer_creates_rar15_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let bytes = rar15_40::write_compressed_archive( + &[ + rar15_40::FileEntry { + name: b"one.txt", + data: b"shared facade prefix one\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_40::FileEntry { + name: b"two.txt", + data: b"shared facade prefix two\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + ], + rar15_options_with_features(ArchiveVersion::Rar15, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"shared facade prefix one\n"); + assert_eq!(extracted[1].data, b"shared facade prefix two\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar15_encrypted_compressed_archive() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"secret.txt", + data: b"facade encrypted payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar15, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::NeedPassword) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, b"facade encrypted payload\n"); + } + + #[test] + fn direct_writer_creates_rar15_stored_volumes() { + let parts = rar15_40::write_stored_volumes( + rar15_40::StoredEntry { + name: b"split.bin", + data: b"abcdefghijklmnopqrstuvwxyz0123456789", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_options(ArchiveVersion::Rar15), + 10, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + let extracted = collect_rar15_40_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split.bin"); + assert_eq!(extracted[0].data, b"abcdefghijklmnopqrstuvwxyz0123456789"); + } + + #[test] + fn direct_writer_creates_rar20_compressed_volumes() { + let data = b"facade rar20 split phrase alpha beta gamma\n".repeat(32); + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-rar20.txt", + data: &data, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_options(ArchiveVersion::Rar20), + 8, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + let first_file = archives[0].files().next().unwrap(); + assert_eq!(first_file.unp_ver, 20); + assert!(first_file.is_split_after()); + + let extracted = collect_rar15_40_volumes(&archives, None).unwrap(); + assert_eq!(extracted[0].name, b"split-rar20.txt"); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn direct_writer_creates_rar29_compressed_volumes() { + let data = b"facade rar29 split phrase alpha beta gamma\n".repeat(32); + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-rar29.txt", + data: &data, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }, + rar15_options(ArchiveVersion::Rar29), + 8, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + let first_file = archives[0].files().next().unwrap(); + assert_eq!(first_file.unp_ver, 29); + assert!(first_file.is_split_after()); + + let extracted = collect_rar15_40_volumes(&archives, None).unwrap(); + assert_eq!(extracted[0].name, b"split-rar29.txt"); + assert_eq!(extracted[0].data, data); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar29_encrypted_compressed_volumes() { + let features = FeatureSet::store_only(); + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-rar29-secret.txt", + data: b"facade rar29 encrypted split facade rar29 encrypted split\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + rar15_options_with_features(ArchiveVersion::Rar29, features), + 8, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + + assert!(matches!( + collect_rar15_40_volumes(&archives, None), + Err(Error::NeedPassword) + )); + let extracted = collect_rar15_40_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-rar29-secret.txt"); + assert_eq!( + extracted[0].data, + b"facade rar29 encrypted split facade rar29 encrypted split\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar15_encrypted_compressed_volumes() { + let features = FeatureSet::store_only(); + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-secret.txt", + data: b"facade encrypted split facade encrypted split\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + rar15_options_with_features(ArchiveVersion::Rar15, features), + 8, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + + assert!(matches!( + collect_rar15_40_volumes(&archives, None), + Err(Error::NeedPassword) + )); + let extracted = collect_rar15_40_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-secret.txt"); + assert_eq!( + extracted[0].data, + b"facade encrypted split facade encrypted split\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_encrypted_compressed_volumes() { + let features = FeatureSet::store_only(); + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-rar30-secret.txt", + data: b"facade rar30 encrypted split facade rar30 encrypted split\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + rar15_options_with_features(ArchiveVersion::Rar30, features), + 8, + ) + .unwrap(); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse(part).unwrap()) + .collect(); + + assert!(matches!( + collect_rar15_40_volumes(&archives, None), + Err(Error::NeedPassword) + )); + let extracted = collect_rar15_40_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-rar30-secret.txt"); + assert_eq!( + extracted[0].data, + b"facade rar30 encrypted split facade rar30 encrypted split\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_header_encrypted_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let parts = rar15_40::write_compressed_volumes( + rar15_40::FileEntry { + name: b"split-rar30-header-secret.txt", + data: b"facade rar30 header encrypted split facade rar30 header encrypted split\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + rar15_options_with_features(ArchiveVersion::Rar30, features), + 8, + ) + .unwrap(); + assert!(matches!( + rar15_40::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar15_40::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + + let extracted = collect_rar15_40_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-rar30-header-secret.txt"); + assert_eq!( + extracted[0].data, + b"facade rar30 header encrypted split facade rar30 header encrypted split\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_aes_encrypted_compressed_archive() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar30-secret.txt", + data: b"facade rar30 aes encrypted payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar30, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::NeedPassword) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, b"facade rar30 aes encrypted payload\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar29_aes_encrypted_compressed_archive() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar29-secret.txt", + data: b"facade rar29 aes encrypted payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar29, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 29); + assert!(file.is_encrypted()); + assert!(file.salt.is_some()); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::NeedPassword) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, b"facade rar29 aes encrypted payload\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar20_encrypted_compressed_archive() { + let features = FeatureSet::store_only(); + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar20-secret.txt", + data: b"facade rar20 encrypted payload payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar20, features), + ) + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar15_40().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.unp_ver, 20); + assert!(file.is_encrypted()); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::NeedPassword) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar20 encrypted payload payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_header_encrypted_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar15_40::write_compressed_archive( + &[rar15_40::FileEntry { + name: b"rar30-header-secret.txt", + data: b"facade rar30 header encrypted payload\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }], + rar15_options_with_features(ArchiveVersion::Rar30, features), + ) + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar15_40().unwrap(); + assert!(raw.main.has_encrypted_headers()); + assert_eq!(raw.files().next().unwrap().name, b"rar30-header-secret.txt"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar30 header encrypted payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar30_solid_header_encrypted_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + features.solid = true; + let bytes = rar15_40::write_compressed_archive( + &[ + rar15_40::FileEntry { + name: b"solid-header-one.txt", + data: b"facade solid header encrypted one one one\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + rar15_40::FileEntry { + name: b"solid-header-two.txt", + data: b"facade solid header encrypted two two two\n", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"password"), + file_comment: None, + }, + ], + rar15_options_with_features(ArchiveVersion::Rar30, features), + ) + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade solid header encrypted one one one\n" + ); + assert_eq!( + extracted[1].data, + b"facade solid header encrypted two two two\n" + ); + } + + #[test] + fn direct_writer_creates_rar50_stored_archive() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entries( + [ + rar50_entry(b"rar5-store.txt", b"facade rar5 stored payload\n") + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar50Plus); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 stored payload\n"); + } + + #[test] + fn direct_writer_creates_rar50_compressed_archive() { + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50)) + .entries( + [rar50_entry( + b"rar5-compressed.txt", + b"facade rar5 compressed payload\nfacade rar5 compressed payload\n", + ) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let file = raw.files().next().unwrap(); + assert_eq!(file.decoded_compression_info().unwrap().method, 3); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 compressed payload\nfacade rar5 compressed payload\n" + ); + } + + #[test] + fn direct_writer_creates_rar50_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let first = b"facade rar50 solid shared phrase alpha beta gamma\n".repeat(16); + let second = b"facade rar50 solid shared phrase alpha beta gamma\nsecond\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-solid-one.txt", &first) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3), + rar50_entry(b"rar5-solid-two.txt", &second) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let files: Vec<_> = raw.files().collect(); + assert!(raw.main.is_solid()); + assert!(!files[0].decoded_compression_info().unwrap().solid); + assert!(files[1].decoded_compression_info().unwrap().solid); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].data, second); + } + + #[test] + fn direct_writer_creates_rar50_delta_filtered_compressed_archive() { + let payload: Vec = (0..180) + .map(|index| (index * 11 + index / 5) as u8) + .collect(); + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50)) + .entries( + [rar50_entry(b"rar5-delta-filtered.bin", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(rar50::FilterPolicy::explicit(rar50::FilterKind::Delta { + channels: 3, + })) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_e8_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar5 e8 filter payload".to_vec(); + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50)) + .entries( + [rar50_entry(b"rar5-e8-filtered.bin", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(rar50::FilterPolicy::explicit(rar50::FilterKind::E8)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_arm_filtered_compressed_archive() { + let payload = [0x04, 0x00, 0x00, 0xeb, b'A', b'R', b'M', b'!']; + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50)) + .entries( + [rar50_entry(b"rar5-arm-filtered.bin", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(rar50::FilterPolicy::explicit(rar50::FilterKind::Arm)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_auto_filtered_compressed_archive() { + let payload = b"\xe8\0\0\0\0facade rar5 auto filter payload\n".repeat(16); + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50)) + .entries( + [rar50_entry(b"rar5-auto-filtered.bin", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(rar50::FilterPolicy::Auto) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_stored_archive_with_comment_service() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [ + rar50_entry(b"rar5-commented.txt", b"facade rar5 comment payload\n") + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .archive_comment(Some(b"facade rar5 comment\n")) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let services: Vec<_> = raw.services().collect(); + assert_eq!(services.len(), 1); + assert_eq!(services[0].name, b"CMT"); + assert_eq!( + collect_rar50_file(raw, services[0]).unwrap().data, + b"facade rar5 comment\n" + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 comment payload\n"); + } + + #[test] + fn direct_writer_creates_rar50_stored_file_comment_service() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entry( + rar50_entry( + b"rar5-file-commented.txt", + b"facade rar5 file comment payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_service(rar50::ServiceEntry::new( + b"CMT".to_vec(), + b"facade rar5 file comment\n".to_vec(), + )), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let services: Vec<_> = raw.services().collect(); + assert_eq!(services.len(), 1); + assert_eq!(services[0].name, b"CMT"); + assert_eq!( + collect_rar50_file(raw, services[0]).unwrap().data, + b"facade rar5 file comment\n" + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 file comment payload\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_stored_file_comment_service() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entry( + rar50_entry( + b"rar5-encrypted-file-commented.txt", + b"facade encrypted rar5 file comment payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()) + .with_service( + rar50::ServiceEntry::new( + b"CMT".to_vec(), + b"facade encrypted rar5 file comment\n".to_vec(), + ) + .with_password(b"password".to_vec()), + ), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let service = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(service.data, b"facade encrypted rar5 file comment\n"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade encrypted rar5 file comment payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_stored_file_comment_service() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entry( + rar50_entry( + b"rar5-header-file-commented.txt", + b"facade header encrypted rar5 file comment payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()) + .with_service( + rar50::ServiceEntry::new( + b"CMT".to_vec(), + b"facade header encrypted rar5 file comment\n".to_vec(), + ) + .with_password(b"password".to_vec()), + ), + ) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let service = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(service.data, b"facade header encrypted rar5 file comment\n"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade header encrypted rar5 file comment payload\n" + ); + } + + #[test] + fn direct_writer_creates_rar50_stored_archive_with_quick_open_service() { + let mut features = FeatureSet::store_only(); + features.quick_open = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [ + rar50_entry(b"rar5-qo.txt", b"facade rar5 quick-open payload\n") + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.locator().unwrap().quick_open_offset.unwrap() > 0); + let services: Vec<_> = raw.services().collect(); + assert_eq!(services.len(), 1); + assert_eq!(services[0].name, b"QO"); + assert!(!collect_rar50_file(raw, services[0]) + .unwrap() + .data + .is_empty()); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 quick-open payload\n"); + } + + #[test] + fn rar50_quick_open_wrapper_checksums_the_block_size_vint() { + // The wrapper is CRC32 || BlockSize || body and the checksum covers + // BlockSize too, which is easy to miss because the length is written + // after the checksum it belongs to. Checksumming the body alone is + // invisible from inside rars: nothing here reads a quick-open index + // back, and a reference reader that rejects the wrapper just walks the + // block chain instead and calls the archive fine. + let mut features = FeatureSet::store_only(); + features.quick_open = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [ + rar50_entry(b"a.txt", b"one\n").with_host_os(3), + rar50_entry(b"b.txt", b"two\n").with_host_os(3), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"QO"); + let payload = collect_rar50_file(raw, service).unwrap().data; + + let mut pos = 0usize; + let mut wrappers = 0usize; + while pos + 4 < payload.len() { + let stored = u32::from_le_bytes(payload[pos..pos + 4].try_into().unwrap()); + let (block_size, size_len) = { + let (mut value, mut shift, mut len) = (0u64, 0u32, 0usize); + loop { + let byte = payload[pos + 4 + len]; + value |= u64::from(byte & 0x7f) << shift; + shift += 7; + len += 1; + if byte & 0x80 == 0 { + break (value, len); + } + } + }; + let framed_start = pos + 4; + let framed_end = framed_start + size_len + block_size as usize; + let framed = &payload[framed_start..framed_end]; + + assert_eq!( + crate::crc32::crc32(framed), + stored, + "wrapper {wrappers}: checksum must span the BlockSize vint and the body" + ); + assert_ne!( + crate::crc32::crc32(&framed[size_len..]), + stored, + "wrapper {wrappers}: checksum must not be over the body alone" + ); + + pos = framed_end; + wrappers += 1; + } + assert_eq!(wrappers, 2); + } + + #[test] + fn direct_writer_creates_rar50_stored_archive_with_file_services() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entry( + rar50_entry(b"rar5-services.txt", b"facade rar5 service payload\n") + .with_attributes(0x20) + .with_host_os(3) + .with_service(rar50::ServiceEntry::new( + b"ACL".to_vec(), + b"facade acl".to_vec(), + )) + .with_service(rar50::ServiceEntry::new( + b"STM".to_vec(), + b"facade stream".to_vec(), + )), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let services: Vec<_> = raw.services().collect(); + assert_eq!(services.len(), 2); + assert_eq!(services[0].name, b"ACL"); + assert_eq!(services[1].name, b"STM"); + assert_eq!( + collect_rar50_file(raw, services[0]).unwrap().data, + b"facade acl" + ); + assert_eq!( + collect_rar50_file(raw, services[1]).unwrap().data, + b"facade stream" + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 service payload\n"); + } + + #[test] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_stored_archive_with_recovery_service() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [ + rar50_entry(b"rar5-recovery.txt", b"facade rar5 recovery payload\n") + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .recovery_percent(Some(9)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + let recovery = service.recovery_record().unwrap().unwrap(); + assert_eq!(recovery.percent, 9); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 recovery payload\n"); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_repairs_rar50_inline_recovery_damage() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 repair payload\n".repeat(64); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry(b"rar5-repair.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .recovery_percent(Some(20)) + .finish() + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let data_range = archive + .as_rar50() + .unwrap() + .files() + .next() + .unwrap() + .block + .data_range + .clone(); + let mut damaged = bytes.clone(); + damaged[data_range.start + 4..data_range.start + 80].fill(0xa5); + let damaged_archive = ArchiveReader::read(&damaged).unwrap(); + assert!(collect_extract(&damaged_archive, None).is_err()); + + let mut repaired = Vec::new(); + damaged_archive.repair_recovery_to(&mut repaired).unwrap(); + + assert_eq!(repaired, bytes); + let repaired_archive = ArchiveReader::read(&repaired).unwrap(); + assert_eq!( + collect_extract(&repaired_archive, None).unwrap()[0].data, + payload + ); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_reports_rar13_family_for_unsupported_recovery_repair() { + let bytes = rar13::write_stored_archive( + &[rar13::StoredEntry { + name: b"old.txt", + data: b"old rar payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }], + rar13_options(ArchiveVersion::Rar13), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let mut repaired = Vec::new(); + let err = archive.repair_recovery_to(&mut repaired).unwrap_err(); + + assert_eq!( + err, + Error::UnsupportedFamilyFeature { + family: ArchiveFamily::Rar13, + feature: "recovery repair for RAR 1.3/1.4 archives" + } + ); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_repairs_rar15_40_recovery_as_full_archive_bytes() { + let bytes = std::fs::read(rar15_40_fixture("rar250_protect_head_rr5.rar")).unwrap(); + let mut damaged = bytes.clone(); + damaged[512 + 16..512 + 80].fill(0xa5); + let damaged_archive = ArchiveReader::read(&damaged).unwrap(); + assert!(collect_extract(&damaged_archive, None).is_err()); + + let mut repaired = Vec::new(); + damaged_archive.repair_recovery_to(&mut repaired).unwrap(); + + assert_eq!(repaired, bytes); + let repaired_archive = ArchiveReader::read(&repaired).unwrap(); + assert_eq!( + collect_extract(&repaired_archive, None).unwrap()[0].name, + b"BIG.BIN" + ); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_repairs_rar3_newsub_recovery_as_full_archive_bytes() { + let bytes = std::fs::read(rar15_40_fixture("rar300/with_recovery_rar300.rar")).unwrap(); + let mut damaged = bytes.clone(); + damaged[512 + 16..512 + 80].fill(0xa5); + let damaged_archive = ArchiveReader::read(&damaged).unwrap(); + assert!(collect_extract(&damaged_archive, None).is_err()); + + let mut repaired = Vec::new(); + damaged_archive.repair_recovery_to(&mut repaired).unwrap(); + + assert_eq!(repaired, bytes); + let repaired_archive = ArchiveReader::read(&repaired).unwrap(); + assert_eq!( + collect_extract(&repaired_archive, None).unwrap()[0].name, + b"bigtext_64k.bin" + ); + } + + #[test] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_compressed_archive_with_recovery_service() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 compressed recovery payload repeated repeated\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [rar50_entry(b"rar5-compressed-recovery.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .recovery_percent(Some(9)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, 9); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar70_stored_archive_with_metadata() { + let bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar70).with_compression_level(0)) + .entries( + [ + rar50_entry(b"rar7-metadata.txt", b"facade rar7 metadata payload\n") + .with_attributes(0x20) + .with_host_os(3), + ] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"facade rar7 metadata payload\n"); + } + + #[test] + fn direct_writer_creates_rar70_compressed_archive_with_metadata() { + let payload = b"facade rar7 compressed metadata payload repeated\n".repeat(8); + let bytes = rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar70)) + .entries( + [rar50_entry(b"rar7-compressed-metadata.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-compressed-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-compressed-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_compressed_archive_with_comment() { + let payload = b"facade rar5 compressed archive comment payload repeated\n".repeat(8); + let features = FeatureSet::store_only(); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [rar50_entry(b"rar5-compressed-comment.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .archive_comment(Some(b"facade compressed comment\n")) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let comment = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(comment.data, b"facade compressed comment\n"); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar70_encrypted_stored_archive_with_metadata() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar70, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar7-encrypted-metadata.txt", + b"facade rar7 encrypted metadata payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-encrypted-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-encrypted-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar7 encrypted metadata payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar70_encrypted_compressed_archive_with_metadata() { + let features = FeatureSet::store_only(); + let payload = b"facade rar7 encrypted compressed metadata payload repeated\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar70, features)) + .entries( + [ + rar50_entry(b"rar7-encrypted-compressed-metadata.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-encrypted-compressed-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-encrypted-compressed-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar70_header_encrypted_stored_archive_with_metadata() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar70, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar7-header-metadata.txt", + b"facade rar7 header encrypted metadata payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-header-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-header-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar7 header encrypted metadata payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar70_header_encrypted_compressed_archive_with_metadata() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload = + b"facade rar7 header encrypted compressed metadata payload repeated\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar70, features)) + .entries( + [ + rar50_entry(b"rar7-header-compressed-metadata.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .archive_metadata(Some(rar50::ArchiveMetadataEntry { + name: Some(b"facade-header-compressed-metadata.rar"), + creation_time: Some(0x01dcd60e_662d7a32), + })) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let metadata = archive.as_rar50().unwrap().main.archive_metadata().unwrap(); + assert_eq!( + metadata.name.as_deref(), + Some(b"facade-header-compressed-metadata.rar".as_slice()) + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_stored_archive() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-secret.txt", + b"facade rar5 encrypted stored payload\n", + ) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::AtEntry { source, .. }) if matches!(*source, Error::NeedPassword) + )); + assert!(matches!( + collect_extract(&archive, Some(b"wrong")), + Err(Error::AtEntry { source, .. }) + if matches!(*source, Error::WrongPasswordOrCorruptData) + )); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 encrypted stored payload\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_compressed_archive() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted compressed\n".repeat(16); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [rar50_entry(b"rar5-secret-compressed.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let file = raw.files().next().unwrap(); + assert!(file.encrypted); + assert_eq!(file.decoded_compression_info().unwrap().method, 3); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let first = b"facade rar50 encrypted solid shared phrase alpha beta gamma\n".repeat(12); + let second = + b"facade rar50 encrypted solid shared phrase alpha beta gamma\nsecond\n".repeat(6); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-encrypted-solid-one.txt", &first) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + rar50_entry(b"rar5-encrypted-solid-two.txt", &second) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + let files: Vec<_> = raw.files().collect(); + assert!(raw.main.is_solid()); + assert!(files.iter().all(|file| file.encrypted)); + assert!(!files[0].decoded_compression_info().unwrap().solid); + assert!(files[1].decoded_compression_info().unwrap().solid); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].data, second); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries([rar50_entry(b"rar5-header-secret-compressed.txt", b"facade rar5 header encrypted compressed\nfacade rar5 header encrypted compressed\n").with_attributes(0x20).with_host_os(3).with_password(b"password".to_vec())].to_vec()) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let file = raw.files().next().unwrap(); + assert!(file.encrypted); + assert_eq!(file.decoded_compression_info().unwrap().method, 3); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 header encrypted compressed\nfacade rar5 header encrypted compressed\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_solid_compressed_archive() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + features.solid = true; + let first = + b"facade rar50 header encrypted solid shared phrase alpha beta gamma\n".repeat(12); + let second = + b"facade rar50 header encrypted solid shared phrase alpha beta gamma\nsecond\n" + .repeat(6); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-header-solid-one.txt", &first) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + rar50_entry(b"rar5-header-solid-two.txt", &second) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let files: Vec<_> = raw.files().collect(); + assert!(raw.main.is_solid()); + assert!(files.iter().all(|file| file.encrypted)); + assert!(!files[0].decoded_compression_info().unwrap().solid); + assert!(files[1].decoded_compression_info().unwrap().solid); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].data, second); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_stored_archive_with_comment() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-secret.txt", + b"facade rar5 encrypted stored payload\n", + ) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .encrypted_archive_comment(b"facade encrypted comment\n", b"password") + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let comment = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(comment.data, b"facade encrypted comment\n"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, b"facade rar5 encrypted stored payload\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_compressed_archive_with_comment() { + let payload = b"facade rar5 encrypted compressed comment payload\n".repeat(8); + let features = FeatureSet::store_only(); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-encrypted-compressed-comment.txt", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .encrypted_archive_comment(b"facade encrypted compressed comment\n", b"password") + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let comment = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(comment.data, b"facade encrypted compressed comment\n"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_stored_archive() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-header-secret.txt", + b"facade rar5 header encrypted stored payload\n", + ) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + assert!(matches!( + ArchiveReader::read_with_options(&bytes, ArchiveReadOptions::with_password(b"wrong")), + Err(Error::WrongPasswordOrCorruptData) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 header encrypted stored payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_stored_archive_with_comment() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-header-comment-secret.txt", + b"facade rar5 header encrypted comment payload\n", + ) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .encrypted_archive_comment(b"facade header encrypted comment\n", b"password") + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let comment = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!(comment.data, b"facade header encrypted comment\n"); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 header encrypted comment payload\n" + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_compressed_archive_with_comment() { + let payload = b"facade rar5 header encrypted compressed comment payload\n".repeat(8); + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-header-compressed-comment-secret.txt", &payload) + .with_mtime(Some(0)) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .encrypted_archive_comment( + b"facade header encrypted compressed comment\n", + b"password", + ) + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + let comment = collect_rar50_file(raw, raw.services().next().unwrap()).unwrap(); + assert_eq!( + comment.data, + b"facade header encrypted compressed comment\n" + ); + let extracted = collect_extract(&archive, Some(b"password")).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "recovery")] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_stored_archive_with_recovery() { + let features = FeatureSet::store_only(); + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-encrypted-recovery.txt", + b"facade rar5 encrypted recovery payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .recovery_percent(Some(6)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, 6); + let recovery_data = collect_rar50_file(raw, service).unwrap().data; + assert!(recovery_data.starts_with(b"{RB}")); + assert_eq!( + u32::from_le_bytes(recovery_data[0x0c..0x10].try_into().unwrap()) as usize, + recovery_data.len() + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 encrypted recovery payload\n" + ); + } + + #[test] + #[cfg(feature = "recovery")] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_compressed_archive_with_recovery() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted compressed recovery payload repeated\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-encrypted-compressed-recovery.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .recovery_percent(Some(6)) + .finish() + .unwrap(); + + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, 6); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "recovery")] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_stored_archive_with_recovery() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let bytes = rar50::Rar50Writer::new( + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries( + [rar50_entry( + b"rar5-header-recovery.txt", + b"facade rar5 header encrypted recovery payload\n", + ) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())] + .to_vec(), + ) + .recovery_percent(Some(4)) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert!(!service.encrypted); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, 4); + let recovery_data = collect_rar50_file(raw, service).unwrap().data; + assert!(recovery_data.starts_with(b"{RB}")); + assert_eq!( + u32::from_le_bytes(recovery_data[0x0c..0x10].try_into().unwrap()) as usize, + recovery_data.len() + ); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!( + extracted[0].data, + b"facade rar5 header encrypted recovery payload\n" + ); + } + + #[test] + #[cfg(feature = "recovery")] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_compressed_archive_with_recovery() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload = + b"facade rar5 header encrypted compressed recovery payload repeated\n".repeat(8); + let bytes = + rar50::Rar50Writer::new(rar50_options_with_features(ArchiveVersion::Rar50, features)) + .entries( + [ + rar50_entry(b"rar5-header-compressed-recovery.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ] + .to_vec(), + ) + .recovery_percent(Some(4)) + .finish() + .unwrap(); + + assert!(matches!( + ArchiveReader::read(&bytes), + Err(Error::NeedPassword) + )); + let archive = ArchiveReader::read_with_options( + &bytes, + ArchiveReadOptions::with_password(b"password"), + ) + .unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.has_recovery_record()); + let service = raw.services().next().unwrap(); + assert_eq!(service.name, b"RR"); + assert!(!service.encrypted); + assert_eq!(service.recovery_record().unwrap().unwrap().percent, 4); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_stored_volumes() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-secret50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())], + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + 16, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-secret50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_encrypted_stored_volumes_with_recovery() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted recovery split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-secret50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())], + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + 16, + Some(8), + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-secret50-rr.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_header_encrypted_stored_volumes_with_recovery() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload = b"facade rar5 header encrypted recovery split payload\n".repeat(4); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-header-secret50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())], + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + 16, + Some(8), + ); + assert!(matches!( + rar50::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-header-secret50-rr.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_stored_volumes() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload = b"facade rar5 header encrypted split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-header-secret50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())], + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + 16, + None, + ); + assert!(matches!( + rar50::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-header-secret50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_compressed_volumes() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted compressed split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-secret-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())], + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-secret-compressed50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_encrypted_compressed_volumes_with_recovery() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 encrypted compressed recovery split payload\n".repeat(12); + let entries = [rar50_entry(b"split-secret-compressed50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec())]; + let parts = write_rar50_volume_set( + &entries, + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + Some(8), + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-secret-compressed50-rr.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_header_encrypted_compressed_volumes_with_recovery() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload = + b"facade rar5 header encrypted compressed recovery split payload\n".repeat(12); + let entries = [ + rar50_entry(b"split-header-secret-compressed50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ]; + let parts = write_rar50_volume_set( + &entries, + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + Some(8), + ); + assert!(matches!( + rar50::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!( + extracted[0].name, + b"split-header-secret-compressed50-rr.txt" + ); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_encrypted_solid_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let payload = b"facade rar5 encrypted solid compressed split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[ + rar50_entry(b"split-solid-secret-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ], + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + assert!(archives.iter().all(|archive| archive.main.is_solid())); + + let extracted = collect_rar50_volumes(&archives, Some(b"password")).unwrap(); + assert_eq!(extracted[0].name, b"split-solid-secret-compressed50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + let payload: Vec = (0..512).map(|index| (index * 37 + 11) as u8).collect(); + let parts = write_rar50_volume_set( + &[ + rar50_entry(b"split-header-secret-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ], + rar50_options_with_features(ArchiveVersion::Rar50, features), + 64, + None, + ); + assert!(matches!( + rar50::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + assert_eq!(extracted[0].name, b"split-header-secret-compressed50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn direct_writer_creates_rar50_header_encrypted_solid_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + features.solid = true; + let payload = b"facade rar5 header encrypted solid compressed split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[ + rar50_entry(b"split-header-solid-secret-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3) + .with_password(b"password".to_vec()), + ], + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + None, + ); + assert!(matches!( + rar50::Archive::parse(&parts[0]), + Err(Error::NeedPassword) + )); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse_with_password(part, Some(b"password")).unwrap()) + .collect(); + assert!(archives.iter().all(|archive| archive.main.is_solid())); + + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + assert_eq!( + extracted[0].name, + b"split-header-solid-secret-compressed50.txt" + ); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_stored_volumes() { + let payload = b"facade rar5 stored split payload\n".repeat(20); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)], + rar50_options(ArchiveVersion::Rar50).with_compression_level(0), + 80, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_stored_volumes_with_recovery() { + let features = FeatureSet::store_only(); + let payload = b"facade rar5 stored recovery split payload\n".repeat(20); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)], + rar50_options_with_features(ArchiveVersion::Rar50, features).with_compression_level(0), + 80, + Some(8), + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split50-rr.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_compressed_volumes() { + let payload: Vec = (0..512).map(|index| (index * 53 + 17) as u8).collect(); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)], + rar50_options(ArchiveVersion::Rar50), + 64, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split-compressed50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + #[cfg(feature = "recovery")] + fn direct_writer_creates_rar50_compressed_volumes_with_recovery() { + let features = FeatureSet::store_only(); + let payload: Vec = (0..512).map(|index| (index * 53 + 17) as u8).collect(); + let entries = [rar50_entry(b"split-compressed50-rr.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)]; + let parts = write_rar50_volume_set( + &entries, + rar50_options_with_features(ArchiveVersion::Rar50, features), + 64, + Some(8), + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + assert_rar50_volume_recovery_records(&archives, 8); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split-compressed50-rr.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_solid_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let payload = b"facade rar5 solid compressed split payload\n".repeat(12); + let parts = write_rar50_volume_set( + &[rar50_entry(b"split-solid-compressed50.txt", &payload) + .with_attributes(0x20) + .with_host_os(3)], + rar50_options_with_features(ArchiveVersion::Rar50, features), + 32, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + assert!(archives.iter().all(|archive| archive.main.is_solid())); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"split-solid-compressed50.txt"); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn direct_writer_creates_rar50_multi_file_solid_compressed_volumes() { + let mut features = FeatureSet::store_only(); + features.solid = true; + let mut first = b"facade rar5 multi-file solid split shared phrase\n" + .repeat(8) + .to_vec(); + first.extend_from_slice(&deterministic_noise(2048)); + let mut second = b"facade rar5 multi-file solid split shared phrase\nsecond\n" + .repeat(8) + .to_vec(); + second.extend_from_slice(&deterministic_noise(2048)); + let entries = [ + rar50_entry(b"solid-volume-one.txt", &first) + .with_attributes(0x20) + .with_host_os(3), + rar50_entry(b"solid-volume-two.txt", &second) + .with_attributes(0x20) + .with_host_os(3), + ]; + let parts = write_rar50_volume_set( + &entries, + rar50_options_with_features(ArchiveVersion::Rar50, features), + 512, + None, + ); + let archives: Vec<_> = parts + .iter() + .map(|part| rar50::Archive::parse(part).unwrap()) + .collect(); + assert!(archives.iter().all(|archive| archive.main.is_solid())); + let extracted = collect_rar50_volumes(&archives, None).unwrap(); + + assert_eq!(extracted[0].name, b"solid-volume-one.txt"); + assert_eq!(extracted[0].data, first); + assert_eq!(extracted[1].name, b"solid-volume-two.txt"); + assert_eq!(extracted[1].data, second); + } + + #[test] + fn archive_as_rar13_returns_some_only_for_rar13_family() { + let bytes = rar13::write_stored_archive( + &[rar13::StoredEntry { + name: b"old.txt", + data: b"r13 downcast", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }], + rar13_options(ArchiveVersion::Rar14), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + let raw = archive.as_rar13().unwrap(); + assert_eq!(raw.entries[0].name, b"old.txt"); + assert!(archive.as_rar15_40().is_none()); + assert!(archive.as_rar50().is_none()); + + // Other-family archives should refuse the rar13 downcast. + let rar15_bytes = rar15_40::write_stored_archive( + &[rar15_40::StoredEntry { + name: b"mid.txt", + data: b"r15 downcast", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + rar15_options(ArchiveVersion::Rar15), + ) + .unwrap(); + let rar15_archive = ArchiveReader::read(&rar15_bytes).unwrap(); + assert!(rar15_archive.as_rar13().is_none()); + + let rar50_bytes = + rar50::Rar50Writer::new(rar50_options(ArchiveVersion::Rar50).with_compression_level(0)) + .entries( + [rar50_entry(b"new.txt", b"r50 downcast") + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .finish() + .unwrap(); + let rar50_archive = ArchiveReader::read(&rar50_bytes).unwrap(); + assert!(rar50_archive.as_rar13().is_none()); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_repair_recovery_returns_full_repaired_archive_bytes() { + let bytes = std::fs::read(rar15_40_fixture("rar250_protect_head_rr5.rar")).unwrap(); + let mut damaged = bytes.clone(); + damaged[512 + 16..512 + 80].fill(0xa5); + let damaged_archive = ArchiveReader::read(&damaged).unwrap(); + + let repaired = damaged_archive.repair_recovery().unwrap(); + assert_eq!(repaired, bytes); + } + + #[test] + #[cfg(feature = "recovery")] + fn archive_facade_repair_recovery_rejects_rar13_archives() { + let bytes = rar13::write_stored_archive( + &[rar13::StoredEntry { + name: b"old.txt", + data: b"old data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }], + rar13_options(ArchiveVersion::Rar14), + ) + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + assert_eq!( + archive.repair_recovery(), + Err(Error::UnsupportedFamilyFeature { + family: ArchiveFamily::Rar13, + feature: "recovery repair for RAR 1.3/1.4 archives", + }) + ); + } + + #[test] + fn archive_reader_read_path_dispatches_to_default_options() { + // Existing tests cover read_path_with_options; this ensures the + // zero-arg convenience wrapper actually delegates to it. + let archive = + ArchiveReader::read_path(rar15_40_fixture("rar250_protect_head_rr5.rar")).unwrap(); + assert_eq!(archive.family(), ArchiveFamily::Rar15To40); + assert!(archive.as_rar15_40().unwrap().main.has_recovery_record()); + } + + #[test] + fn archive_member_can_be_read_by_index() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"first.txt".to_vec(), b"first".to_vec(), None, None) + .unwrap(); + builder + .add_bytes(b"second.txt".to_vec(), b"second".to_vec(), None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + + assert_eq!(archive.read_member_at(1, None).unwrap().unwrap(), b"second"); + assert_eq!(archive.read_member_at(2, None).unwrap(), None); + } + + #[test] + fn volume_facade_rejects_empty_and_every_mixed_family_ordering() { + let never_open = |_: &ExtractedEntryMeta| -> Result> { + panic!("invalid volume set must be rejected before opening output") + }; + let empty = Error::InvalidHeader("volume set is empty"); + assert_eq!(volume_members(&[]).unwrap_err(), empty); + assert_eq!(read_volume_members_at(&[], &[], None).unwrap_err(), empty); + assert_eq!( + extract_volumes_to(&[], None, never_open).unwrap_err(), + empty + ); + let cancellation = ReadCancellation::new(); + cancellation.cancel(); + assert_eq!( + extract_volumes_to_with_options( + &[], + ArchiveReadOptions::new().with_cancellation(&cancellation), + never_open, + ) + .unwrap_err(), + Error::Cancelled + ); + + let archives: Vec<_> = [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] + .into_iter() + .map(|version| { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap() + }) + .collect(); + for first in 0..archives.len() { + for second in 0..archives.len() { + if first == second { + continue; + } + let mixed = [archives[first].clone(), archives[second].clone()]; + let error = Error::InvalidHeader("mixed archive families in volume set"); + assert_eq!(volume_members(&mixed).unwrap_err(), error); + assert_eq!( + extract_volumes_to(&mixed, None, never_open).unwrap_err(), + error + ); + } + } + } + + #[test] + fn volume_index_reads_skip_directories_and_absent_indices_in_each_family() { + for version in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(version).store(true); + builder.add_directory(b"dir".to_vec(), None, None).unwrap(); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archives = [ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap()]; + assert_eq!(read_volume_member_at(&archives, 0, None).unwrap(), None); + assert_eq!( + read_volume_member_at(&archives, 1, None).unwrap(), + Some(b"payload".to_vec()) + ); + assert_eq!(read_volume_member_at(&archives, 2, None).unwrap(), None); + } + } + + #[test] + fn volume_members_and_index_reads_fold_split_fragments() { + let payload = vec![7; 200_000]; + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .volume_size(Some(64 * 1024)); + builder + .add_bytes(b"big.bin".to_vec(), payload.clone(), None, None) + .unwrap(); + let archives: Vec<_> = builder + .build_volumes(None) + .unwrap() + .into_iter() + .map(|part| ArchiveReader::read_owned(part).unwrap()) + .collect(); + + let members = volume_members(&archives).unwrap(); + assert_eq!( + volume_members(&archives[1..]).unwrap_err(), + Error::InvalidHeader("volume set starts with a continuation") + ); + assert_eq!(members.len(), 1); + assert_eq!(members[0].meta.name, b"big.bin"); + assert_eq!( + read_volume_member_at(&archives, 0, None).unwrap().unwrap(), + payload + ); + assert_eq!( + read_volume_members_at(&archives, &[0, 0, usize::MAX], None).unwrap(), + vec![Some(payload.clone()), Some(payload), None] + ); + } +} diff --git a/arca-rar/vendor/rars/src/member.rs b/arca-rar/vendor/rars/src/member.rs new file mode 100644 index 00000000..2c85476e --- /dev/null +++ b/arca-rar/vendor/rars/src/member.rs @@ -0,0 +1,276 @@ +//! Borrowed member traversal without copying names or format-specific records. + +use crate::{rar13, rar15_40, rar50, Archive, ArchiveMember, Result}; +use std::borrow::Cow; +use std::collections::HashMap; + +/// A member header borrowed from its archive, including all format metadata. +/// +/// Use [`Self::to_owned`] when the metadata must outlive the archive borrow. +#[derive(Debug, Clone, Copy)] +#[non_exhaustive] +pub enum ArchiveMemberRef<'a> { + /// RAR 1.3/1.4 member. + Rar13(&'a rar13::Entry), + /// RAR 1.5 through 4.x member. + Rar15To40(&'a rar15_40::FileHeader), + /// RAR 5.0 or later member. + Rar50Plus(&'a rar50::FileHeader), +} + +impl<'a> ArchiveMemberRef<'a> { + /// Exact name bytes, without copying or interpreting legacy encodings. + pub fn name_bytes(self) -> &'a [u8] { + match self { + Self::Rar13(entry) => &entry.name, + Self::Rar15To40(file) => &file.name, + Self::Rar50Plus(file) => &file.name, + } + } + + /// Whether the member is a directory. + pub fn is_directory(self) -> bool { + match self { + Self::Rar13(entry) => entry.is_directory(), + Self::Rar15To40(file) => file.is_directory(), + Self::Rar50Plus(file) => file.is_directory(), + } + } + + /// Whether the member carries a RAR5 redirection record. + pub fn is_redirection(self) -> bool { + matches!(self, Self::Rar50Plus(file) if file.is_redirection()) + } + + /// Whether this header continues a member from an earlier volume. + pub fn is_split_before(self) -> bool { + match self { + Self::Rar13(entry) => entry.is_split_before(), + Self::Rar15To40(file) => file.is_split_before(), + Self::Rar50Plus(file) => file.is_split_before(), + } + } + + /// Whether this member declares a dependency on preceding decoded history. + /// RAR 1.3 has no member flag; consult its archive main header. + pub fn is_solid(self) -> bool { + match self { + Self::Rar13(_) => false, + Self::Rar15To40(file) => file.is_solid(), + Self::Rar50Plus(file) => file.compression_info & 0x40 != 0, + } + } + + /// Whether the format supplied Unicode rather than unspecified legacy bytes. + pub fn name_is_unicode(self) -> bool { + match self { + Self::Rar13(_) => false, + Self::Rar15To40(file) => file.unicode_name.is_some(), + Self::Rar50Plus(_) => true, + } + } + + /// Display/destination name interpretation; stored identity remains unchanged. + pub fn decoded_name( + self, + encoding: Option, + ) -> Result> { + crate::filename::decoded_name(self.name_bytes(), self.name_is_unicode(), encoding) + } + + /// Copies this member's common and format-specific metadata. + pub fn to_owned(&self) -> ArchiveMember { + match *self { + Self::Rar13(entry) => crate::rar13_member(entry), + Self::Rar15To40(file) => crate::rar15_40_member(file), + Self::Rar50Plus(file) => crate::rar50_member(file), + } + } +} + +/// Lazy borrowed traversal returned by [`Archive::member_refs`]. +#[derive(Debug, Clone)] +pub struct ArchiveMemberRefs<'a> { + inner: MemberRefsInner<'a>, +} + +#[derive(Debug, Clone)] +enum MemberRefsInner<'a> { + Rar13(std::slice::Iter<'a, rar13::Entry>), + Rar15To40(std::slice::Iter<'a, rar15_40::Block>), + Rar50Plus(std::slice::Iter<'a, rar50::Block>), +} + +impl<'a> ArchiveMemberRefs<'a> { + pub(crate) fn new(archive: &'a Archive) -> Self { + let inner = match archive { + Archive::Rar13(archive) => MemberRefsInner::Rar13(archive.entries.iter()), + Archive::Rar15To40(archive) => MemberRefsInner::Rar15To40(archive.blocks.iter()), + Archive::Rar50Plus(archive) => MemberRefsInner::Rar50Plus(archive.blocks.iter()), + }; + Self { inner } + } +} + +impl<'a> Iterator for ArchiveMemberRefs<'a> { + type Item = ArchiveMemberRef<'a>; + + fn next(&mut self) -> Option { + match &mut self.inner { + MemberRefsInner::Rar13(entries) => entries.next().map(ArchiveMemberRef::Rar13), + MemberRefsInner::Rar15To40(blocks) => blocks.find_map(|block| match block { + rar15_40::Block::File(file) => Some(ArchiveMemberRef::Rar15To40(file)), + _ => None, + }), + MemberRefsInner::Rar50Plus(blocks) => blocks.find_map(|block| match block { + rar50::Block::File(file) => Some(ArchiveMemberRef::Rar50Plus(file)), + _ => None, + }), + } + } +} + +/// An optional index borrowing immutable archive headers and name bytes. +/// +/// Construction traverses headers once and allocates caller-owned index storage. +/// Indexed metadata lookup does not allocate or traverse preceding members. +/// Duplicate entries retain their archive-order indices. Name lookup selects the +/// last entry, while payload lookup excludes directories and redirections. +/// Payload decoding still uses the archive's extraction policies. +#[derive(Debug)] +pub struct ArchiveIndex<'a> { + members: Vec>, + names: HashMap<&'a [u8], NameIndices>, +} + +#[derive(Debug, Default)] +struct NameIndices { + last: usize, + payload: Option, +} + +impl<'a> ArchiveIndex<'a> { + pub(crate) fn new(archive: &'a Archive) -> Self { + let members: Vec<_> = archive.member_refs().collect(); + let mut names: HashMap<&[u8], NameIndices> = HashMap::new(); + for (index, member) in members.iter().enumerate() { + let indices = names.entry(member.name_bytes()).or_default(); + indices.last = index; + if !member.is_directory() && !member.is_redirection() { + indices.payload = Some(index); + } + } + Self { members, names } + } + + /// Number of members, including directories and redirections. + pub fn len(&self) -> usize { + self.members.len() + } + + /// Whether the archive contains no members. + pub fn is_empty(&self) -> bool { + self.members.is_empty() + } + + /// Borrows metadata for an archive-order index without copying it. + pub fn get(&self, index: usize) -> Option> { + self.members.get(index).copied() + } + + /// Archive-order index of the last entry with this exact stored name. + pub fn index_of(&self, name: &[u8]) -> Option { + self.names.get(name).map(|indices| indices.last) + } + + /// Last payload index, matching [`Archive::read_member`] selection. + /// A later directory or redirection with the same name does not hide a file. + pub fn payload_index_of(&self, name: &[u8]) -> Option { + self.names.get(name).and_then(|indices| indices.payload) + } + + /// All borrowed member headers in archive order. + pub fn members(&self) -> &[ArchiveMemberRef<'a>] { + &self.members + } +} + +#[cfg(all(test, feature = "write"))] +mod tests { + use crate::{ArchiveReader, ArchiveVersion, Builder}; + + #[test] + fn borrowed_members_preserve_metadata_and_archive_order_across_families() { + for version in ArchiveVersion::ALL { + let mut builder = Builder::new(version).store(true); + builder.add_directory(b"dir".to_vec(), None, None).unwrap(); + builder + .add_bytes(b"dir/file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let members: Vec<_> = archive.member_refs().collect(); + assert_eq!(members.len(), 2, "{version}"); + assert!(members[0].is_directory()); + assert!(!members[1].is_directory()); + assert_eq!(members[1].name_bytes(), b"dir/file"); + for (borrowed, owned) in members.iter().zip(archive.members()) { + assert_eq!(borrowed.to_owned(), owned); + assert_eq!(borrowed.is_solid(), owned.is_solid()); + assert_eq!(borrowed.name_is_unicode(), owned.name_is_unicode()); + assert_eq!(borrowed.is_redirection(), owned.meta.is_redirection); + assert_eq!( + borrowed.decoded_name(None).unwrap().as_ref(), + owned.meta.name + ); + assert!(std::ptr::eq( + borrowed.name_bytes().as_ptr(), + archive + .member_refs() + .find(|m| m.name_bytes() == borrowed.name_bytes()) + .unwrap() + .name_bytes() + .as_ptr(), + )); + } + let mut owned = archive.members(); + assert_eq!(owned.nth(1).unwrap().meta.name, b"dir/file"); + assert_eq!(owned.next(), None); + assert_eq!( + archive.read_member_at(1, None).unwrap().unwrap(), + b"payload" + ); + } + } + + #[test] + fn member_index_preserves_duplicates_and_distinguishes_payload_lookup() { + for version in ArchiveVersion::ALL { + let mut builder = Builder::new(version) + .store(true) + .allow_duplicate_names(true); + for data in [b"first".as_slice(), b"second"] { + builder + .add_bytes(b"same".to_vec(), data.to_vec(), None, None) + .unwrap(); + } + builder.add_directory(b"same".to_vec(), None, None).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let index = archive.index(); + assert_eq!(index.len(), 3, "{version}"); + assert!(!index.is_empty()); + assert_eq!(index.index_of(b"same"), Some(2)); + assert_eq!(index.payload_index_of(b"same"), Some(1)); + assert_eq!(index.index_of(b"missing"), None); + assert_eq!(index.payload_index_of(b"missing"), None); + assert_eq!(index.get(0).unwrap().to_owned().meta.unpacked_size, 5); + assert_eq!(index.get(1).unwrap().to_owned().meta.unpacked_size, 6); + assert!(index.get(2).unwrap().is_directory()); + assert!(index.get(3).is_none()); + assert_eq!(index.members().len(), 3); + assert_eq!( + archive.read_member(b"same", None).unwrap().unwrap(), + b"second" + ); + } + } +} diff --git a/arca-rar/vendor/rars/src/member_read.rs b/arca-rar/vendor/rars/src/member_read.rs new file mode 100644 index 00000000..409a7069 --- /dev/null +++ b/arca-rar/vendor/rars/src/member_read.rs @@ -0,0 +1,206 @@ +//! Several selected payloads decoded through one extraction session. + +use crate::{Archive, ArchiveReadOptions, ExtractionDecision, Result, SharedBuffer}; +use std::collections::BTreeMap; +use std::io::Write; +use std::sync::{Arc, Mutex}; + +type Bytes = Arc>>>; + +struct SelectedBuffer { + first_position: usize, + duplicates: Vec, + bytes: Bytes, +} + +struct ReadBatch { + buffers: BTreeMap, + length: usize, +} + +impl ReadBatch { + fn new(indices: &[usize]) -> Self { + let mut buffers = BTreeMap::::new(); + for (position, &index) in indices.iter().enumerate() { + buffers + .entry(index) + .and_modify(|buffer| buffer.duplicates.push(position)) + .or_insert_with(|| SelectedBuffer { + first_position: position, + duplicates: Vec::new(), + bytes: Arc::new(Mutex::new(None)), + }); + } + Self { + buffers, + length: indices.len(), + } + } + + fn contains(&self, index: usize) -> bool { + self.buffers.contains_key(&index) + } + + fn writer(&self, index: usize) -> Option> { + let buffer = self.buffers.get(&index)?; + *buffer + .bytes + .lock() + .expect("member buffer mutex is not poisoned") = Some(Vec::new()); + Some(Box::new(SharedBuffer(Arc::clone(&buffer.bytes)))) + } + + fn finish(self) -> Vec>> { + let mut result = vec![None; self.length]; + for buffer in self.buffers.into_values() { + if let Some(bytes) = buffer + .bytes + .lock() + .expect("member buffer mutex is not poisoned") + .take() + { + for position in buffer.duplicates { + result[position] = Some(bytes.clone()); + } + // Unique selections transfer their output without a payload copy. + result[buffer.first_position] = Some(bytes); + } + } + result + } +} + +impl Archive { + /// Whether archive or member headers declare solid decoding dependencies. + /// This uses the same conservative policy as controlled extraction. + pub fn is_solid(&self) -> bool { + let main_solid = match self { + Self::Rar13(archive) => archive.main.is_solid(), + Self::Rar15To40(archive) => archive.main.is_solid(), + Self::Rar50Plus(archive) => archive.main.is_solid(), + }; + main_solid || self.member_refs().any(|member| member.is_solid()) + } + + /// Reads several members by archive-order index using one decoder session. + /// See [`Self::read_members_at_with_options`] for selection and budget rules. + pub fn read_members_at( + &self, + indices: &[usize], + password: Option<&[u8]>, + ) -> Result>>> { + self.read_members_at_with_options( + indices, + ArchiveReadOptions::with_optional_password(password), + ) + } + + /// Reads selected payloads in one pass, avoiding repeated solid-prefix decoding. + /// + /// Results follow the requested order, including duplicate indices. Missing + /// members, directories and redirections return `None`. Each selected payload + /// is decoded once; repeated results copy its verified bytes. Independent + /// unselected payloads are skipped. Solid predecessors are decoded and + /// verified once, even when their output is discarded. + /// + /// Output budgets are shared across this call and include all decoded bytes; + /// returning another copy of a selected payload does not decode it again or + /// consume logical output quota again. Result buffers are caller output, not + /// decoder workspace. No buffers are returned if any selected payload or + /// required predecessor fails. Cancellation is checked for empty selections. + pub fn read_members_at_with_options( + &self, + indices: &[usize], + options: ArchiveReadOptions<'_>, + ) -> Result>>> { + options.check_cancelled()?; + let batch = ReadBatch::new(indices); + if indices.is_empty() { + return Ok(batch.finish()); + } + let last = self + .member_refs() + .enumerate() + .filter(|(index, member)| { + batch.contains(*index) && !member.is_directory() && !member.is_redirection() + }) + .map(|(index, _)| index) + .last(); + let Some(last) = last else { + return Ok(batch.finish()); + }; + let solid = self.is_solid(); + let mut current = 0; + self.extract_with_control(options, |member| { + let index = current; + current += 1; + if index > last { + return Ok(ExtractionDecision::Stop); + } + if member.meta.is_directory || member.meta.is_redirection { + return Ok(ExtractionDecision::Skip); + } + if let Some(writer) = batch.writer(index) { + return Ok(ExtractionDecision::Extract(writer)); + } + Ok(if solid { + ExtractionDecision::Extract(Box::new(std::io::sink())) + } else { + ExtractionDecision::Skip + }) + })?; + Ok(batch.finish()) + } +} + +// Redirections have logical indices but do not open volume extraction writers. +// Continuation headers share the logical index of their first fragment. +pub(crate) fn volume_output_indices(archives: &[Archive]) -> impl Iterator + '_ { + archives + .iter() + .flat_map(Archive::member_refs) + .filter(|member| !member.is_split_before()) + .enumerate() + .filter_map(|(index, member)| (!member.is_redirection()).then_some(index)) +} + +/// Reads several logical volume members in one traversal of the volume set. +/// See [`read_volume_members_at_with_options`] for budget and selection rules. +pub fn read_volume_members_at( + archives: &[Archive], + indices: &[usize], + password: Option<&[u8]>, +) -> Result>>> { + read_volume_members_at_with_options( + archives, + indices, + ArchiveReadOptions::with_optional_password(password), + ) +} + +/// Reads selected logical volume members, preserving order and duplicate indices. +/// +/// Missing members, directories and redirections return `None`. The current +/// volume traversal decodes and verifies the whole set, including unselected +/// payloads and empty selections; discarded output counts against shared quotas. +/// Each payload is decoded once. Copies returned for repeated indices do not +/// consume additional logical output quota. No result buffers escape on failure. +pub fn read_volume_members_at_with_options( + archives: &[Archive], + indices: &[usize], + options: ArchiveReadOptions<'_>, +) -> Result>>> { + options.check_cancelled()?; + let batch = ReadBatch::new(indices); + let mut output_indices = volume_output_indices(archives); + crate::extract_volumes_to_with_options(archives, options, |meta| { + let index = output_indices.next(); + if !meta.is_directory { + if let Some(writer) = index.and_then(|index| batch.writer(index)) { + return Ok(writer); + } + } + Ok(Box::new(std::io::sink())) + })?; + Ok(batch.finish()) +} diff --git a/arca-rar/vendor/rars/src/output_limit.rs b/arca-rar/vendor/rars/src/output_limit.rs new file mode 100644 index 00000000..6a0dd71c --- /dev/null +++ b/arca-rar/vendor/rars/src/output_limit.rs @@ -0,0 +1,483 @@ +//! Output admission and a writer guard whose error survives I/O adapters. +#[cfg(test)] +use crate::ArchiveReadOptions; +use crate::{Error, Result}; +use std::io::{self, Write}; + +pub(crate) fn check(limit: Option, required: u64, name: &[u8]) -> Result<()> { + if let Some(limit) = limit.filter(|limit| required > *limit) { + return Err(error(limit, required, name)); + } + Ok(()) +} + +fn error(limit: u64, required: u64, name: &[u8]) -> Error { + Error::MemberOutputLimitExceeded { limit, required }.at_entry(name.to_vec(), "limiting output") +} + +/// Owned by one sequential extraction operation, including all its volumes. +/// Declarations admit work; only bytes accepted by the logical output sink charge it. +pub(crate) struct OutputBudget { + pub(crate) control: crate::read_control::ReadControl, + member_limit: Option, + total_limit: Option, + used: u64, +} + +impl OutputBudget { + pub(crate) fn new(options: crate::ArchiveReadOptions<'_>) -> Self { + Self { + control: crate::read_control::ReadControl::new(options.cancellation), + member_limit: options.max_member_output_bytes, + total_limit: options.max_total_output_bytes, + used: 0, + } + } + + pub(crate) fn is_limited(&self) -> bool { + self.member_limit.is_some() || self.total_limit.is_some() + } + + pub(crate) fn check(&self, required: u64, name: &[u8]) -> Result<()> { + self.control.check()?; + check(self.member_limit, required, name)?; + if let Some(limit) = self.total_limit { + if required > limit - self.used { + return Err(self + .total_error(limit, required) + .at_entry(name.to_vec(), "limiting output")); + } + } + Ok(()) + } + + fn total_error(&self, limit: u64, additional: u64) -> Error { + Error::TotalOutputLimitExceeded { + limit, + required: self.used.saturating_add(additional), + used: self.used, + } + } + + pub(crate) fn run( + &mut self, + name: &[u8], + writer: W, + work: impl FnOnce(&mut LimitedWriter<'_, W>) -> Result, + ) -> Result { + self.control.check()?; + let mut guarded = LimitedWriter { + writer, + budget: self, + written: 0, + exceeded: None, + sink_error: None, + }; + let result = work(&mut guarded); + // Older decoders/error adapters may wrap or replace the sentinel. Keep + // the refusal out of band so it cannot become bad-password/checksum/I/O. + // Also preserve destination failures that legacy codecs turn into + // generic decode errors, including the original I/O source. + match (guarded.exceeded, guarded.sink_error) { + (Some(error), _) => Err(error.at_entry(name.to_vec(), "limiting output")), + (None, Some(error)) => Err(error.at_entry(name.to_vec(), "extracting")), + (None, None) => guarded + .budget + .control + .finish(result) + .and_then(|value| guarded.budget.control.check().map(|()| value)) + .map_err(|error| { + if error.kind() == crate::ErrorKind::Cancelled + && error.entry_context().is_none() + { + error.at_entry(name.to_vec(), "extracting") + } else { + error + } + }), + } + } +} + +#[cfg(test)] +pub(crate) fn run( + limit: Option, + name: &[u8], + writer: W, + work: impl FnOnce(&mut LimitedWriter<'_, W>) -> Result, +) -> Result { + let mut options = ArchiveReadOptions::new(); + options.max_member_output_bytes = limit; + OutputBudget::new(options).run(name, writer, work) +} + +pub(crate) struct LimitedWriter<'a, W> { + writer: W, + budget: &'a mut OutputBudget, + written: u64, + exceeded: Option, + sink_error: Option, +} + +impl LimitedWriter<'_, W> { + fn remember_sink_result(&mut self, result: io::Result) -> io::Result { + result.map_err(|error| { + // write_all retries Interrupted; it is not a terminal sink failure. + if error.kind() == io::ErrorKind::Interrupted { + return error; + } + let kind = error.kind(); + let error = Error::from(error); + self.sink_error.get_or_insert_with(|| error.clone()); + io::Error::new(kind, error) + }) + } + + fn write_sink(&mut self, bytes: &[u8]) -> io::Result { + let result = match self.writer.write(bytes) { + Ok(0) if !bytes.is_empty() => Err(io::ErrorKind::WriteZero.into()), + result => result, + }; + self.remember_sink_result(result) + } +} + +impl Write for LimitedWriter<'_, W> { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.budget.control.check().map_err(io::Error::other)?; + if !self.budget.is_limited() { + let len = if self.budget.control.is_enabled() { + bytes.len().min(64 * 1024) + } else { + bytes.len() + }; + return self.write_sink(&bytes[..len]); + } + if self.exceeded.is_none() { + let count = bytes.len() as u64; + if let Some(limit) = self.budget.member_limit { + if count > limit - self.written { + self.exceeded = Some(Error::MemberOutputLimitExceeded { + limit, + required: self.written.saturating_add(count), + }); + } + } + if self.exceeded.is_none() { + if let Some(limit) = self.budget.total_limit { + if count > limit - self.budget.used { + self.exceeded = Some(self.budget.total_error(limit, count)); + } + } + } + } + if self.exceeded.is_some() { + return Err(io::Error::other("output limit exceeded")); + } + let len = if self.budget.control.is_enabled() { + bytes.len().min(64 * 1024) + } else { + bytes.len() + }; + let n = self.write_sink(&bytes[..len])?; + if self.budget.member_limit.is_some() { + self.written += n as u64; + } + if self.budget.total_limit.is_some() { + self.budget.used += n as u64; + } + Ok(n) + } + fn flush(&mut self) -> io::Result<()> { + self.budget.control.check().map_err(io::Error::other)?; + let result = self.writer.flush(); + self.remember_sink_result(result) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn interrupted_sink_writes_retry_without_latching_a_failure() { + struct InterruptedOnce(bool); + impl Write for InterruptedOnce { + fn write(&mut self, bytes: &[u8]) -> io::Result { + if std::mem::replace(&mut self.0, false) { + Err(io::ErrorKind::Interrupted.into()) + } else { + Ok(bytes.len()) + } + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + let mut budget = + OutputBudget::new(ArchiveReadOptions::new().with_max_total_output_bytes(3)); + budget + .run(b"member", InterruptedOnce(true), |w| { + w.write_all(b"abc").map_err(Error::from) + }) + .unwrap(); + assert_eq!(budget.used, 3); + } + + #[test] + fn zero_writes_and_flush_errors_survive_lossy_codec_adapters() { + struct Broken; + impl Write for Broken { + fn write(&mut self, _: &[u8]) -> io::Result { + Ok(0) + } + fn flush(&mut self) -> io::Result<()> { + Err(io::ErrorKind::PermissionDenied.into()) + } + } + for flush in [false, true] { + let mut budget = OutputBudget::new(ArchiveReadOptions::new()); + let error = budget + .run(b"member", Broken, |w| { + assert_eq!(w.write(b"").unwrap(), 0); + if flush { + assert!(w.flush().is_err()); + } else { + assert!(w.write_all(b"a").is_err()); + } + Err::<(), _>(Error::InvalidHeader("lossy adapter")) + }) + .unwrap_err(); + let expected = if flush { + io::ErrorKind::PermissionDenied + } else { + io::ErrorKind::WriteZero + }; + assert!(matches!(error.root_cause(), Error::Io(e) if e.kind == expected)); + assert_eq!(error.entry_context().unwrap().0, b"member"); + } + } + + #[test] + fn cancellation_survives_adapters_without_refunding_or_hiding_quota_refusal() { + let token = crate::ReadCancellation::new(); + let mut budget = OutputBudget::new( + ArchiveReadOptions::new() + .with_cancellation(&token) + .with_max_total_output_bytes(4), + ); + let err = budget + .run(b"member", io::sink(), |w| { + w.write_all(b"ab")?; + token.cancel(); + assert!(w.write_all(b"c").is_err()); + Err::<(), _>(Error::WrongPasswordOrCorruptData) + }) + .unwrap_err(); + assert_eq!(err.kind(), crate::ErrorKind::Cancelled); + assert_eq!(err.entry_context().unwrap().0, b"member"); + assert_eq!(budget.used, 2); + + let token = crate::ReadCancellation::new(); + let mut budget = OutputBudget::new( + ArchiveReadOptions::new() + .with_cancellation(&token) + .with_max_total_output_bytes(0), + ); + let err = budget + .run(b"member", io::sink(), |w| { + assert!(w.write_all(b"a").is_err()); + token.cancel(); + assert!(w.write_all(b"b").is_err()); + Err::<(), _>(Error::WrongPasswordOrCorruptData) + }) + .unwrap_err(); + assert_eq!(err.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(budget.used, 0); + } + #[test] + fn total_accounting_survives_short_writes_and_later_errors() { + struct Short; + impl Write for Short { + fn write(&mut self, b: &[u8]) -> io::Result { + Ok(b.len().min(1)) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + let mut budget = + OutputBudget::new(ArchiveReadOptions::new().with_max_total_output_bytes(6)); + budget.check(6, b"first").unwrap(); + // Admission is not a charge, and short writes do not count offered bytes twice. + assert_eq!(budget.used, 0); + let err = budget + .run(b"first", Short, |w| { + w.write_all(b"abc")?; + Err::<(), _>(Error::Crc32Mismatch { + expected: 1, + actual: 2, + }) + }) + .unwrap_err(); + assert!(matches!(err, Error::Crc32Mismatch { .. })); + assert_eq!(budget.used, 3); + budget.check(3, b"second").unwrap(); + let err = budget + .run(b"second", io::sink(), |w| { + w.write_all(b"d")?; + assert!(w.write_all(b"efg").is_err()); + assert!(w.write_all(b"x").is_err()); + Err::<(), _>(Error::WrongPasswordOrCorruptData) + }) + .unwrap_err(); + let err = Error::InVolume { + number: 2, + source: Box::new(err), + }; + assert_eq!(budget.used, 4); + assert_eq!(err.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(err.entry_context().unwrap().0, b"second"); + assert!(matches!( + err.root_cause(), + Error::TotalOutputLimitExceeded { + limit: 6, + used: 4, + required: 7 + } + )); + } + + #[test] + fn total_admission_and_runtime_use_overflow_safe_arithmetic() { + let mut budget = + OutputBudget::new(ArchiveReadOptions::new().with_max_total_output_bytes(u64::MAX)); + budget.used = u64::MAX - 1; + budget.check(1, b"member").unwrap(); + let err = budget.check(2, b"member").unwrap_err(); + assert!( + matches!(err.root_cause(), Error::TotalOutputLimitExceeded { limit:u64::MAX, required:u64::MAX, used } if *used == u64::MAX - 1) + ); + budget + .run(b"member", io::sink(), |w| { + w.write_all(b"x")?; + Ok(()) + }) + .unwrap(); + budget.check(0, b"empty").unwrap(); + let err = budget + .run(b"member", io::sink(), |w| { + w.write_all(b"x")?; + Ok(()) + }) + .unwrap_err(); + assert!(matches!( + err.root_cause(), + Error::TotalOutputLimitExceeded { used: u64::MAX, .. } + )); + } + + #[test] + fn member_precedence_and_total_only_refusal() { + for (member, expected_member) in [(2, true), (3, false)] { + let mut budget = OutputBudget::new( + ArchiveReadOptions::new() + .with_max_member_output_bytes(member) + .with_max_total_output_bytes(2), + ); + for err in [ + budget.check(3, b"member").unwrap_err(), + budget + .run(b"member", io::sink(), |w| { + w.write_all(b"abc")?; + Ok(()) + }) + .unwrap_err(), + ] { + assert_eq!( + matches!(err.root_cause(), Error::MemberOutputLimitExceeded { .. }), + expected_member + ); + assert_eq!(err.kind(), crate::ErrorKind::ResourceLimit); + } + assert_eq!(budget.used, 0); + } + } + + #[test] + fn total_guard_keeps_real_sink_errors_and_empty_output() { + let mut budget = + OutputBudget::new(ArchiveReadOptions::new().with_max_total_output_bytes(3)); + let mut empty = [].as_mut_slice(); + let err = budget + .run(b"member", &mut empty, |w| { + w.write_all(b"a")?; + Ok(()) + }) + .unwrap_err(); + assert!(matches!(err.root_cause(), Error::Io(e) if e.kind == io::ErrorKind::WriteZero)); + assert_eq!(budget.used, 0); + let mut zero = OutputBudget::new(ArchiveReadOptions::new().with_max_total_output_bytes(0)); + zero.run(b"empty", io::sink(), |w| { + assert_eq!(w.write(b"")?, 0); + Ok(()) + }) + .unwrap(); + assert_eq!(zero.used, 0); + } + #[test] + fn refusal_is_latched_and_restored_after_error_remapping() { + let mut out = Vec::new(); + let err = run(Some(3), b"member", &mut out, |w| { + w.write_all(b"ab")?; + assert!(w.write_all(b"cd").is_err()); + assert!(w.write_all(b"x").is_err()); + Err::<(), _>(Error::WrongPasswordOrCorruptData) + }) + .unwrap_err(); + assert_eq!(out, b"ab"); + assert!(matches!( + err.root_cause(), + Error::MemberOutputLimitExceeded { + limit: 3, + required: 4 + } + )); + assert_eq!(err.kind(), crate::ErrorKind::ResourceLimit); + } + #[test] + fn partial_writes_count_only_accepted_bytes_and_keep_sink_errors() { + struct Short(Vec); + impl Write for Short { + fn write(&mut self, b: &[u8]) -> io::Result { + if self.0.len() == 3 { + return Err(io::ErrorKind::PermissionDenied.into()); + } + let n = b.len().min(1); + self.0.extend_from_slice(&b[..n]); + Ok(n) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + let mut out = Short(Vec::new()); + let err = run(Some(4), b"member", &mut out, |w| { + w.write_all(b"abcd")?; + Ok(()) + }) + .unwrap_err(); + assert_eq!(out.0, b"abc"); + assert!( + matches!(err.root_cause(), Error::Io(e) if e.kind == io::ErrorKind::PermissionDenied) + ); + let mut out = Vec::new(); + run(Some(3), b"member", &mut out, |w| { + w.write_all(b"abc")?; + Ok(()) + }) + .unwrap(); + assert_eq!(out, b"abc"); + check(Some(u64::MAX), u64::MAX, b"member").unwrap(); + } +} diff --git a/arca-rar/vendor/rars/src/parallel.rs b/arca-rar/vendor/rars/src/parallel.rs new file mode 100644 index 00000000..760c2fa6 --- /dev/null +++ b/arca-rar/vendor/rars/src/parallel.rs @@ -0,0 +1,376 @@ +//! Fan-out helpers, and the one place that knows whether there is anything to +//! fan out to. +//! +//! Without the `parallel` feature these helpers run sequentially. +//! Bare WebAssembly also has no threads: `wasm32-unknown-unknown` has no way to +//! start one, so rayon's pool panics the first time it is touched rather than +//! degrading. The `sequential` module below is the same three functions done in +//! sequence, and rayon is not compiled in at all for that target. + +#[cfg(any( + not(feature = "parallel"), + all(target_arch = "wasm32", target_os = "unknown") +))] +pub(crate) use sequential::*; +#[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) +))] +pub(crate) use threaded::*; + +#[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) +))] +mod threaded { + use rayon::prelude::*; + + /// Process preallocated slots without allocating a separate result vector. + /// Returns only after every admitted callback has finished. + pub(crate) fn for_each_mut(items: &mut [T], apply: F) + where + T: Send, + F: Fn(usize, &mut T) + Sync + Send, + { + items + .par_iter_mut() + .enumerate() + .for_each(|(index, item)| apply(index, item)); + } + + /// Maps `items` in parallel and returns, in order, the outputs before the + /// first failure together with that failure, so a caller can still publish + /// the successful prefix. + pub(crate) fn map_prefix(items: Vec, map: F) -> (Vec, Option) + where + T: Send, + O: Send, + E: Send, + F: Fn(T) -> Result + Sync + Send, + { + let mut outputs = Vec::with_capacity(items.len()); + for result in items.into_par_iter().map(map).collect::>() { + match result { + Ok(output) => outputs.push(output), + Err(error) => return (outputs, Some(error)), + } + } + (outputs, None) + } + + /// Maps `items` in parallel but keeps only a window of results alive, + /// handing each to `consume` in order before starting the next window. + /// + /// Mapping everything up front is simpler, but it holds every result at + /// once; when the results are compressed file payloads that is the + /// difference between one copy of the archive in memory and two. + #[cfg(any(test, feature = "write"))] + pub(crate) fn map_slice_windowed<'a, T, O, E, F, C>( + items: &'a [T], + window: usize, + map: F, + mut consume: C, + ) -> Result<(), E> + where + T: Sync + 'a, + O: Send, + E: Send, + F: Fn(&'a T) -> Result + Sync + Send, + C: FnMut(&'a T, O) -> Result<(), E>, + { + let window = window.max(1); + for chunk in items.chunks(window) { + let mapped: Vec = chunk.par_iter().map(&map).collect::>()?; + for (item, output) in chunk.iter().zip(mapped) { + consume(item, output)?; + } + } + Ok(()) + } + + /// How many members to keep in flight at once. + pub(crate) fn default_window() -> usize { + threads() + } + + /// How many members can be worked on at the same time. + pub(crate) fn threads() -> usize { + rayon::current_num_threads().max(1) + } +} + +#[cfg(any( + test, + not(feature = "parallel"), + all(target_arch = "wasm32", target_os = "unknown") +))] +mod sequential { + /// Process preallocated slots without allocating a separate result vector. + /// Returns only after every admitted callback has finished. + pub(crate) fn for_each_mut(items: &mut [T], apply: F) + where + T: Send, + F: Fn(usize, &mut T) + Sync + Send, + { + items + .iter_mut() + .enumerate() + .for_each(|(index, item)| apply(index, item)); + } + + pub(crate) fn map_prefix(items: Vec, map: F) -> (Vec, Option) + where + T: Send, + O: Send, + E: Send, + F: Fn(T) -> Result + Sync + Send, + { + let mut outputs = Vec::with_capacity(items.len()); + for item in items { + match map(item) { + Ok(output) => outputs.push(output), + Err(error) => return (outputs, Some(error)), + } + } + (outputs, None) + } + + /// One at a time, so the window only decides how much output is alive at + /// once rather than how much work runs at once. + #[cfg(any(test, feature = "write"))] + pub(crate) fn map_slice_windowed<'a, T, O, E, F, C>( + items: &'a [T], + _window: usize, + map: F, + mut consume: C, + ) -> Result<(), E> + where + T: Sync + 'a, + O: Send, + E: Send, + F: Fn(&'a T) -> Result + Sync + Send, + C: FnMut(&'a T, O) -> Result<(), E>, + { + for item in items { + let output = map(item)?; + consume(item, output)?; + } + Ok(()) + } + + pub(crate) fn default_window() -> usize { + 1 + } + + #[cfg(any(test, feature = "write"))] + pub(crate) fn threads() -> usize { + 1 + } +} + +#[cfg(test)] +mod tests { + use super::sequential; + + #[test] + fn sequential_slots_and_collect_keep_order_and_stop_on_error() { + let mut slots = [7, 7, 7]; + sequential::for_each_mut(&mut slots, |index, slot| *slot += index); + assert_eq!(slots, [7, 8, 9]); + sequential::for_each_mut::(&mut [], |_, _| panic!("empty callback")); + let mapped = sequential::map_prefix(vec![3, 1, 2], |x| Ok::<_, ()>(x * 2)); + assert_eq!(mapped, (vec![6, 2, 4], None)); + let empty = sequential::map_prefix(Vec::::new(), |_| -> Result { + panic!("empty map") + }); + assert_eq!(empty, (vec![], None)); + let visited = std::sync::Mutex::new(Vec::new()); + let mapped = sequential::map_prefix(vec![3, 1, 2], |x| { + visited.lock().unwrap().push(x); + if x == 1 { + Err(11) + } else { + Ok(x) + } + }); + assert_eq!(mapped, (vec![3], Some(11))); + assert_eq!(*visited.lock().unwrap(), [3, 1]); + assert_eq!(sequential::default_window(), 1); + assert_eq!(sequential::threads(), 1); + } + + #[test] + fn sequential_windows_publish_in_order_and_preserve_both_failure_kinds() { + let input = [3, 1, 2]; + for window in [0, 1, 8] { + let mut emitted = vec![]; + let result: Result<(), ()> = sequential::map_slice_windowed( + &input, + window, + |x| Ok(x * 2), + |x, y| { + emitted.push((*x, y)); + Ok(()) + }, + ); + assert_eq!(result, Ok(())); + assert_eq!(emitted, [(3, 6), (1, 2), (2, 4)]); + } + let mut emitted = vec![]; + let result = sequential::map_slice_windowed( + &input, + 2, + |x| if *x == 1 { Err(11) } else { Ok(x * 2) }, + |x, y| { + emitted.push((*x, y)); + Ok(()) + }, + ); + assert_eq!(result, Err(11)); + assert_eq!(emitted, [(3, 6)]); + let mut emitted = vec![]; + let visited = std::sync::Mutex::new(Vec::new()); + let result = sequential::map_slice_windowed( + &input, + 2, + |x| { + visited.lock().unwrap().push(*x); + Ok(x * 2) + }, + |x, y| { + emitted.push((*x, y)); + if *x == 1 { + Err(12) + } else { + Ok(()) + } + }, + ); + assert_eq!(result, Err(12)); + assert_eq!(emitted, [(3, 6), (1, 2)]); + assert_eq!(*visited.lock().unwrap(), [3, 1]); + let empty: Result<(), ()> = sequential::map_slice_windowed::( + &[], + 0, + |_| panic!("empty map"), + |_, _| panic!("empty consume"), + ); + assert_eq!(empty, Ok(())); + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn threaded_windows_preserve_order_and_wait_for_admitted_callbacks() { + use std::sync::atomic::{AtomicUsize, Ordering}; + use std::sync::Mutex; + let input = [3, 1, 2, 4]; + let active = AtomicUsize::new(0); + struct Active<'a>(&'a AtomicUsize); + impl Drop for Active<'_> { + fn drop(&mut self) { + self.0.fetch_sub(1, Ordering::Relaxed); + } + } + for window in [0, 1, 2, 8] { + let mut emitted = Vec::new(); + let result: Result<(), ()> = super::threaded::map_slice_windowed( + &input, + window, + |x| { + active.fetch_add(1, Ordering::Relaxed); + let _active = Active(&active); + Ok(x * 2) + }, + |x, y| { + emitted.push((*x, y)); + Ok(()) + }, + ); + assert_eq!(result, Ok(())); + assert_eq!(emitted, [(3, 6), (1, 2), (2, 4), (4, 8)]); + assert_eq!(active.load(Ordering::Acquire), 0); + } + let mut emitted = Vec::new(); + let result = super::threaded::map_slice_windowed( + &input, + 2, + |x| { + active.fetch_add(1, Ordering::Relaxed); + let _active = Active(&active); + if *x == 2 { + Err(11) + } else { + Ok(x * 2) + } + }, + |x, y| { + emitted.push((*x, y)); + Ok(()) + }, + ); + assert_eq!(result, Err(11)); + // A mapping failure discards the whole failed window. Earlier windows + // are already published, and every admitted mapping has returned. + assert_eq!(emitted, [(3, 6), (1, 2)]); + assert_eq!(active.load(Ordering::Acquire), 0); + + let visited = Mutex::new(Vec::new()); + emitted.clear(); + let result = super::threaded::map_slice_windowed( + &input, + 2, + |x| { + visited.lock().unwrap().push(*x); + Ok(x * 2) + }, + |x, y| { + emitted.push((*x, y)); + if *x == 1 { + Err(12) + } else { + Ok(()) + } + }, + ); + assert_eq!(result, Err(12)); + assert_eq!(emitted, [(3, 6), (1, 2)]); + let mut visited = visited.into_inner().unwrap(); + visited.sort_unstable(); + assert_eq!( + visited, + [1, 3], + "later windows must not start after consumer failure" + ); + + emitted.clear(); + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _: Result<(), ()> = super::threaded::map_slice_windowed( + &input, + 2, + |x| { + active.fetch_add(1, Ordering::Relaxed); + let _active = Active(&active); + assert_ne!(*x, 2, "injected map panic"); + Ok(x * 2) + }, + |x, y| { + emitted.push((*x, y)); + Ok(()) + }, + ); + })); + assert!(result.is_err()); + assert_eq!(emitted, [(3, 6), (1, 2)]); + assert_eq!(active.load(Ordering::Acquire), 0); + let empty: Result<(), ()> = super::threaded::map_slice_windowed::( + &[], + 0, + |_| panic!("empty map"), + |_, _| panic!("empty consume"), + ); + assert_eq!(empty, Ok(())); + } +} diff --git a/arca-rar/vendor/rars/src/parse_budget.rs b/arca-rar/vendor/rars/src/parse_budget.rs new file mode 100644 index 00000000..4940e56d --- /dev/null +++ b/arca-rar/vendor/rars/src/parse_budget.rs @@ -0,0 +1,154 @@ +//! Header admission for one physical archive parse, before full-body allocation. +use crate::{ArchiveReadOptions, Error, Result}; + +pub(crate) struct ParseBudget { + pub(crate) control: crate::read_control::ReadControl, + count_limit: Option, + byte_limit: Option, + count: u64, + bytes: u64, +} + +impl ParseBudget { + pub(crate) fn new(options: ArchiveReadOptions<'_>) -> Self { + Self { + control: crate::read_control::ReadControl::new(options.cancellation), + count_limit: options.max_header_count, + byte_limit: options.max_header_bytes, + count: 0, + bytes: 0, + } + } + + pub(crate) fn is_limited(&self) -> bool { + self.count_limit.is_some() || self.byte_limit.is_some() + } + + // Encrypted readers can check count before deriving keys/decrypting a prefix. + pub(crate) fn check_count(&self, offset: usize) -> Result<()> { + self.control.check()?; + if let Some(limit) = self.count_limit { + if self.count == limit { + return Err(Error::HeaderCountLimitExceeded { + limit, + required: self.count.saturating_add(1), + } + .at_archive_offset(offset)); + } + } + Ok(()) + } + + pub(crate) fn admit(&mut self, size: usize, offset: usize) -> Result<()> { + self.check_count(offset)?; + if let Some(limit) = self.byte_limit { + if size as u64 > limit - self.bytes { + return Err(Error::HeaderBytesLimitExceeded { + limit, + required: self.bytes.saturating_add(size as u64), + } + .at_archive_offset(offset)); + } + self.bytes += size as u64; + } + if self.count_limit.is_some() { + self.count += 1; + } + Ok(()) + } +} + +#[cfg(all(test, feature = "write"))] +pub(crate) struct PrefixReader { + inner: std::io::Cursor>, + pub reads: Vec, +} + +#[cfg(all(test, feature = "write"))] +impl PrefixReader { + pub(crate) fn new(prefix: Vec) -> Self { + Self { + inner: std::io::Cursor::new(prefix), + reads: Vec::new(), + } + } +} + +#[cfg(all(test, feature = "write"))] +impl std::io::Read for PrefixReader { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + self.reads.push(buf.len()); + if self.inner.position() as usize + buf.len() > self.inner.get_ref().len() { + return Err(std::io::ErrorKind::PermissionDenied.into()); + } + std::io::Read::read(&mut self.inner, buf) + } +} + +#[cfg(all(test, feature = "write"))] +impl std::io::Seek for PrefixReader { + fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result { + std::io::Seek::seek(&mut self.inner, pos) + } +} + +#[cfg(all(test, feature = "write"))] +mod tests { + use super::*; + + #[test] + fn cumulative_admission_is_inclusive_and_refusal_does_not_charge() { + let mut b = ParseBudget::new( + ArchiveReadOptions::new() + .with_max_header_count(2) + .with_max_header_bytes(10), + ); + b.admit(4, 0).unwrap(); + let e = b.admit(7, 4).unwrap_err(); + assert!(matches!( + e.root_cause(), + Error::HeaderBytesLimitExceeded { + limit: 10, + required: 11 + } + )); + assert!(matches!(e, Error::AtArchiveOffset { offset: 4, .. })); + b.admit(6, 4).unwrap(); + let e = b.admit(1, 10).unwrap_err(); + assert!(matches!( + e.root_cause(), + Error::HeaderCountLimitExceeded { + limit: 2, + required: 3 + } + )); + assert_eq!(e.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!((b.count, b.bytes), (2, 10)); + } + + #[test] + fn overflow_cannot_bypass_limits() { + let mut b = ParseBudget::new( + ArchiveReadOptions::new() + .with_max_header_count(u64::MAX) + .with_max_header_bytes(u64::MAX), + ); + b.bytes = u64::MAX - 1; + b.count = u64::MAX - 1; + assert!(matches!( + b.admit(2, 0).unwrap_err().root_cause(), + Error::HeaderBytesLimitExceeded { + required: u64::MAX, + .. + } + )); + b.admit(1, 0).unwrap(); + assert!(matches!( + b.admit(0, 0).unwrap_err().root_cause(), + Error::HeaderCountLimitExceeded { + required: u64::MAX, + .. + } + )); + } +} diff --git a/arca-rar/vendor/rars/src/pending_archive.rs b/arca-rar/vendor/rars/src/pending_archive.rs new file mode 100644 index 00000000..54e1a533 --- /dev/null +++ b/arca-rar/vendor/rars/src/pending_archive.rs @@ -0,0 +1,58 @@ +//! Temporary archive publication shared by writing and recovery repair. + +use crate::Result; +use std::fs; +use std::path::{Path, PathBuf}; + +pub(crate) struct PendingArchive { + pub(crate) path: Option, + _charge: C, +} + +#[cfg(feature = "recovery")] +impl PendingArchive<()> { + pub(crate) fn create(destination: &Path) -> Result<(Self, fs::File)> { + Self::with_admission(destination, |_| Ok(())) + } +} + +impl PendingArchive { + pub(crate) fn with_admission( + destination: &Path, + admit: impl FnMut(usize) -> Result, + ) -> Result<(Self, fs::File)> { + use crate::atomic64::AtomicU64; + use std::sync::atomic::Ordering; + static NEXT: AtomicU64 = AtomicU64::new(0); + Self::create_with_sequence(destination, admit, || NEXT.fetch_add(1, Ordering::Relaxed)) + } + + pub(crate) fn create_with_sequence( + destination: &Path, + admit: impl FnMut(usize) -> Result, + next_sequence: impl FnMut() -> u64, + ) -> Result<(Self, fs::File)> { + let directory = destination.parent().unwrap_or_else(|| Path::new("")); + let (path, file, charge) = crate::temp_file::create_named_with_sequence( + crate::temp_file::TemporaryKind::Archive, + directory, + admit, + next_sequence, + )?; + Ok(( + Self { + path: Some(path), + _charge: charge, + }, + file, + )) + } +} + +impl Drop for PendingArchive { + fn drop(&mut self) { + if let Some(path) = &self.path { + let _ = fs::remove_file(path); + } + } +} diff --git a/arca-rar/vendor/rars/src/progress.rs b/arca-rar/vendor/rars/src/progress.rs new file mode 100644 index 00000000..41855893 --- /dev/null +++ b/arca-rar/vendor/rars/src/progress.rs @@ -0,0 +1,124 @@ +//! Progress events shared by archive writing and recovery generation. + +/// A high-level archive-writing operation. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum WriteOperation { + /// Decoding and verifying source payloads for a rewrite; may overlap encoding. + Staging, + /// Compressing or otherwise preparing member payloads. + Compression, + /// Building a RAR 5 recovery record. + Recovery, + /// Writing finished archive bytes to the output. + Emission, +} + +/// Progress reported by archive writers. +/// +/// Callbacks can be invoked concurrently when parallel compression is enabled. +/// Each member starts before its source is consumed and finishes after its packed +/// payload is prepared. Different members may overlap. `Advanced` and +/// `BytesWritten` carry absolute byte counts; entry events must not be added to +/// them. A failed operation does not +/// report `OperationFinished`. Emission can overlap compression and contain recovery sub-operations. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum WriteProgressEvent<'a> { + /// An operation has started. + OperationStarted { + operation: WriteOperation, + total_bytes: Option, + total_entries: Option, + pass: usize, + }, + /// Work on one archive member has started. + EntryStarted { + operation: WriteOperation, + index: usize, + total_entries: usize, + name: &'a [u8], + input_bytes: u64, + }, + /// Work on one archive member has finished. + EntryFinished { + operation: WriteOperation, + index: usize, + total_entries: usize, + name: &'a [u8], + input_bytes: u64, + }, + /// Absolute progress within the current operation or pass. + Advanced { + operation: WriteOperation, + completed_bytes: u64, + total_bytes: u64, + pass: usize, + }, + /// Absolute archive bytes accepted by the output while its final size is unknown. + BytesWritten { completed_bytes: u64 }, + /// One volume of a multi-volume set has been written out. + VolumeFinished { + volume_number: usize, + total_volumes: Option, + bytes: u64, + }, + /// An operation has finished. + OperationFinished { + operation: WriteOperation, + total_bytes: Option, + total_entries: Option, + pass: usize, + }, +} + +/// Receives archive-writing progress events. +pub trait WriteProgress: Send + Sync { + fn report(&self, event: WriteProgressEvent<'_>); + + /// Returns true when the caller wants the active write operation to stop. + /// Writers retain an observed request for the rest of the write. + /// Cancellation is cooperative: it cannot interrupt a blocked caller I/O + /// operation or an indivisible allocation or cryptographic setup call. + fn is_cancelled(&self) -> bool { + false + } +} + +impl WriteProgress for F +where + F: Fn(WriteProgressEvent<'_>) + Send + Sync, +{ + fn report(&self, event: WriteProgressEvent<'_>) { + self(event); + } +} + +#[derive(Clone, Copy)] +pub(crate) struct ProgressReporter<'a>(pub(crate) &'a dyn WriteProgress); + +impl std::fmt::Debug for ProgressReporter<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("ProgressReporter(..)") + } +} + +impl ProgressReporter<'_> { + pub(crate) fn report(self, event: WriteProgressEvent<'_>) { + self.0.report(event); + } + + pub(crate) fn is_cancelled(self) -> bool { + self.0.is_cancelled() + } +} + +#[cfg(test)] +#[test] +fn progress_reporter_debug_does_not_expose_the_callback() { + let callback = |_event: WriteProgressEvent<'_>| {}; + assert_eq!( + format!("{:?}", ProgressReporter(&callback)), + "ProgressReporter(..)" + ); +} diff --git a/arca-rar/vendor/rars/src/rar13.rs b/arca-rar/vendor/rars/src/rar13.rs new file mode 100644 index 00000000..60de3a76 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar13.rs @@ -0,0 +1,1424 @@ +//! RAR 1.3/1.4 format parsing and sequential extraction. + +#[cfg(feature = "write")] +pub(crate) mod write; +#[cfg(feature = "write")] +pub(crate) use write::{ + write_archive_with_sources, write_stored_volumes_with_progress, BorrowedFileEntry, +}; +#[cfg(feature = "write")] +pub use write::{ + write_compressed_archive, write_compressed_archive_with_comment, + write_compressed_archive_with_comment_and_progress, write_compressed_volumes, + write_compressed_volumes_with_progress, write_stored_archive, + write_stored_archive_with_comment, write_stored_volumes, write_streaming_archive_to, + EntrySource, FileEntry, MemberCoding, StoredEntry, StreamingEntry, WriterOptions, + WriterResources, +}; + +use crate::codec::rar13::Reader15State; +use crate::codec::workspace::{Allowance, Budget, Buffer}; +use crate::crypto::rar13::{Rar13Cipher, Rar13DecryptReader}; +use crate::detect::{find_archive_start, ArchiveSignature, RAR13_SIGNATURE, SFX_SCAN_LIMIT}; +use crate::error::{Error, Result}; +use crate::io_util::{read_exact_at, read_u16, read_u32}; +pub(crate) use crate::source::ArchiveSource; +use crate::version::ArchiveFamily; +use crate::volume_extract::ChainedReader; +use std::fs::File; +use std::io::{Read, Write}; +use std::ops::Range; +use std::path::Path; +use std::sync::Arc; + +const MAIN_HEAD_SIZE: u16 = 7; +const FILE_HEAD_BASE_SIZE: usize = 21; +const MHD_VOLUME: u8 = 0x01; +const MHD_COMMENT: u8 = 0x02; +const MHD_SOLID: u8 = 0x08; +const MHD_PACK_COMMENT: u8 = 0x10; +const MHD_AV: u8 = 0x20; +#[cfg(feature = "write")] +const MHD_ALWAYS_SET: u8 = 0x80; +const RAR13_AV_PREFIX: &[u8; 6] = b"\x1ai\x6d\x02\xda\xae"; +const COPY_BUFFER_SIZE: usize = 64 * 1024; +const LHD_SPLIT_BEFORE: u8 = 0x01; +const LHD_SPLIT_AFTER: u8 = 0x02; +const LHD_PASSWORD: u8 = 0x04; +const LHD_COMMENT: u8 = 0x08; +#[cfg(feature = "write")] +const LHD_SOLID: u8 = 0x10; +const METHOD_STORE: u8 = 0; +#[cfg(feature = "write")] +const METHOD_BEST: u8 = 5; +#[cfg(feature = "write")] +const DEFAULT_UNP_VER: u8 = 2; + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct MainHeader { + pub flags: u8, + pub head_size: u16, + pub extra: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileHeader { + pub flags: u8, + pub pack_size: u32, + pub unp_size: u32, + pub file_crc: u16, + pub file_time: u32, + pub file_attr: u8, + pub unp_ver: u8, + pub method: u8, + pub head_size: u16, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct Entry { + pub header: FileHeader, + pub name: Vec, + pub extra: Vec, + pub packed_range: Range, +} + +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct Archive { + pub sfx_offset: usize, + pub main: MainHeader, + pub entries: Vec, + source: ArchiveSource, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct AuthenticityVerification { + pub size: u16, + pub prefix: [u8; 6], + pub cipher_body: Vec, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum AuthenticityVerificationStatus { + Absent, + StructurallyPresent, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct ExtractedEntryMeta { + pub name: Vec, + pub file_time: u32, + pub file_attr: u8, + pub is_directory: bool, +} + +impl MainHeader { + pub fn is_volume(&self) -> bool { + self.flags & MHD_VOLUME != 0 + } + + pub fn has_archive_comment(&self) -> bool { + self.flags & MHD_COMMENT != 0 + } + + pub fn has_packed_comment(&self) -> bool { + self.flags & MHD_PACK_COMMENT != 0 + } + + pub fn is_solid(&self) -> bool { + self.flags & MHD_SOLID != 0 + } + + pub fn has_authenticity_verification(&self) -> bool { + self.flags & MHD_AV != 0 + } + + fn parse(input: &[u8]) -> Result { + if input.len() < MAIN_HEAD_SIZE as usize { + return Err(Error::TooShort); + } + if !input.starts_with(RAR13_SIGNATURE) { + return Err(Error::UnsupportedSignature); + } + + let head_size = read_u16(input, 4)?; + let flags = input[6]; + if head_size < MAIN_HEAD_SIZE { + return Err(Error::InvalidHeader( + "RAR 1.3 main header is shorter than 7 bytes", + )); + } + if head_size as usize > input.len() { + return Err(Error::TooShort); + } + + let extra = input[MAIN_HEAD_SIZE as usize..head_size as usize].to_vec(); + + Ok(Self { + flags, + head_size, + extra, + }) + } +} + +// Inspect only the fixed prefix before any name/extra allocation or full read. +fn admit_header( + prefix: &[u8], + remaining: u64, + main: bool, + budget: &mut crate::parse_budget::ParseBudget, + offset: usize, +) -> Result<()> { + budget.control.check()?; + if !budget.is_limited() { + return Ok(()); + } + let base = if main { + MAIN_HEAD_SIZE as usize + } else { + FILE_HEAD_BASE_SIZE + }; + if prefix.len() < base { + return Err(Error::TooShort); + } + if main && !prefix.starts_with(RAR13_SIGNATURE) { + return Err(Error::UnsupportedSignature); + } + let size = read_u16(prefix, if main { 4 } else { 10 })? as usize; + let minimum = if main { + base + } else { + base + prefix[19] as usize + }; + if size < minimum { + return Err(Error::InvalidHeader(if main { + "RAR 1.3 main header is shorter than 7 bytes" + } else { + "RAR 1.3 file header is shorter than its name" + })); + } + if size as u64 > remaining { + return Err(Error::TooShort); + } + budget.admit(size, offset) +} + +impl FileHeader { + fn parse(input: &[u8]) -> Result<(Self, Vec, Vec, usize)> { + if input.len() < FILE_HEAD_BASE_SIZE { + return Err(Error::TooShort); + } + + let pack_size = read_u32(input, 0)?; + let unp_size = read_u32(input, 4)?; + let file_crc = read_u16(input, 8)?; + let head_size = read_u16(input, 10)?; + let file_time = read_u32(input, 12)?; + let file_attr = input[16]; + let flags = input[17]; + let unp_ver = input[18]; + let name_size = input[19] as usize; + let method = input[20]; + let minimum_size = FILE_HEAD_BASE_SIZE + name_size; + + if (head_size as usize) < minimum_size { + return Err(Error::InvalidHeader( + "RAR 1.3 file header is shorter than its name", + )); + } + if input.len() < head_size as usize { + return Err(Error::TooShort); + } + + let name = input[FILE_HEAD_BASE_SIZE..FILE_HEAD_BASE_SIZE + name_size].to_vec(); + let extra = input[minimum_size..head_size as usize].to_vec(); + Ok(( + Self { + flags, + pack_size, + unp_size, + file_crc, + file_time, + file_attr, + unp_ver, + method, + head_size, + }, + name, + extra, + head_size as usize, + )) + } +} + +/// Stored members need no dictionary. Delay model allocation until the first +/// compressed member, retaining the same allowance throughout a solid chain. +struct Decoder15 { + read_control: crate::read_control::ReadControl, + allowance: B, + state: Option>, +} +impl Decoder15 { + fn with_allowance(allowance: &B) -> Self { + Self { + read_control: Default::default(), + allowance: allowance.clone(), + state: None, + } + } + fn reset(&mut self) { + self.state = None; + } + fn decode_member_from_reader( + &mut self, + input: &mut impl Read, + output_size: usize, + solid: bool, + out: &mut impl Write, + ) -> crate::codec::Result<()> { + self.read_control.check_codec()?; + if self.state.is_none() { + self.state = Some(Reader15State::with_allowance(&self.allowance)?); + } + let state = self.state.as_mut().expect("decoder initialized above"); + state.read_control = self.read_control.clone(); + state.decode_member_from_reader(input, output_size, solid, out) + } +} +impl Decoder15 { + fn new() -> Self { + Self::with_allowance(&Allowance::default()) + } +} + +impl Archive { + pub fn parse(input: &[u8]) -> Result { + Self::parse_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_with_options( + input: &[u8], + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let data: Arc<[u8]> = Arc::from(input.to_vec().into_boxed_slice()); + Self::parse_shared(data, options) + } + + pub fn parse_owned(input: Vec) -> Result { + Self::parse_owned_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_owned_with_options( + input: Vec, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + Self::parse_shared(Arc::from(input.into_boxed_slice()), options) + } + + pub fn parse_path(path: impl AsRef) -> Result { + Self::parse_path_with_options(path, crate::ArchiveReadOptions::default()) + } + + pub fn parse_path_with_options( + path: impl AsRef, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let path = Arc::new(path.as_ref().to_path_buf()); + let mut file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + let scan_len = len.min(SFX_SCAN_LIMIT as u64) as usize; + let mut scan = vec![0; scan_len]; + file.read_exact(&mut scan)?; + options.check_cancelled()?; + let sig = find_archive_start(&scan, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar13 { + return Err(Error::UnsupportedSignature); + } + Self::parse_seekable(file, len, sig.offset, ArchiveSource::File(path), options) + } + + pub fn parse_path_with_signature( + path: impl AsRef, + signature: ArchiveSignature, + ) -> Result { + Self::parse_path_with_signature_and_options( + path, + signature, + crate::ArchiveReadOptions::default(), + ) + } + + pub fn parse_path_with_signature_and_options( + path: impl AsRef, + signature: ArchiveSignature, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + if signature.family != ArchiveFamily::Rar13 { + return Err(Error::UnsupportedSignature); + } + let path = Arc::new(path.as_ref().to_path_buf()); + let file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + Self::parse_seekable( + file, + len, + signature.offset, + ArchiveSource::File(path), + options, + ) + } + + fn parse_shared(input: Arc<[u8]>, options: crate::ArchiveReadOptions<'_>) -> Result { + options.check_cancelled()?; + let sig = find_archive_start(&input, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar13 { + return Err(Error::UnsupportedSignature); + } + + let archive = &input[sig.offset..]; + let mut budget = crate::parse_budget::ParseBudget::new(options); + admit_header(archive, archive.len() as u64, true, &mut budget, 0)?; + let main = MainHeader::parse(archive)?; + let mut pos = main.head_size as usize; + let mut entries = Vec::new(); + + while pos < archive.len() { + if archive.len() - pos < FILE_HEAD_BASE_SIZE { + break; + } + + admit_header( + &archive[pos..], + (archive.len() - pos) as u64, + false, + &mut budget, + pos, + )?; + let (header, name, extra, consumed) = FileHeader::parse(&archive[pos..])?; + let data_start = pos + consumed; + let data_end = + data_start + .checked_add(header.pack_size as usize) + .ok_or(Error::InvalidHeader( + "RAR 1.3 file data size overflows usize", + ))?; + if data_end > archive.len() { + return Err(Error::TooShort); + } + + entries.push(Entry { + header, + name, + extra, + packed_range: sig.offset + data_start..sig.offset + data_end, + }); + pos = data_end; + } + + options.check_cancelled()?; + Ok(Self { + sfx_offset: sig.offset, + main, + entries, + source: ArchiveSource::Memory(input), + }) + } + + pub(crate) fn parse_seekable( + file: impl Read + std::io::Seek, + file_len: u64, + sfx_offset: usize, + source: ArchiveSource, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let mut budget = crate::parse_budget::ParseBudget::new(options); + let mut file = budget.control.reader(file); + let main_prefix = read_exact_at(&mut file, sfx_offset, MAIN_HEAD_SIZE as usize)?; + let head_size = read_u16(&main_prefix, 4)? as usize; + admit_header( + &main_prefix, + file_len + .checked_sub(sfx_offset as u64) + .ok_or(Error::TooShort)?, + true, + &mut budget, + 0, + )?; + let main_bytes = read_exact_at(&mut file, sfx_offset, head_size)?; + let main = MainHeader::parse(&main_bytes)?; + let mut pos = main.head_size as usize; + let mut entries = Vec::new(); + + while (sfx_offset + pos) as u64 + FILE_HEAD_BASE_SIZE as u64 <= file_len { + let header_prefix = read_exact_at(&mut file, sfx_offset + pos, FILE_HEAD_BASE_SIZE)?; + let head_size = read_u16(&header_prefix, 10)? as usize; + admit_header( + &header_prefix, + file_len + .checked_sub((sfx_offset + pos) as u64) + .ok_or(Error::TooShort)?, + false, + &mut budget, + pos, + )?; + let header_bytes = read_exact_at(&mut file, sfx_offset + pos, head_size)?; + let (header, name, extra, consumed) = FileHeader::parse(&header_bytes)?; + let data_start = pos + consumed; + let data_end = + data_start + .checked_add(header.pack_size as usize) + .ok_or(Error::InvalidHeader( + "RAR 1.3 file data size overflows usize", + ))?; + if (sfx_offset + data_end) as u64 > file_len { + return Err(Error::TooShort); + } + entries.push(Entry { + header, + name, + extra, + packed_range: sfx_offset + data_start..sfx_offset + data_end, + }); + pos = data_end; + } + + options.check_cancelled()?; + Ok(Self { + sfx_offset, + main, + entries, + source, + }) + } + + fn copy_range_to(&self, range: Range, out: &mut impl Write) -> Result<()> { + self.source.copy_range_to(range, out) + } + + fn range_reader(&self, range: Range) -> Result> { + self.source.range_reader(range) + } + + fn copy_decrypted_range_to( + &self, + range: Range, + mut cipher: Rar13Cipher, + out: &mut impl Write, + ) -> Result<()> { + let mut buffer = [0u8; COPY_BUFFER_SIZE]; + match &self.source { + ArchiveSource::Memory(data) => { + let data = data.get(range).ok_or(Error::TooShort)?; + for chunk in data.chunks(COPY_BUFFER_SIZE) { + buffer[..chunk.len()].copy_from_slice(chunk); + for byte in &mut buffer[..chunk.len()] { + *byte = cipher.decrypt_byte(*byte); + } + out.write_all(&buffer[..chunk.len()])?; + } + } + ArchiveSource::File(_) | ArchiveSource::Reader(_) => { + let mut file = self.source.range_reader(range.clone())?; + let mut remaining = range.len(); + while remaining > 0 { + let to_read = remaining.min(buffer.len()); + file.read_exact(&mut buffer[..to_read])?; + for byte in &mut buffer[..to_read] { + *byte = cipher.decrypt_byte(*byte); + } + out.write_all(&buffer[..to_read])?; + remaining -= to_read; + } + } + } + Ok(()) + } + + /// Streams extracted entries to caller-provided writers. + pub fn extract_to(&self, password: Option<&[u8]>, open: F) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.extract_to_with_options( + crate::ArchiveReadOptions::with_optional_password(password), + open, + ) + } + + /// Extracts members with explicit output policy; default wrappers retain their behavior. + pub fn extract_to_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + mut open: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.extract_impl(options, &mut open, None, None) + .map(|_| ()) + } + + pub(crate) fn extract_controlled( + &self, + options: crate::ArchiveReadOptions<'_>, + selector: &mut crate::extraction_control::Selector<'_>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result { + self.extract_impl( + options, + &mut |_| unreachable!("controlled selection supplies writer"), + Some(selector), + on_error, + ) + } + + fn extract_impl( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + selector: Option<&mut crate::extraction_control::Selector<'_>>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.extract_with_allowance( + options, + open, + selector, + on_error, + &crate::codec::workspace::Allowance::limited(limit), + ); + } + self.extract_with_allowance(options, open, selector, on_error, &Allowance::default()) + } + + fn extract_with_allowance( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + mut selector: Option<&mut crate::extraction_control::Selector<'_>>, + mut on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + allowance: &B, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + let mut unpack15 = Decoder15::with_allowance(allowance); + unpack15.read_control = budget.control.clone(); + let mut extracted_count = 0usize; + let solid = self.main.is_solid(); + for entry in &self.entries { + let selected = crate::extraction_control::select( + &mut selector, + options, + || crate::rar13_member(entry), + solid, + )?; + let mut selected_writer = match selected { + Some(crate::ExtractionDecision::Skip) => continue, + Some(crate::ExtractionDecision::Stop) => { + return Ok(crate::ExtractionOutcome::Stopped) + } + Some(crate::ExtractionDecision::Extract(writer)) => Some(writer), + None => None, + }; + let result = (|| { + options.check_cancelled()?; + if entry.is_split_before() || entry.is_split_after() { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry requires multivolume extraction", + )); + } + let meta = entry.metadata(); + if meta.is_directory { + options.check_cancelled()?; + let _ = match selected_writer.take() { + Some(writer) => writer, + None => open(&meta)?, + }; + options.check_cancelled()?; + extracted_count += 1; + return Ok(()); + } + budget.check(u64::from(entry.header.unp_size), &meta.name)?; + options.check_cancelled()?; + let mut writer = match selected_writer.take() { + Some(writer) => writer, + None => open(&meta)?, + }; + options.check_cancelled()?; + budget.run(&meta.name, &mut writer, |mut writer| { + if entry.is_stored() && !entry.is_encrypted() { + entry + .write_stored_to(self, password, &mut writer) + .map_err(|error| entry.entry_error("extracting", error))?; + } else { + entry + .write_compressed_to( + self, + password, + &mut unpack15, + self.main.is_solid() && extracted_count != 0, + &mut writer, + ) + .map_err(|error| entry.entry_error("extracting", error))?; + } + Ok(()) + })?; + extracted_count += 1; + Ok(()) + })(); + if crate::extraction_control::finish_member( + &mut on_error, + options, + || crate::rar13_member(entry), + solid, + result, + )? { + unpack15.reset(); + unpack15.read_control = budget.control.clone(); + } + } + options.check_cancelled()?; + Ok(crate::ExtractionOutcome::Complete) + } + + #[cfg(feature = "write")] + pub(crate) fn rewrite_preservation_issues(&self) -> Vec { + let mut issues = Vec::new(); + let exact_comment = |extra: &[u8], present: bool| { + if present { + read_u16(extra, 0).is_ok_and(|size| usize::from(size) + 2 == extra.len()) + } else { + extra.is_empty() + } + }; + if self.main.flags & !(MHD_COMMENT | MHD_SOLID | MHD_PACK_COMMENT | MHD_ALWAYS_SET) != 0 + || (self.main.has_packed_comment() && !self.main.has_archive_comment()) + || !exact_comment(&self.main.extra, self.main.has_archive_comment()) + { + issues.push( + "RAR1.3/1.4 main metadata, volumes or authenticity records are unsupported".into(), + ); + } + if self.entries.is_empty() { + issues.push("empty legacy archive (source format cannot be inferred)".into()); + } + for (index, entry) in self.entries.iter().enumerate() { + if entry.header.unp_ver != DEFAULT_UNP_VER + || entry.header.method > METHOD_BEST + || entry.header.flags & !(LHD_PASSWORD | LHD_COMMENT | LHD_SOLID) != 0 + || (!self.main.is_solid() && entry.header.flags & LHD_SOLID != 0) + || !exact_comment(&entry.extra, entry.has_file_comment()) + || (entry.is_directory() + && (entry.header.pack_size != 0 || entry.header.unp_size != 0)) + { + issues.push(format!("RAR1.3/1.4 member {index}: unsupported version, flags, comments or directory payload")); + } + } + if self.entries.last().map(|entry| entry.packed_range.end) != self.source.len().ok() { + issues.push("RAR1.3/1.4 trailing bytes or incomplete archive".into()); + } + issues + } + + pub fn archive_comment(&self) -> Result>> { + self.archive_comment_with_options(crate::ArchiveReadOptions::new()) + } + + /// Decodes the archive comment under the same policy as [`crate::Archive::comment_with_options`]. + pub fn archive_comment_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + ) -> Result>> { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.archive_comment_with_allowance(options, &Allowance::limited(limit)); + } + self.archive_comment_with_allowance(options, &Allowance::default()) + } + + fn archive_comment_with_allowance( + &self, + options: crate::ArchiveReadOptions<'_>, + allowance: &B, + ) -> Result>> { + options.check_cancelled()?; + let mut budget = crate::output_limit::OutputBudget::new(options); + if !self.main.has_archive_comment() { + return Ok(None); + } + + let length = read_u16(&self.main.extra, 0)? as usize; + if self.main.has_packed_comment() { + if length < 2 { + return Err(Error::InvalidHeader( + "RAR 1.3 packed archive comment is shorter than size field", + )); + } + let unpacked_len = read_u16(&self.main.extra, 2)? as usize; + let packed_len = length - 2; + let packed_start = 4usize; + let packed_end = packed_start + .checked_add(packed_len) + .ok_or(Error::InvalidHeader( + "RAR 1.3 archive comment size overflows", + ))?; + if packed_end > self.main.extra.len() { + return Err(Error::TooShort); + } + + budget.check(unpacked_len as u64, b"CMT")?; + let mut packed = Rar13DecryptReader::new( + &self.main.extra[packed_start..packed_end], + Rar13Cipher::new_comment(), + ); + let mut decoder = Decoder15::with_allowance(allowance); + decoder.read_control = budget.control.clone(); + let mut data = Vec::new(); + budget.run(b"CMT", &mut data, |writer| { + decoder.decode_member_from_reader(&mut packed, unpacked_len, false, writer)?; + Ok(()) + })?; + return Ok(Some(data)); + } + + let comment_start = 2usize; + let comment_end = comment_start + .checked_add(length) + .ok_or(Error::InvalidHeader( + "RAR 1.3 archive comment size overflows", + ))?; + if comment_end > self.main.extra.len() { + return Err(Error::TooShort); + } + budget.check(length as u64, b"CMT")?; + let mut data = Vec::new(); + budget.run(b"CMT", &mut data, |writer| { + writer.write_all(&self.main.extra[comment_start..comment_end])?; + Ok(()) + })?; + Ok(Some(data)) + } + + pub fn authenticity_verification(&self) -> Result> { + if !self.main.has_authenticity_verification() { + return Ok(None); + } + let size = read_u16(&self.main.extra, 0)?; + if size < RAR13_AV_PREFIX.len() as u16 { + return Err(Error::InvalidHeader("RAR 1.3 AV payload is too short")); + } + let payload_end = 2usize + .checked_add(size as usize) + .ok_or(Error::InvalidHeader("RAR 1.3 AV payload size overflows"))?; + if payload_end > self.main.extra.len() { + return Err(Error::TooShort); + } + let prefix_bytes = self + .main + .extra + .get(2..2 + RAR13_AV_PREFIX.len()) + .ok_or(Error::TooShort)?; + let prefix: [u8; 6] = prefix_bytes + .try_into() + .expect("RAR 1.3 AV prefix slice has fixed length"); + if &prefix != RAR13_AV_PREFIX { + return Err(Error::InvalidHeader("RAR 1.3 AV prefix mismatch")); + } + Ok(Some(AuthenticityVerification { + size, + prefix, + cipher_body: self.main.extra[2 + RAR13_AV_PREFIX.len()..payload_end].to_vec(), + })) + } + + pub fn authenticity_verification_status(&self) -> Result { + Ok(if self.authenticity_verification()?.is_some() { + AuthenticityVerificationStatus::StructurallyPresent + } else { + AuthenticityVerificationStatus::Absent + }) + } +} + +impl Entry { + pub fn name_bytes(&self) -> &[u8] { + &self.name + } + + /// Returns the entry name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + String::from_utf8_lossy(&self.name).into_owned() + } + + pub fn is_encrypted(&self) -> bool { + self.header.flags & LHD_PASSWORD != 0 + } + + pub fn is_split_before(&self) -> bool { + self.header.flags & LHD_SPLIT_BEFORE != 0 + } + + pub fn is_split_after(&self) -> bool { + self.header.flags & LHD_SPLIT_AFTER != 0 + } + + pub fn is_directory(&self) -> bool { + self.header.file_attr & 0x10 != 0 + } + + pub fn has_file_comment(&self) -> bool { + self.header.flags & LHD_COMMENT != 0 + } + + pub fn file_comment(&self) -> Result>> { + if !self.has_file_comment() { + return Ok(None); + } + let length = read_u16(&self.extra, 0)? as usize; + let comment_start = 2usize; + let comment_end = comment_start + .checked_add(length) + .ok_or(Error::InvalidHeader("RAR 1.3 file comment size overflows"))?; + if comment_end > self.extra.len() { + return Err(Error::TooShort); + } + Ok(Some(self.extra[comment_start..comment_end].to_vec())) + } + + pub fn is_stored(&self) -> bool { + self.header.method == METHOD_STORE + } + + pub fn packed_data<'a>(&self, archive: &'a Archive) -> Result<&'a [u8]> { + match &archive.source { + ArchiveSource::Memory(data) => { + data.get(self.packed_range.clone()).ok_or(Error::TooShort) + } + ArchiveSource::File(_) | ArchiveSource::Reader(_) => Err(Error::InvalidHeader( + "RAR 1.3 file-backed packed data requires owned read", + )), + } + } + + pub fn write_packed_data(&self, archive: &Archive, out: &mut impl Write) -> Result<()> { + archive.copy_range_to(self.packed_range.clone(), out) + } + + pub fn verify_checksum(&self, data: &[u8]) -> Result<()> { + let actual = file_checksum(data); + if actual == self.header.file_crc { + Ok(()) + } else { + Err(Error::CrcMismatch { + expected: self.header.file_crc, + actual, + }) + } + } + + pub fn metadata(&self) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name: self.name.clone(), + file_time: self.header.file_time, + file_attr: self.header.file_attr, + is_directory: self.is_directory(), + } + } + + fn write_stored_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + if self.is_encrypted() { + crate::crypto::require_encryption()?; + let password = password.ok_or(Error::NeedPassword)?; + let mut checksum = Rar13Checksum::new(); + let mut checksum_writer = Rar13ChecksumWriter { + inner: out, + checksum: &mut checksum, + }; + archive.copy_decrypted_range_to( + self.packed_range.clone(), + Rar13Cipher::for_password(password)?, + &mut checksum_writer, + )?; + checksum.verify_stored_length(self.header.unp_size)?; + let actual = checksum.finish(); + return if actual == self.header.file_crc { + Ok(()) + } else { + Err(Error::CrcMismatch { + expected: self.header.file_crc, + actual, + }) + }; + } + let mut checksum = Rar13Checksum::new(); + let mut checksum_writer = Rar13ChecksumWriter { + inner: out, + checksum: &mut checksum, + }; + self.write_packed_data(archive, &mut checksum_writer)?; + checksum.verify_stored_length(self.header.unp_size)?; + let actual = checksum.finish(); + if actual == self.header.file_crc { + Ok(()) + } else { + Err(Error::CrcMismatch { + expected: self.header.file_crc, + actual, + }) + } + } + + fn write_compressed_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + unpack15: &mut Decoder15, + solid: bool, + out: &mut impl Write, + ) -> Result<()> { + if self.is_stored() { + return self.write_stored_to(archive, password, out); + } + let mut checksum = Rar13Checksum::new(); + let mut checksum_writer = Rar13ChecksumWriter { + inner: out, + checksum: &mut checksum, + }; + if self.is_encrypted() { + crate::crypto::require_encryption()?; + let password = password.ok_or(Error::NeedPassword)?; + let packed = archive.range_reader(self.packed_range.clone())?; + let mut packed = Rar13DecryptReader::new(packed, Rar13Cipher::for_password(password)?); + unpack15.decode_member_from_reader( + &mut packed, + self.header.unp_size as usize, + solid, + &mut checksum_writer, + )?; + } else { + let mut packed = archive.range_reader(self.packed_range.clone())?; + unpack15.decode_member_from_reader( + &mut packed, + self.header.unp_size as usize, + solid, + &mut checksum_writer, + )?; + } + let actual = checksum.finish(); + if actual == self.header.file_crc { + Ok(()) + } else { + Err(Error::CrcMismatch { + expected: self.header.file_crc, + actual, + }) + } + } + + pub fn write_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + self.write_compressed_to(archive, password, &mut Decoder15::new(), false, out) + } + + fn entry_error(&self, operation: &'static str, error: Error) -> Error { + if matches!( + error, + Error::NeedPassword | Error::WrongPasswordOrCorruptData + ) { + return error; + } + if self.is_encrypted() + && !matches!( + error.kind(), + crate::ErrorKind::ResourceLimit + | crate::ErrorKind::Cancelled + | crate::ErrorKind::Io + ) + && matches!( + error, + Error::InvalidHeader(_) + | Error::Codec(_) + | Error::CrcMismatch { .. } + | Error::Crc32Mismatch { .. } + | Error::HashMismatch { .. } + ) + { + return Error::WrongPasswordOrCorruptData; + } + error.at_entry(self.name.clone(), operation) + } +} + +/// Streams a multivolume archive set to caller-provided writers. +pub fn extract_volumes_to(volumes: &[Archive], password: Option<&[u8]>, open: F) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + extract_volumes_to_with_options( + volumes, + crate::ArchiveReadOptions::with_optional_password(password), + open, + ) +} + +/// Extracts logical volume members with explicit output policy. +pub fn extract_volumes_to_with_options( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + open: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + if let Some(limit) = options.max_reader_workspace_bytes { + return extract_volumes_with_allowance(volumes, options, open, &Allowance::limited(limit)); + } + extract_volumes_with_allowance(volumes, options, open, &Allowance::default()) +} + +fn extract_volumes_with_allowance( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + mut open: F, + allowance: &B, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + options.check_cancelled()?; + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + let mut pending: Option> = None; + let mut unpack15 = Decoder15::with_allowance(allowance); + unpack15.read_control = budget.control.clone(); + let mut extracted_count = 0usize; + + for (volume_index, archive) in volumes.iter().enumerate() { + for (entry_index, entry) in archive.entries.iter().enumerate() { + options.check_cancelled()?; + if !entry.is_split_before() && !entry.is_split_after() { + if pending.is_some() { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry is interrupted by a regular entry", + )); + } + let meta = entry.metadata(); + if meta.is_directory { + options.check_cancelled()?; + let _ = open(&meta)?; + options.check_cancelled()?; + extracted_count += 1; + continue; + } + budget.check(u64::from(entry.header.unp_size), &meta.name)?; + options.check_cancelled()?; + let mut writer = open(&meta)?; + options.check_cancelled()?; + budget.run(&meta.name, &mut writer, |mut writer| { + entry + .write_compressed_to( + archive, + password, + &mut unpack15, + archive.main.is_solid() && extracted_count != 0, + &mut writer, + ) + .map_err(|error| entry.entry_error("extracting", error))?; + options.check_cancelled()?; + Ok(()) + })?; + extracted_count += 1; + continue; + } + + match ( + &mut pending, + entry.is_split_before(), + entry.is_split_after(), + ) { + (None, false, true) => { + pending = Some(PendingSplitRefs::with_allowance( + entry, + volume_index, + entry_index, + allowance, + )?); + } + (Some(current), true, true) => { + current.append(entry, volume_index, entry_index)?; + } + (Some(current), true, false) => { + current.append(entry, volume_index, entry_index)?; + let completed = pending.take().expect("pending split"); + let solid = archive.main.is_solid() && extracted_count != 0; + completed + .write_to( + volumes, + entry, + options, + &mut budget, + &mut unpack15, + solid, + &mut open, + ) + .map_err(|error| entry.entry_error("extracting", error))?; + extracted_count += 1; + } + _ => { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry flags are inconsistent", + )); + } + } + } + } + + if pending.is_some() { + return Err(Error::InvalidHeader("RAR 1.3 split entry is incomplete")); + } + + options.check_cancelled()?; + Ok(()) +} + +struct Rar13ChecksumWriter<'a, W: Write + ?Sized> { + inner: &'a mut W, + checksum: &'a mut Rar13Checksum, +} + +impl Write for Rar13ChecksumWriter<'_, W> { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + let written = self.inner.write(buf)?; + self.checksum.update(&buf[..written]); + Ok(written) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.inner.flush() + } +} + +struct Rar13Checksum { + value: u16, + written: u64, +} + +impl Rar13Checksum { + fn new() -> Self { + Self { + value: 0, + written: 0, + } + } + + fn update(&mut self, input: &[u8]) { + self.written = self.written.saturating_add(input.len() as u64); + for &byte in input { + self.value = self.value.wrapping_add(byte as u16).rotate_left(1); + } + } + + fn verify_stored_length(&self, expected: u32) -> Result<()> { + if self.written != u64::from(expected) { + return Err(Error::InvalidHeader( + "RAR 1.3 stored file has mismatched packed and unpacked sizes", + )); + } + Ok(()) + } + + fn finish(self) -> u16 { + self.value + } +} + +struct PendingSplitRefs { + name: Vec, + fragments: Buffer<(usize, usize), B>, + file_time: u32, + file_attr: u8, + method: u8, + unp_ver: u8, + was_encrypted: bool, +} + +impl PendingSplitRefs { + fn with_allowance( + entry: &Entry, + volume_index: usize, + entry_index: usize, + allowance: &B, + ) -> Result { + Ok(Self { + name: entry.name.clone(), + fragments: Buffer::copied(&[(volume_index, entry_index)], allowance)?, + file_time: entry.header.file_time, + file_attr: entry.header.file_attr, + method: entry.header.method, + unp_ver: entry.header.unp_ver, + was_encrypted: entry.is_encrypted(), + }) + } + + fn append(&mut self, entry: &Entry, volume_index: usize, entry_index: usize) -> Result<()> { + if entry.name != self.name { + return Err(Error::InvalidHeader("RAR 1.3 split entry name changed")); + } + if entry.header.method != self.method { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry compression method changed", + )); + } + if entry.header.unp_ver != self.unp_ver { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry unpack version changed", + )); + } + if entry.is_encrypted() != self.was_encrypted { + return Err(Error::InvalidHeader( + "RAR 1.3 split entry encryption flag changed", + )); + } + self.fragments.try_push((volume_index, entry_index))?; + Ok(()) + } + + // Split decoding needs format state, policy accounting and the output callback. + #[allow(clippy::too_many_arguments)] + fn write_to( + self, + volumes: &[Archive], + final_entry: &Entry, + options: crate::ArchiveReadOptions<'_>, + budget: &mut crate::output_limit::OutputBudget, + unpack15: &mut Decoder15, + solid: bool, + open: &mut F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + let password = options.password; + budget.check(u64::from(final_entry.header.unp_size), &self.name)?; + let mut reader = + self.fragment_reader_with_allowance(volumes, password, &unpack15.allowance)?; + let meta = ExtractedEntryMeta { + name: self.name, + file_time: self.file_time, + file_attr: self.file_attr, + is_directory: false, + }; + options.check_cancelled()?; + let mut writer = open(&meta)?; + options.check_cancelled()?; + budget.run(&meta.name, &mut writer, |mut writer| { + let mut checksum = Rar13Checksum::new(); + let mut checksum_writer = Rar13ChecksumWriter { + inner: &mut writer, + checksum: &mut checksum, + }; + if self.method == METHOD_STORE { + std::io::copy(&mut reader, &mut checksum_writer)?; + checksum.verify_stored_length(final_entry.header.unp_size)?; + } else { + unpack15.decode_member_from_reader( + &mut reader, + final_entry.header.unp_size as usize, + solid, + &mut checksum_writer, + )?; + } + let actual = checksum.finish(); + if actual == final_entry.header.file_crc { + options.check_cancelled()?; + Ok(()) + } else { + Err(Error::CrcMismatch { + expected: final_entry.header.file_crc, + actual, + }) + } + }) + } + + fn fragment_reader_with_allowance<'a>( + &self, + volumes: &'a [Archive], + password: Option<&'a [u8]>, + allowance: &B, + ) -> Result, B>>> { + let mut readers = Buffer::with_capacity(self.fragments.len(), allowance)?; + for &(volume_index, entry_index) in &self.fragments { + let archive = volumes + .get(volume_index) + .ok_or(Error::InvalidHeader("RAR 1.3 split volume is missing"))?; + let entry = archive + .entries + .get(entry_index) + .ok_or(Error::InvalidHeader("RAR 1.3 split entry is missing"))?; + readers.push_admitted(archive.range_reader(entry.packed_range.clone())?); + } + let chained = ChainedReader::with_readers(readers); + if self.was_encrypted { + crate::crypto::require_encryption()?; + let password = password.ok_or(Error::NeedPassword)?; + // RAR 1.402 encrypts the logical packed stream continuously across + // split volumes; restarting the cipher at each part corrupts it. + Ok(PackedReader::Encrypted(Rar13DecryptReader::new( + chained, + Rar13Cipher::for_password(password)?, + ))) + } else { + Ok(PackedReader::Plain(chained)) + } + } +} + +enum PackedReader { + Plain(R), + Encrypted(Rar13DecryptReader), +} +impl Read for PackedReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + match self { + Self::Plain(reader) => reader.read(out), + Self::Encrypted(reader) => reader.read(out), + } + } +} + +pub fn file_checksum(input: &[u8]) -> u16 { + let mut checksum = Rar13Checksum::new(); + checksum.update(input); + checksum.finish() +} diff --git a/arca-rar/vendor/rars/src/rar13/write.rs b/arca-rar/vendor/rars/src/rar13/write.rs new file mode 100644 index 00000000..ec211eae --- /dev/null +++ b/arca-rar/vendor/rars/src/rar13/write.rs @@ -0,0 +1,3791 @@ +//! RAR 1.3/1.4 archive encoding and assembly. + +use super::*; +use crate::codec::rar13::{ + unpack15_decode, unpack15_encode, unpack15_encode_with_options_and_progress, + EncodeOptions as Rar15EncodeOptions, Unpack15Encoder, +}; +use crate::features::FeatureSet; +pub use crate::streaming::{EntrySource, WriterResources}; +pub use crate::write_plan::MemberCoding; +use crate::write_plan::{PlanShape, WriterOption}; +use crate::write_progress::{ProgressReporter, WorkTracker}; +use crate::write_stream::{MemberBytes, MemberPayload}; +use crate::ArchiveVersion; +use crate::{WriteOperation, WriteProgress, WriteProgressEvent}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct WriterOptions { + pub target: ArchiveVersion, + pub features: FeatureSet, + pub compression_level: Option, +} + +impl WriterOptions { + pub const fn new(target: ArchiveVersion, features: FeatureSet) -> Self { + Self { + target, + features, + compression_level: None, + } + } + + pub const fn with_compression_level(mut self, level: u8) -> Self { + self.compression_level = Some(level); + self + } +} + +impl Default for WriterOptions { + fn default() -> Self { + Self { + target: ArchiveVersion::Rar14, + features: FeatureSet::store_only(), + compression_level: None, + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct StoredEntry<'a> { + pub name: &'a [u8], + pub data: &'a [u8], + pub file_time: u32, + pub file_attr: u8, + pub password: Option<&'a [u8]>, + pub file_comment: Option<&'a [u8]>, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FileEntry<'a> { + pub name: &'a [u8], + pub data: &'a [u8], + pub file_time: u32, + pub file_attr: u8, + pub password: Option<&'a [u8]>, + pub file_comment: Option<&'a [u8]>, +} + +/// One member of an archive written a member at a time. +/// +/// The bytes are opened when the member is coded and dropped once it is +/// written, so an archive of many files never holds more than one of them. A +/// stored member is copied straight from its source and never lands on the heap +/// at all. +#[derive(Debug, Clone)] +pub struct StreamingEntry { + pub name: Vec, + pub source: EntrySource, + pub file_time: u32, + pub file_attr: u8, + pub password: Option>, + pub file_comment: Option>, +} + +impl StreamingEntry { + pub fn new(name: impl Into>, source: EntrySource) -> Self { + Self { + name: name.into(), + source, + file_time: 0, + file_attr: 0, + password: None, + file_comment: None, + } + } + + pub fn with_file_time(mut self, file_time: u32) -> Self { + self.file_time = file_time; + self + } + + pub fn with_file_attr(mut self, file_attr: u8) -> Self { + self.file_attr = file_attr; + self + } + + pub fn with_password(mut self, password: impl Into>) -> Self { + self.password = Some(password.into()); + self + } + + pub fn with_file_comment(mut self, comment: impl Into>) -> Self { + self.file_comment = Some(comment.into()); + self + } +} + +pub fn write_stored_archive( + entries: &[StoredEntry<'_>], + options: WriterOptions, +) -> Result> { + write_stored_archive_with_comment(entries, options, None) +} + +pub fn write_stored_archive_with_comment( + entries: &[StoredEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, +) -> Result> { + write_stored_archive_with_comment_and_progress(entries, options, archive_comment, None) +} + +pub(crate) fn write_stored_archive_with_comment_and_progress( + entries: &[StoredEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let members: Vec<_> = entries.iter().map(Member::from_stored).collect(); + collect_archive( + &members, + options, + MemberCoding::Stored, + archive_comment, + progress, + ) +} + +pub fn write_compressed_archive( + entries: &[FileEntry<'_>], + options: WriterOptions, +) -> Result> { + write_compressed_archive_with_comment(entries, options, None) +} + +/// Builder entries borrow either caller bytes or reopenable sources. This +/// keeps a source-backed archive from materializing every member up front. +pub(crate) struct BorrowedFileEntry<'a> { + pub(crate) file: FileEntry<'a>, + pub(crate) source: Option<&'a EntrySource>, +} + +pub(crate) fn write_archive_with_sources( + entries: &[BorrowedFileEntry<'_>], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, +) -> Result<()> { + let members: Vec<_> = entries + .iter() + .map(|entry| { + let mut member = Member::from_file(&entry.file); + if let Some(source) = entry.source { + member.bytes = MemberBytes::NamedSource(source, entry.file.name); + } + member + }) + .collect(); + write_archive_to( + &members, + options, + coding, + archive_comment, + resources, + progress, + output, + ) +} + +pub fn write_compressed_archive_with_comment( + entries: &[FileEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, +) -> Result> { + write_compressed_archive_with_comment_and_progress(entries, options, archive_comment, None) +} + +pub fn write_compressed_archive_with_comment_and_progress( + entries: &[FileEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let members: Vec<_> = entries.iter().map(Member::from_file).collect(); + collect_archive( + &members, + options, + MemberCoding::Compressed, + archive_comment, + progress, + ) +} + +/// Writes an archive straight to `output`, holding only the member being coded +/// rather than every input at once. +/// +/// `resources` bounds the working set. RAR 1.3 compresses a member as a unit, +/// so a member larger than the budget is coded on its own rather than refused. +pub fn write_streaming_archive_to( + entries: &[StreamingEntry], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, +) -> Result<()> { + // Managed-memory quotas require codec and source allocations to be charged; + // legacy members do not yet provide that accounting. + if resources.max_preparation_bytes().is_some() || resources.max_memory_bytes().is_some() { + return Err(Error::UnsupportedFamilyFeature { + family: options.target.family(), + feature: if resources.max_memory_bytes().is_some() { + "aggregate managed-memory limit" + } else { + "preparation memory quota" + }, + }); + } + + let members: Vec<_> = entries.iter().map(Member::from_streaming).collect(); + write_archive_to( + &members, + options, + coding, + archive_comment, + resources, + progress, + output, + ) +} + +/// One member, however the caller supplied it. +struct Member<'a> { + name: &'a [u8], + bytes: MemberBytes<'a>, + file_time: u32, + file_attr: u8, + password: Option<&'a [u8]>, + file_comment: Option<&'a [u8]>, +} + +impl<'a> Member<'a> { + fn from_stored(entry: &'a StoredEntry<'a>) -> Self { + Self { + name: entry.name, + bytes: MemberBytes::Borrowed(entry.data), + file_time: entry.file_time, + file_attr: entry.file_attr, + password: entry.password, + file_comment: entry.file_comment, + } + } + + fn from_file(entry: &'a FileEntry<'a>) -> Self { + Self { + name: entry.name, + bytes: MemberBytes::Borrowed(entry.data), + file_time: entry.file_time, + file_attr: entry.file_attr, + password: entry.password, + file_comment: entry.file_comment, + } + } + + fn from_streaming(entry: &'a StreamingEntry) -> Self { + Self { + name: &entry.name, + bytes: MemberBytes::Source(&entry.source), + file_time: entry.file_time, + file_attr: entry.file_attr, + password: entry.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + } + } + + fn unpacked_size(&self) -> Result { + usize::try_from(self.bytes.len()?) + .map_err(|_| Error::InvalidArgument("RAR 1.3 file is larger than 32-bit size fields")) + } +} + +/// Runs the streaming writer into a buffer, for the callers that want the +/// archive as bytes. +fn collect_archive( + members: &[Member<'_>], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let mut out = Vec::new(); + write_archive_to( + members, + options, + coding, + archive_comment, + &WriterResources::default(), + progress, + &mut out, + )?; + Ok(out) +} + +fn write_archive_to( + members: &[Member<'_>], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, +) -> Result<()> { + if members.iter().any(|member| member.password.is_some()) { + crate::crypto::require_encryption()?; + } + + let control = + crate::write_progress::ResourceProgress::new(resources, progress.map(ProgressReporter)); + let progress = Some(&control as &dyn WriteProgress); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + let mut output = crate::write_progress::CancellableIo { + inner: output, + progress: progress.map(ProgressReporter), + }; + let output = &mut output as &mut dyn Write; + if !options.target.is_rar13_family() { + return Err(Error::UnsupportedVersion(options.target)); + } + validate_plan(options, coding.shape())?; + if coding.is_filtered() { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: crate::write_plan::WriterOption::Filter, + because: None, + }); + } + + let mut head = Vec::new(); + write_main_header(&mut head, options.features, archive_comment)?; + output.write_all(&head)?; + + let encode_options = rar15_encode_options_for_level(options.compression_level); + let mut solid_encoder = (options.features.solid && coding.compresses()) + .then(|| Unpack15Encoder::with_options(encode_options)); + + let mut total_bytes = 0u64; + for member in members { + total_bytes = total_bytes.saturating_add(member.unpacked_size().map_err(|error| { + crate::write_stream::member_error(error, member.name, "reading source") + })? as u64); + } + // Without a solid chain the writer tries each fallback setting in turn, so + // its progress total counts every byte once per attempt. + let attempts = + if !coding.compresses() || options.features.solid || options.compression_level == Some(0) { + 1 + } else { + rar15_encode_fallback_options(encode_options).len() as u64 + }; + let total_work = total_bytes.saturating_mul(attempts); + let reporting = &control as &dyn WriteProgress; + report_compression_operation(reporting, true, total_work, members.len()); + let work = WorkTracker::new( + Some(ProgressReporter(reporting)), + WriteOperation::Compression, + total_work, + ); + + for (index, member) in members.iter().enumerate() { + work.check()?; + let unpacked_size = member.unpacked_size().map_err(|error| { + crate::write_stream::member_error(error, member.name, "reading source") + })?; + report_compression_entry(reporting, true, index, members.len(), member, unpacked_size); + work.check()?; + let encoded = encode_member( + member, + options, + &coding, + encode_options, + solid_encoder.as_mut(), + resources, + &work, + ) + .map_err(|error| crate::write_stream::member_error(error, member.name, "preparing"))?; + write_member(output, member, encoded, options, work.reporter()) + .map_err(|error| crate::write_stream::member_error(error, member.name, "writing"))?; + member.bytes.release(); + report_compression_entry( + reporting, + false, + index, + members.len(), + member, + unpacked_size, + ); + } + + if !work.finish() { + return Err(Error::Cancelled); + } + report_compression_operation(reporting, false, total_work, members.len()); + work.check()?; + Ok(()) +} + +struct EncodedMember<'a> { + payload: MemberPayload<'a>, + method: u8, + unpacked_size: usize, + file_crc: u16, +} + +/// Working memory one member needs while it is coded. This is the admission +/// weight that keeps concurrent writers from piling up, not a prediction. +fn member_workspace(unpacked: u64, compressing: bool) -> u64 { + if !compressing { + return 1024 * 1024; + } + unpacked.saturating_mul(4).saturating_add(2 * 1024 * 1024) +} + +/// Codes one member, holding its bytes only while it is being coded. +#[allow(clippy::too_many_arguments)] +fn encode_member<'a>( + member: &Member<'a>, + options: WriterOptions, + coding: &MemberCoding, + encode_options: Rar15EncodeOptions, + solid_encoder: Option<&mut Unpack15Encoder>, + resources: &WriterResources, + work: &WorkTracker<'_>, +) -> Result> { + work.check()?; + let unpacked_size = member.unpacked_size()?; + validate_member(member.name, unpacked_size)?; + if member.file_attr & 0x10 != 0 { + if unpacked_size != 0 { + return Err(Error::InvalidArgument( + "RAR1.3/1.4 directories must have no payload", + )); + } + return Ok(EncodedMember { + payload: MemberPayload::Packed(Vec::new()), + method: METHOD_STORE, + unpacked_size: 0, + file_crc: file_checksum(&[]), + }); + } + let _permit = resources.acquire_serialising_cancellable( + member_workspace(unpacked_size as u64, coding.compresses()), + &|| work.is_cancelled(), + )?; + + // A stored member never needs to be resident: checksum it from its source + // and let the writer copy it straight through. + if let (MemberCoding::Stored, None, Some(source)) = + (coding, member.password, member.bytes.source()) + { + return Ok(EncodedMember { + payload: MemberPayload::Copied(source), + method: METHOD_STORE, + unpacked_size, + file_crc: { + let mut checksum = Rar13Checksum::new(); + member.bytes.walk_exact_with_progress( + unpacked_size as u64, + work.reporter(), + |chunk| { + checksum.update(chunk); + work.advance(chunk.len() as u64); + }, + )?; + checksum.finish() + }, + }); + } + + let data = member + .bytes + .load_exact_with_progress(unpacked_size as u64, work.reporter())?; + let mut checksum = Rar13Checksum::new(); + for chunk in data.chunks(64 * 1024) { + work.check()?; + checksum.update(chunk); + if !coding.compresses() { + work.advance(chunk.len() as u64); + } + } + let file_crc = checksum.finish(); + work.check()?; + if !coding.compresses() { + return Ok(EncodedMember { + payload: MemberPayload::Packed(data.into_owned()), + method: METHOD_STORE, + unpacked_size, + file_crc, + }); + } + + let solid = solid_encoder.is_some(); + let mut last = 0usize; + let mut advance = |position: usize| advance_rar15_attempt(&mut last, work, position); + // Every arm that ends up stored hands the payload back below, so none of + // them builds a copy of the member to be thrown away. At level zero and + // where the encoder gave nothing back, that copy was the whole member. + let packed = if let Some(encoder) = solid_encoder { + Some(encoder.encode_member_with_progress(&data, &mut advance)?) + } else if options.compression_level == Some(0) { + None + } else { + encode_verified_rar15_payload_with_progress(&data, encode_options, &mut advance)? + }; + let (packed, method) = select_verified_payload(data, packed, solid); + Ok(EncodedMember { + payload: MemberPayload::Packed(packed), + method, + unpacked_size, + file_crc, + }) +} + +/// Writes one member's header and payload. +fn write_member( + output: &mut dyn Write, + member: &Member<'_>, + encoded: EncodedMember<'_>, + options: WriterOptions, + progress: Option>, +) -> Result<()> { + crate::write_progress::check_cancelled(progress)?; + let payload = match encoded.payload { + MemberPayload::Packed(mut packed) => { + if let Some(password) = member.password { + let mut cipher = Rar13Cipher::for_password(password)?; + for chunk in packed.chunks_mut(64 * 1024) { + crate::write_progress::check_cancelled(progress)?; + for byte in chunk { + *byte = cipher.encrypt_byte(*byte); + } + } + } + MemberPayload::Packed(packed) + } + // Unencrypted by construction, so the stored bytes are their own + // payload. + copied => copied, + }; + let packed_size = payload.size(encoded.unpacked_size as u64); + let packed_size = u32::try_from(packed_size) + .map_err(|_| Error::InvalidArgument("RAR 1.3 file is larger than 32-bit size fields"))?; + + let mut flags = 0u8; + if options.features.solid { + flags |= LHD_SOLID; + } + if member.password.is_some() { + flags |= LHD_PASSWORD; + } + if member.file_comment.is_some() { + flags |= LHD_COMMENT; + } + let file_extra = encode_file_comment(member.file_comment)?; + let mut header = Vec::new(); + write_file_header( + &mut header, + FileEntryRecord { + name: member.name, + unpacked_size: encoded.unpacked_size as u32, + file_crc: encoded.file_crc, + packed_size, + file_time: member.file_time, + file_attr: member.file_attr, + flags, + unp_ver: DEFAULT_UNP_VER, + method: encoded.method, + extra: &file_extra, + }, + )?; + output.write_all(&header)?; + if matches!(payload, MemberPayload::Copied(_)) { + let mut checksum = Rar13Checksum::new(); + payload.write_to( + &mut Rar13ChecksumWriter { + inner: output, + checksum: &mut checksum, + }, + u64::from(packed_size), + )?; + if checksum.finish() != encoded.file_crc { + return Err(Error::SourceChanged( + "entry source contents changed while writing", + )); + } + Ok(()) + } else { + payload.write_to(output, u64::from(packed_size)) + } +} + +pub fn write_stored_volumes( + entry: StoredEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, +) -> Result>> { + write_stored_volumes_with_progress(entry, options, max_packed_per_volume, None) +} + +pub(crate) fn write_stored_volumes_with_progress( + entry: StoredEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, + progress: Option<&dyn WriteProgress>, +) -> Result>> { + let resources = WriterResources::default(); + let control = + crate::write_progress::ResourceProgress::new(&resources, progress.map(ProgressReporter)); + let progress = Some(&control as &dyn WriteProgress); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + if !options.target.is_rar13_family() { + return Err(Error::UnsupportedVersion(options.target)); + } + validate_plan(options, PlanShape::new())?; + validate_volume_writer_inputs( + entry.name, + entry.data, + entry.password, + entry.file_comment, + options, + )?; + + let body = entry.data.to_vec(); + write_split_volumes(SplitVolumeRecord { + name: entry.name, + unpacked: entry.data, + packed: &body, + progress: ProgressReporter(&control), + file_time: entry.file_time, + file_attr: entry.file_attr, + method: METHOD_STORE, + base_flags: 0, + features: options.features, + max_packed_per_volume, + }) +} + +pub fn write_compressed_volumes( + entry: FileEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, +) -> Result>> { + write_compressed_volumes_with_progress(entry, options, max_packed_per_volume, None) +} + +pub fn write_compressed_volumes_with_progress( + entry: FileEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, + progress: Option<&dyn WriteProgress>, +) -> Result>> { + let resources = WriterResources::default(); + let control = + crate::write_progress::ResourceProgress::new(&resources, progress.map(ProgressReporter)); + let progress = Some(&control as &dyn WriteProgress); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + if !options.target.is_rar13_family() { + return Err(Error::UnsupportedVersion(options.target)); + } + validate_plan(options, PlanShape::new().compressed(true))?; + validate_volume_writer_inputs( + entry.name, + entry.data, + entry.password, + entry.file_comment, + options, + )?; + + let encode_options = rar15_encode_options_for_level(options.compression_level); + let total_work = (entry.data.len() as u64) + .saturating_mul(rar15_encode_fallback_options(encode_options).len() as u64); + let reporting = &control as &dyn WriteProgress; + report_compression_operation(reporting, true, total_work, 1); + let work = WorkTracker::new( + progress.map(ProgressReporter), + WriteOperation::Compression, + total_work, + ); + report_compression_entry( + reporting, + true, + 0, + 1, + &Member::from_file(&entry), + entry.data.len(), + ); + let mut last = 0usize; + let mut advance = |position: usize| advance_rar15_attempt(&mut last, &work, position); + let packed = + encode_verified_rar15_payload_with_progress(entry.data, encode_options, &mut advance) + .map_err(|error| { + crate::write_stream::member_error(error, entry.name, "compressing volume member") + })?; + let (packed, method) = + select_verified_payload(std::borrow::Cow::Borrowed(entry.data), packed, false); + let result = write_split_volumes(SplitVolumeRecord { + name: entry.name, + unpacked: entry.data, + packed: &packed, + progress: ProgressReporter(&control), + file_time: entry.file_time, + file_attr: entry.file_attr, + method, + base_flags: 0, + features: options.features, + max_packed_per_volume, + }); + report_compression_entry( + reporting, + false, + 0, + 1, + &Member::from_file(&entry), + entry.data.len(), + ); + let result = result?; + if !work.finish() { + return Err(Error::Cancelled); + } + report_compression_operation(reporting, false, total_work, 1); + work.check()?; + Ok(result) +} + +fn report_compression_operation( + progress: &dyn WriteProgress, + started: bool, + total_bytes: u64, + total_entries: usize, +) { + if started { + progress.report(WriteProgressEvent::OperationStarted { + operation: WriteOperation::Compression, + total_bytes: Some(total_bytes), + total_entries: Some(total_entries), + pass: 1, + }); + } else { + progress.report(WriteProgressEvent::OperationFinished { + operation: WriteOperation::Compression, + total_bytes: Some(total_bytes), + total_entries: Some(total_entries), + pass: 1, + }); + } +} + +fn report_compression_entry( + progress: &dyn WriteProgress, + started: bool, + index: usize, + total_entries: usize, + member: &Member<'_>, + input_bytes: usize, +) { + let name = member.name; + let input_bytes = input_bytes as u64; + if started { + progress.report(WriteProgressEvent::EntryStarted { + operation: WriteOperation::Compression, + index, + total_entries, + name, + input_bytes, + }); + } else { + progress.report(WriteProgressEvent::EntryFinished { + operation: WriteOperation::Compression, + index, + total_entries, + name, + input_bytes, + }); + } +} + +/// Everything this writer refuses, in one place, before anything is written. +fn validate_plan(options: WriterOptions, shape: PlanShape) -> Result<()> { + crate::write_plan::validate_features(options.target, options.features, shape)?; + crate::write_plan::validate_compression_level(options.target, options.compression_level) +} + +fn validate_volume_writer_inputs( + name: &[u8], + data: &[u8], + password: Option<&[u8]>, + file_comment: Option<&[u8]>, + options: WriterOptions, +) -> Result<()> { + validate_file_entry(name, data).map_err(|error| { + crate::write_stream::member_error(error, name, "preparing volume member") + })?; + if password.is_some() { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: WriterOption::Password, + because: Some("in a volume set"), + }); + } + if file_comment.is_some() { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: WriterOption::FileComment, + because: Some("in a volume set"), + }); + } + Ok(()) +} + +fn rar15_encode_options_for_level(level: Option) -> Rar15EncodeOptions { + // Both callers have validated 0..=5 before resolving the encoder policy. + let level = usize::from(level.unwrap_or(5)); + let options = Rar15EncodeOptions::new() + .with_lazy_matching(level == 5) + .with_stmode_literal_runs(level >= 3); + let max_distance = [ + Some(0), + Some(4 * 1024), + Some(8 * 1024), + Some(16 * 1024), + Some(24 * 1024), + None, + ][level]; + match max_distance { + Some(distance) => options.with_max_long_match_distance(distance), + None => options, + } +} + +/// The encoder reports positions within each attempt, restarting at zero for +/// a verification fallback. Account only the new bytes in that attempt. +fn advance_rar15_attempt(last: &mut usize, work: &WorkTracker<'_>, position: usize) -> bool { + if position < *last { + *last = 0; + } + let delta = position.saturating_sub(*last); + *last = position; + work.advance(delta as u64) +} + +fn select_verified_payload( + data: std::borrow::Cow<'_, [u8]>, + packed: Option>, + solid: bool, +) -> (Vec, u8) { + match packed { + Some(packed) + if !crate::write_plan::StoreFallback::new().applies( + solid, + data.len(), + packed.len(), + ) => + { + (packed, METHOD_BEST) + } + _ => (data.into_owned(), METHOD_STORE), + } +} + +fn encode_verified_rar15_payload_with_progress( + data: &[u8], + options: Rar15EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result>> { + encode_verified_rar15_payload_using( + data, + options, + progress, + unpack15_encode_with_options_and_progress, + ) +} + +fn encode_verified_rar15_payload_using( + data: &[u8], + options: Rar15EncodeOptions, + progress: &mut dyn FnMut(usize) -> bool, + mut encode: impl FnMut( + &[u8], + Rar15EncodeOptions, + &mut dyn FnMut(usize) -> bool, + ) -> crate::codec::Result>, +) -> Result>> { + for candidate_options in rar15_encode_fallback_options(options) { + let packed = match encode(data, candidate_options, progress) { + Err(crate::codec::Error::Cancelled) => return Err(Error::Cancelled), + result => result?, + }; + if unpack15_payload_matches(&packed, data)? { + return Ok(Some(packed)); + } + } + Ok(None) +} + +fn rar15_encode_fallback_options(options: Rar15EncodeOptions) -> Vec { + let mut candidates = vec![options]; + let distance_limited = options.with_max_long_match_distance(24 * 1024); + if distance_limited != options { + candidates.push(distance_limited); + } + let conservative = options + .with_lazy_matching(false) + .with_stmode_literal_runs(false) + .with_max_long_match_distance(8 * 1024); + if !candidates.contains(&conservative) { + candidates.push(conservative); + } + candidates +} + +fn unpack15_payload_matches(packed: &[u8], data: &[u8]) -> Result { + match unpack15_decode(packed, data.len()) { + Ok(decoded) => Ok(decoded == data), + Err(_) => Ok(false), + } +} + +fn write_main_header( + out: &mut Vec, + features: FeatureSet, + archive_comment: Option<&[u8]>, +) -> Result<()> { + write_main_header_with_flags(out, features, archive_comment, 0) +} + +fn write_main_header_with_flags( + out: &mut Vec, + features: FeatureSet, + archive_comment: Option<&[u8]>, + extra_flags: u8, +) -> Result<()> { + let comment_extra = encode_archive_comment(archive_comment)?; + let mut flags = MHD_ALWAYS_SET | extra_flags; + if archive_comment.is_some() { + flags |= MHD_COMMENT; + flags |= MHD_PACK_COMMENT; + } + if features.solid { + flags |= MHD_SOLID; + } + out.extend_from_slice(RAR13_SIGNATURE); + let head_size = MAIN_HEAD_SIZE as usize + comment_extra.len(); + if head_size > u16::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 main header comment extension is too large", + )); + } + out.extend_from_slice(&(head_size as u16).to_le_bytes()); + out.push(flags); + out.extend_from_slice(&comment_extra); + Ok(()) +} + +struct FileEntryRecord<'a> { + name: &'a [u8], + unpacked_size: u32, + file_crc: u16, + packed_size: u32, + file_time: u32, + file_attr: u8, + flags: u8, + unp_ver: u8, + method: u8, + extra: &'a [u8], +} + +fn write_file_header(out: &mut Vec, entry: FileEntryRecord<'_>) -> Result<()> { + let head_size = FILE_HEAD_BASE_SIZE + entry.name.len() + entry.extra.len(); + let head_size = u16::try_from(head_size) + .map_err(|_| Error::InvalidArgument("RAR 1.3 file header is longer than 65535 bytes"))?; + out.extend_from_slice(&entry.packed_size.to_le_bytes()); + out.extend_from_slice(&entry.unpacked_size.to_le_bytes()); + out.extend_from_slice(&entry.file_crc.to_le_bytes()); + out.extend_from_slice(&head_size.to_le_bytes()); + out.extend_from_slice(&entry.file_time.to_le_bytes()); + out.push(entry.file_attr); + out.push(entry.flags); + out.push(entry.unp_ver); + out.push(entry.name.len() as u8); + out.push(entry.method); + out.extend_from_slice(entry.name); + out.extend_from_slice(entry.extra); + Ok(()) +} + +struct SplitVolumeRecord<'a> { + progress: ProgressReporter<'a>, + name: &'a [u8], + unpacked: &'a [u8], + packed: &'a [u8], + file_time: u32, + file_attr: u8, + method: u8, + base_flags: u8, + features: FeatureSet, + max_packed_per_volume: usize, +} + +fn write_split_volumes(entry: SplitVolumeRecord<'_>) -> Result>> { + crate::write_progress::check_cancelled(Some(entry.progress))?; + if entry.max_packed_per_volume == 0 { + return Err(Error::InvalidArgument( + "RAR 1.3 volume payload size must be non-zero", + )); + } + if entry.packed.is_empty() { + return Err(Error::InvalidArgument( + "RAR 1.3 volume writer needs a non-empty packed payload", + ) + .at_entry(entry.name.to_vec(), "preparing volume member")); + } + + // One volume is a legitimate answer when the payload fits; see the note in + // rar15_40::write::write_split_volumes. + let chunks: Vec<&[u8]> = entry.packed.chunks(entry.max_packed_per_volume).collect(); + + let mut volumes = Vec::with_capacity(chunks.len()); + for (index, chunk) in chunks.iter().enumerate() { + crate::write_progress::check_cancelled(Some(entry.progress))?; + let split_before = index > 0; + let split_after = index + 1 < chunks.len(); + let mut flags = entry.base_flags; + if split_before { + flags |= LHD_SPLIT_BEFORE; + } + if split_after { + flags |= LHD_SPLIT_AFTER; + } + if entry.features.solid { + flags |= LHD_SOLID; + } + + let mut out = Vec::new(); + write_main_header_with_flags(&mut out, entry.features, None, MHD_VOLUME)?; + let checksum_data = if split_after { *chunk } else { entry.unpacked }; + // Both public callers validate the 255-byte name limit and forbid + // comments, so this header is at most 21 + 255 bytes. + write_file_header( + &mut out, + FileEntryRecord { + name: entry.name, + unpacked_size: entry.unpacked.len() as u32, + file_crc: file_checksum(checksum_data), + packed_size: chunk.len() as u32, + file_time: entry.file_time, + file_attr: entry.file_attr, + flags, + unp_ver: DEFAULT_UNP_VER, + method: entry.method, + extra: &[], + }, + ) + .expect("validated legacy volume header fits the u16 size field"); + out.extend_from_slice(chunk); + entry.progress.report(WriteProgressEvent::VolumeFinished { + volume_number: index + 1, + total_volumes: Some(chunks.len()), + bytes: out.len() as u64, + }); + crate::write_progress::check_cancelled(Some(entry.progress))?; + volumes.push(out); + } + + Ok(volumes) +} + +fn encode_archive_comment(comment: Option<&[u8]>) -> Result> { + let Some(comment) = comment else { + return Ok(Vec::new()); + }; + if comment.len() > u16::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 archive comment is longer than 65535 bytes", + )); + } + let mut packed = unpack15_encode(comment)?; + Rar13Cipher::new_comment().encrypt_in_place(&mut packed); + let packed_field_len = packed.len().checked_add(2).ok_or(Error::InvalidArgument( + "RAR 1.3 archive comment size overflows", + ))?; + if packed_field_len > u16::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 packed archive comment is longer than 65535 bytes", + )); + } + + let mut out = Vec::with_capacity(4 + packed.len()); + out.extend_from_slice(&(packed_field_len as u16).to_le_bytes()); + out.extend_from_slice(&(comment.len() as u16).to_le_bytes()); + out.extend_from_slice(&packed); + Ok(out) +} + +fn encode_file_comment(comment: Option<&[u8]>) -> Result> { + let Some(comment) = comment else { + return Ok(Vec::new()); + }; + if comment.len() > u16::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 file comment is longer than 65535 bytes", + )); + } + let mut out = Vec::with_capacity(2 + comment.len()); + out.extend_from_slice(&(comment.len() as u16).to_le_bytes()); + out.extend_from_slice(comment); + Ok(out) +} + +fn validate_file_entry(name: &[u8], data: &[u8]) -> Result<()> { + validate_member(name, data.len()) +} + +fn validate_member(name: &[u8], unpacked_size: usize) -> Result<()> { + if name.is_empty() { + return Err(Error::InvalidArgument("RAR 1.3 file name is empty")); + } + if name.len() > u8::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 file name is longer than 255 bytes", + )); + } + if unpacked_size > u32::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.3 file is larger than 32-bit size fields", + )); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + #[test] + fn writer_cancellation_during_workspace_admission_is_preserved() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + struct CancelOnSecondPoll(AtomicUsize); + impl crate::WriteProgress for CancelOnSecondPoll { + fn report(&self, _: crate::WriteProgressEvent<'_>) {} + + fn is_cancelled(&self) -> bool { + self.0.fetch_add(1, Ordering::Relaxed) != 0 + } + } + + let entry = super::FileEntry { + name: b"file", + data: b"payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let callback = CancelOnSecondPoll(AtomicUsize::new(0)); + let work = super::WorkTracker::new( + Some(super::ProgressReporter(&callback)), + crate::WriteOperation::Compression, + 7, + ); + let resources = crate::WriterResources::new(1); + let options = super::WriterOptions::default(); + assert!(matches!( + super::encode_member( + &super::Member::from_file(&entry), + options, + &crate::MemberCoding::Stored, + super::rar15_encode_options_for_level(options.compression_level), + None, + &resources, + &work, + ), + Err(crate::Error::Cancelled) + )); + assert_eq!(callback.0.load(Ordering::Relaxed), 2); + assert_eq!(resources.workspace_in_use(), 0); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_extraction_preserves_output_io_failures() { + struct FailingWriter; + impl std::io::Write for FailingWriter { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::new( + std::io::ErrorKind::BrokenPipe, + "closed output", + )) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let data = b"encrypted output failure".repeat(64); + let input = [FileEntry { + name: b"encrypted.bin", + data: &data, + file_time: 0, + file_attr: 0x20, + password: Some(b"pw"), + file_comment: None, + }]; + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries[0].is_encrypted()); + assert!(!archive.entries[0].is_stored()); + let error = archive + .extract_to(Some(b"pw"), |_| Ok(Box::new(FailingWriter))) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert!(error.to_string().contains("closed output")); + } + + #[test] + fn volume_headers_accept_the_largest_legacy_name() { + let name = vec![b'N'; 255]; + let payload = b"abcdef"; + let volumes = write_stored_volumes( + StoredEntry { + name: &name, + data: payload, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + WriterOptions::default(), + 3, + ) + .unwrap(); + assert_eq!(volumes.len(), 2); + let archives: Vec<_> = volumes.iter().map(|v| Archive::parse(v).unwrap()).collect(); + for archive in &archives { + assert_eq!(archive.entries[0].name, name); + } + assert_eq!( + collect_extract_volumes(&archives, None).unwrap()[0].data, + payload + ); + } + + #[test] + fn reader_workspace_rar13_stored_archives_need_no_dictionary_allocation() { + for encrypted in crate::test_features::encryption_cases() { + let password = encrypted.then_some(b"pw".as_slice()); + let input = [StoredEntry { + name: b"stored.bin", + data: b"stored payload", + file_time: 0, + file_attr: 0x20, + password, + file_comment: None, + }]; + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let quota = Allowance::limited(0); + archive + .extract_with_allowance( + crate::ArchiveReadOptions::with_optional_password(password), + &mut |_| Ok(Box::new(std::io::sink())), + None, + None, + "a, + ) + .unwrap(); + assert_eq!(quota.used(), 0); + } + } + + #[test] + fn reader_workspace_rar13_refusals_release_dictionary_input_and_stream_buffers() { + use crate::codec::workspace::RefusingBudget; + let data = b"abcabcabc".repeat(64); + for encrypted in crate::test_features::encryption_cases() { + let password = encrypted.then_some(b"pw".as_slice()); + let input = [FileEntry { + name: b"compressed.bin", + data: &data, + file_time: 0, + file_attr: 0x20, + password, + file_comment: None, + }]; + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let entry = &archive.entries[0]; + assert!(!entry.is_stored()); + let run = |quota: &RefusingBudget| -> Result<()> { + let mut decoder = Decoder15::with_allowance(quota); + let mut out = Buffer::new(quota); + entry.write_compressed_to(&archive, password, &mut decoder, false, &mut out)?; + assert_eq!(&out[..], &data); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let quota = RefusingBudget::new(index); + let error = run("a).unwrap_err(); + assert_eq!( + entry.entry_error("extracting", error).kind(), + crate::ErrorKind::Cancelled, + "allocation {index}" + ); + assert_eq!(quota.used(), 0); + } + let quota = Allowance::limited(1); + let error = archive + .extract_with_allowance( + crate::ArchiveReadOptions::with_optional_password(password), + &mut |_| Ok(Box::new(std::io::sink())), + None, + None, + "a, + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(quota.used(), 0); + } + } + + #[test] + fn writer_limits_are_invalid_arguments() { + for error in [ + super::validate_member(b"", 0).unwrap_err(), + super::validate_member(&[b'a'; 256], 0).unwrap_err(), + super::encode_file_comment(Some(&vec![0; 65536])).unwrap_err(), + super::encode_archive_comment(Some(&vec![0; 65536])).unwrap_err(), + ] { + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument, "{error}"); + } + #[cfg(target_pointer_width = "64")] + assert_eq!( + super::validate_member(b"large", u32::MAX as usize + 1) + .unwrap_err() + .kind(), + crate::ErrorKind::InvalidArgument + ); + } + + #[test] + fn header_budget_refuses_full_main_read_after_prefix() { + let mut prefix = super::RAR13_SIGNATURE.to_vec(); + prefix.extend_from_slice(&64u16.to_le_bytes()); + prefix.push(0); + let mut reader = crate::parse_budget::PrefixReader::new(prefix); + let e = super::Archive::parse_seekable( + &mut reader, + 128, + 0, + super::ArchiveSource::Memory(std::sync::Arc::new([])), + crate::ArchiveReadOptions::new().with_max_header_bytes(63), + ) + .unwrap_err(); + assert!(matches!( + e.root_cause(), + crate::Error::HeaderBytesLimitExceeded { required: 64, .. } + )); + assert_eq!(reader.reads, [7]); + } + + #[test] + fn limited_header_admission_rejects_malformed_fixed_prefixes() { + let options = crate::ArchiveReadOptions::new().with_max_header_count(2); + let check = |prefix: &[u8], remaining, main| { + let mut budget = crate::parse_budget::ParseBudget::new(options); + super::admit_header(prefix, remaining, main, &mut budget, 0).unwrap_err() + }; + + let mut main = [0u8; super::MAIN_HEAD_SIZE as usize]; + main[..4].copy_from_slice(super::RAR13_SIGNATURE); + main[4..6].copy_from_slice(&7u16.to_le_bytes()); + assert_eq!(check(&main[..6], 7, true), Error::TooShort); + let mut wrong_signature = main; + wrong_signature[0] = 0; + assert_eq!( + check(&wrong_signature, 7, true), + Error::UnsupportedSignature + ); + main[4..6].copy_from_slice(&6u16.to_le_bytes()); + assert_eq!( + check(&main, 7, true), + Error::InvalidHeader("RAR 1.3 main header is shorter than 7 bytes") + ); + main[4..6].copy_from_slice(&8u16.to_le_bytes()); + assert_eq!(check(&main, 7, true), Error::TooShort); + + let mut file = [0u8; super::FILE_HEAD_BASE_SIZE]; + file[19] = 3; + file[10..12].copy_from_slice(&24u16.to_le_bytes()); + assert_eq!(check(&file[..20], 24, false), Error::TooShort); + file[10..12].copy_from_slice(&23u16.to_le_bytes()); + assert_eq!( + check(&file, 24, false), + Error::InvalidHeader("RAR 1.3 file header is shorter than its name") + ); + file[10..12].copy_from_slice(&25u16.to_le_bytes()); + assert_eq!(check(&file, 24, false), Error::TooShort); + } + use super::*; + use crate::codec::rar13::{find_long_lz, LongLz}; + use std::cell::RefCell; + use std::rc::Rc; + use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}; + + struct CollectWriter(Rc>>); + + #[test] + fn compressed_writer_reports_balanced_progress_events() { + let entries = [ + FileEntry { + name: b"one.txt", + data: b"one one one one", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + FileEntry { + name: b"two.txt", + data: b"two two two two", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + let operation_starts = AtomicUsize::new(0); + let operation_finishes = AtomicUsize::new(0); + let entry_starts = AtomicUsize::new(0); + let entry_finishes = AtomicUsize::new(0); + let advances = AtomicUsize::new(0); + let last_completed = AtomicU64::new(0); + let expected_total = AtomicU64::new(0); + let reporter = |event: WriteProgressEvent<'_>| match event { + WriteProgressEvent::OperationStarted { total_bytes, .. } => { + operation_starts.fetch_add(1, Ordering::Relaxed); + expected_total.store(total_bytes.unwrap_or(0), Ordering::Relaxed); + } + WriteProgressEvent::OperationFinished { .. } => { + operation_finishes.fetch_add(1, Ordering::Relaxed); + } + WriteProgressEvent::EntryStarted { .. } => { + entry_starts.fetch_add(1, Ordering::Relaxed); + } + WriteProgressEvent::EntryFinished { .. } => { + entry_finishes.fetch_add(1, Ordering::Relaxed); + } + WriteProgressEvent::Advanced { + completed_bytes, + total_bytes, + .. + } => { + assert!(completed_bytes >= last_completed.swap(completed_bytes, Ordering::Relaxed)); + assert!(completed_bytes <= total_bytes); + advances.fetch_add(1, Ordering::Relaxed); + } + _ => {} + }; + + write_compressed_archive_with_comment_and_progress( + &entries, + WriterOptions::default(), + None, + Some(&reporter), + ) + .unwrap(); + + assert_eq!(operation_starts.load(Ordering::Relaxed), 1); + assert_eq!(operation_finishes.load(Ordering::Relaxed), 1); + assert_eq!(entry_starts.load(Ordering::Relaxed), entries.len()); + assert_eq!(entry_finishes.load(Ordering::Relaxed), entries.len()); + assert!(advances.load(Ordering::Relaxed) >= entries.len()); + assert_eq!( + last_completed.load(Ordering::Relaxed), + expected_total.load(Ordering::Relaxed) + ); + } + + #[derive(Debug, Clone, PartialEq, Eq)] + struct CollectedEntry { + name: Vec, + data: Vec, + file_time: u32, + file_attr: u8, + is_directory: bool, + } + + impl Write for CollectWriter { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + fn collect_extract(archive: &Archive, password: Option<&[u8]>) -> Result> { + let entries = RefCell::new(Vec::new()); + archive.extract_to(password, |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter(data))) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time, + file_attr: meta.file_attr, + is_directory: meta.is_directory, + }) + .collect()) + } + + fn collect_extract_volumes( + volumes: &[Archive], + password: Option<&[u8]>, + ) -> Result> { + let entries = RefCell::new(Vec::new()); + extract_volumes_to(volumes, password, |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter(data))) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time, + file_attr: meta.file_attr, + is_directory: meta.is_directory, + }) + .collect()) + } + + fn synthetic_log_payload(lines: usize) -> Vec { + let mut data = Vec::new(); + for index in 0..lines { + data.extend_from_slice( + format!( + "2026-05-12T12:{:02}:{:02}.000Z INFO worker-{:02} request_id={:04x}-{:05} path=/api/v1/items/{} status={} elapsed_ms={} bytes={} message=processed archive chunk retry={} user=service-{}\n", + index % 60, + (index * 7) % 60, + index % 16, + index % 10000, + (index * 17) % 100000, + index % 2048, + 200 + (index % 5), + (index * 37) % 5000, + (index * 911) % 65536, + index % 3, + index % 32 + ) + .as_bytes(), + ); + } + data + } + + #[test] + fn writes_and_reads_stored_archive() { + let input = [ + StoredEntry { + name: b"README.md", + data: b"hello rar 1.3", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + StoredEntry { + name: b"docs", + data: b"", + file_time: 0, + file_attr: 0x10, + password: None, + file_comment: None, + }, + ]; + + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.main.flags, 0x80); + assert_eq!(archive.entries.len(), 2); + assert_eq!(archive.entries[0].name_bytes(), b"README.md"); + assert_eq!(archive.entries[0].name_lossy(), "README.md"); + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"hello rar 1.3"); + assert!(archive.entries[1].is_directory()); + assert!(extracted[1].is_directory); + } + + #[test] + fn rejects_malformed_main_header_boundaries() { + assert_eq!(MainHeader::parse(b"RE~"), Err(Error::TooShort)); + + let mut too_small = Vec::from(&b"RE~^"[..]); + too_small.extend_from_slice(&6u16.to_le_bytes()); + too_small.push(0x80); + assert_eq!( + MainHeader::parse(&too_small), + Err(Error::InvalidHeader( + "RAR 1.3 main header is shorter than 7 bytes" + )) + ); + + let mut truncated_extra = Vec::from(&b"RE~^"[..]); + truncated_extra.extend_from_slice(&8u16.to_le_bytes()); + truncated_extra.push(0x80); + assert_eq!(MainHeader::parse(&truncated_extra), Err(Error::TooShort)); + + assert!(matches!( + Archive::parse(b"Rar!\x1a\x07\x00"), + Err(Error::UnsupportedSignature) + )); + } + + #[test] + fn rejects_file_header_shorter_than_its_name() { + let mut bytes = Vec::from(&b"RE~^"[..]); + bytes.extend_from_slice(&7u16.to_le_bytes()); + bytes.push(0x80); + bytes.extend_from_slice(&0u32.to_le_bytes()); + bytes.extend_from_slice(&0u32.to_le_bytes()); + bytes.extend_from_slice(&0u16.to_le_bytes()); + bytes.extend_from_slice(&(FILE_HEAD_BASE_SIZE as u16).to_le_bytes()); + bytes.extend_from_slice(&0u32.to_le_bytes()); + bytes.push(0x20); + bytes.push(0); + bytes.push(DEFAULT_UNP_VER); + bytes.push(10); + bytes.push(METHOD_STORE); + + assert!(matches!( + Archive::parse(&bytes), + Err(Error::InvalidHeader( + "RAR 1.3 file header is shorter than its name" + )) + )); + } + + #[test] + fn rejects_truncated_file_payload_during_parse() { + let input = [StoredEntry { + name: b"hello.txt", + data: b"hello", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + let mut bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + bytes.pop(); + + assert!(matches!(Archive::parse(&bytes), Err(Error::TooShort))); + } + + #[test] + fn returns_none_for_absent_archive_comment() { + let bytes = write_stored_archive(&[], WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + + assert_eq!(archive.archive_comment().unwrap(), None); + } + + #[test] + fn rejects_normal_extract_on_split_entries() { + let entry = StoredEntry { + name: b"split.bin", + data: b"abcdefghijklmnopqrstuvwxyz", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let volumes = write_stored_volumes(entry, WriterOptions::default(), 8).unwrap(); + let first = Archive::parse(&volumes[0]).unwrap(); + + assert_eq!( + collect_extract(&first, None), + Err(Error::InvalidHeader( + "RAR 1.3 split entry requires multivolume extraction" + )) + ); + assert_eq!( + collect_extract(&first, None), + Err(Error::InvalidHeader( + "RAR 1.3 split entry requires multivolume extraction" + )) + ); + } + + #[test] + fn controlled_extraction_rejects_split_member_without_volume_set() { + let entry = StoredEntry { + name: b"split.bin", + data: b"abcdefghijklmnopqrstuvwxyz", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let volumes = write_stored_volumes(entry, WriterOptions::default(), 8).unwrap(); + for volume in [&volumes[0], volumes.last().unwrap()] { + let archive = crate::Archive::Rar13(Archive::parse(volume).unwrap()); + let error = archive + .extract_with_control(crate::ArchiveReadOptions::new(), |_| { + Ok(crate::ExtractionDecision::Extract(Box::new(Vec::new()))) + }) + .unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::InvalidHeader("RAR 1.3 split entry requires multivolume extraction") + ); + } + } + + #[test] + fn rejects_malformed_comment_extensions() { + let packed_too_short = Archive { + sfx_offset: 0, + main: MainHeader { + flags: MHD_COMMENT | MHD_PACK_COMMENT, + head_size: MAIN_HEAD_SIZE, + extra: 1u16.to_le_bytes().to_vec(), + }, + entries: Vec::new(), + source: ArchiveSource::Memory(Arc::new([])), + }; + assert_eq!( + packed_too_short.archive_comment(), + Err(Error::InvalidHeader( + "RAR 1.3 packed archive comment is shorter than size field" + )) + ); + + let unpacked_too_short = Archive { + sfx_offset: 0, + main: MainHeader { + flags: MHD_COMMENT, + head_size: MAIN_HEAD_SIZE, + extra: 4u16.to_le_bytes().to_vec(), + }, + entries: Vec::new(), + source: ArchiveSource::Memory(Arc::new([])), + }; + assert_eq!(unpacked_too_short.archive_comment(), Err(Error::TooShort)); + } + + #[test] + fn rejects_malformed_av_extensions() { + let too_short = Archive { + sfx_offset: 0, + main: MainHeader { + flags: MHD_AV, + head_size: MAIN_HEAD_SIZE, + extra: 5u16.to_le_bytes().to_vec(), + }, + entries: Vec::new(), + source: ArchiveSource::Memory(Arc::new([])), + }; + assert_eq!( + too_short.authenticity_verification(), + Err(Error::InvalidHeader("RAR 1.3 AV payload is too short")) + ); + + let bad_prefix = Archive { + sfx_offset: 0, + main: MainHeader { + flags: MHD_AV, + head_size: MAIN_HEAD_SIZE, + extra: { + let mut extra = 6u16.to_le_bytes().to_vec(); + extra.extend_from_slice(b"badbad"); + extra + }, + }, + entries: Vec::new(), + source: ArchiveSource::Memory(Arc::new([])), + }; + assert_eq!( + bad_prefix.authenticity_verification(), + Err(Error::InvalidHeader("RAR 1.3 AV prefix mismatch")) + ); + + let mut truncated_payload = bad_prefix; + truncated_payload.main.extra[0..2].copy_from_slice(&7u16.to_le_bytes()); + assert_eq!( + truncated_payload.authenticity_verification(), + Err(Error::TooShort) + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn writes_and_reads_encrypted_stored_archive() { + let input = [StoredEntry { + name: b"secret.txt", + data: b"secret bytes", + file_time: 0, + file_attr: 0x20, + password: Some(b"pass"), + file_comment: None, + }]; + + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries[0].is_encrypted()); + match collect_extract(&archive, None) { + Err(Error::NeedPassword) => {} + Err(Error::AtEntry { source, .. }) if matches!(*source, Error::NeedPassword) => {} + other => panic!("expected missing password error, got {other:?}"), + } + + let extracted = collect_extract(&archive, Some(b"pass")).unwrap(); + assert_eq!(extracted[0].data, b"secret bytes"); + } + + #[test] + fn writes_and_reads_archive_comment() { + let input = [StoredEntry { + name: b"README.md", + data: b"hello rar 1.3", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_stored_archive_with_comment( + &input, + WriterOptions::default(), + Some(b"This is an archive comment."), + ) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.main.has_archive_comment()); + assert!(archive.main.has_packed_comment()); + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&b"This is an archive comment."[..]) + ); + assert_eq!( + collect_extract(&archive, None).unwrap()[0].data, + b"hello rar 1.3" + ); + } + + #[test] + fn writes_and_reads_file_comment() { + let input = [StoredEntry { + name: b"README.md", + data: b"hello rar 1.3", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: Some(b"file comment\r\n"), + }]; + + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries[0].has_file_comment()); + assert_eq!( + archive.entries[0].file_comment().unwrap().as_deref(), + Some(&b"file comment\r\n"[..]) + ); + assert_eq!( + collect_extract(&archive, None).unwrap()[0].data, + b"hello rar 1.3" + ); + + let mut truncated_comment = archive.entries[0].clone(); + truncated_comment.extra = vec![5, 0, b'x']; + assert_eq!(truncated_comment.file_comment(), Err(Error::TooShort)); + assert!(matches!( + archive.entries[0].verify_checksum(b"wrong data"), + Err(Error::CrcMismatch { .. }) + )); + } + + #[test] + fn writes_and_reads_literal_only_compressed_archive() { + let input = [FileEntry { + name: b"tiny.txt", + data: b"literal bytes over sixteen", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.main.flags, 0x80); + assert_eq!(archive.entries.len(), 1); + assert_eq!(archive.entries[0].name, b"tiny.txt"); + assert!(archive.entries[0].is_stored()); + assert_eq!(archive.entries[0].header.method, METHOD_STORE); + assert_eq!( + archive.entries[0].header.pack_size, + input[0].data.len() as u32 + ); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b"literal bytes over sixteen"); + } + + #[test] + fn writes_and_reads_literal_only_compressed_archive_with_repeated_stmode() { + let data = + b"this literal-only payload is long enough to enter and exit stmode more than once"; + let input = [FileEntry { + name: b"long.txt", + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.entries[0].header.method, METHOD_BEST); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn compressed_writer_levels_control_rar15_encoder_policy() { + let mut data: Vec<_> = (0..5000).map(|index| (index * 73 + 19) as u8).collect(); + data.extend_from_within(..256); + let input = [FileEntry { + name: b"level-policy.bin", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let level_one = + write_compressed_archive(&input, WriterOptions::default().with_compression_level(1)) + .unwrap(); + let level_five = + write_compressed_archive(&input, WriterOptions::default().with_compression_level(5)) + .unwrap(); + let level_one = Archive::parse(&level_one).unwrap(); + let level_five = Archive::parse(&level_five).unwrap(); + let level_one_file = &level_one.entries[0]; + let level_five_file = &level_five.entries[0]; + + assert_eq!(level_one_file.header.method, METHOD_BEST); + assert_eq!(level_five_file.header.method, METHOD_BEST); + assert!(level_five_file.header.pack_size < level_one_file.header.pack_size); + assert_eq!(collect_extract(&level_one, None).unwrap()[0].data, data); + assert_eq!(collect_extract(&level_five, None).unwrap()[0].data, data); + } + + #[test] + fn rar14_writer_uses_old_distance_tokens() { + for level in 0..=5 { + let options = rar15_encode_options_for_level(Some(level)); + assert!( + options.old_distance_tokens_enabled(), + "RAR 1.4 level {level} should consider old-distance tokens" + ); + } + } + + #[test] + fn rar14_level_five_uses_lazy_matching() { + for level in 0..5 { + assert!(!rar15_encode_options_for_level(Some(level)).lazy_matching_enabled()); + } + assert!(rar15_encode_options_for_level(Some(5)).lazy_matching_enabled()); + } + + #[test] + fn compressed_writer_keeps_adaptive_lz_planning_in_sync_after_literals() { + let data = synthetic_log_payload(8000); + let input = [FileEntry { + name: b"synthetic.log", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = + write_compressed_archive(&input, WriterOptions::default().with_compression_level(2)) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let extracted = collect_extract(&archive, None).unwrap(); + + assert_eq!(extracted[0].data, data); + } + + #[test] + fn compressed_writer_emits_short_lz_matches() { + let data = b"abcabcabcabcabcabcabcabcabcabcabcabc"; + let input = [FileEntry { + name: b"repeat.txt", + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.entries[0].header.method, METHOD_BEST); + assert!( + archive.entries[0].header.pack_size < data.len() as u32, + "ShortLZ should make the repeated payload smaller than stored data" + ); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn compressed_writer_emits_long_lz_matches() { + let mut data = short_lz_resistant_prefix(300); + data.extend_from_within(..32); + assert_eq!( + find_long_lz(&data, 300, 0x8000), + Some(LongLz { + distance: 44, + length: 32 + }) + ); + let input = [FileEntry { + name: b"far.txt", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let literal_only = Unpack15Encoder::new() + .encode_literals_only(&data) + .unwrap() + .len(); + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.entries[0].header.method, METHOD_BEST); + assert!( + (archive.entries[0].header.pack_size as usize) < literal_only, + "LongLZ should make a >256-byte-distance repeat smaller than literal-only output" + ); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn compressed_writer_stores_incompressible_member_when_smaller() { + let mut state = 0x8765_4321u32; + let data: Vec<_> = (0..8192) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let input = [FileEntry { + name: b"randomish.bin", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + + assert_eq!(archive.entries[0].header.method, METHOD_STORE); + assert_eq!(archive.entries[0].header.pack_size, data.len() as u32); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, data); + } + + #[test] + fn compressed_writer_stores_tiny_incompressible_member_when_smaller() { + let data = b"\x00\xff\x12\xed\x34\xcb\x56\xa9\x78\x87\x9a\x65\xbc\x43\xde\x21"; + let input = [FileEntry { + name: b"tiny.bin", + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + + assert_eq!(archive.entries[0].header.method, METHOD_STORE); + assert_eq!(archive.entries[0].header.pack_size, data.len() as u32); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, data); + } + + #[test] + fn writes_and_reads_solid_compressed_archive() { + let input = [ + FileEntry { + name: b"first.txt", + data: b"first member primes the adaptive unpack15 state", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + FileEntry { + name: b"second.txt", + data: b"second member is encoded without resetting that state", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + let mut features = FeatureSet::store_only(); + features.solid = true; + let options = WriterOptions { + target: ArchiveVersion::Rar14, + features, + ..WriterOptions::default() + }; + + let bytes = write_compressed_archive(&input, options).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.main.is_solid()); + assert_eq!(archive.entries.len(), 2); + assert!(archive + .entries + .iter() + .all(|entry| entry.header.flags & LHD_SOLID != 0)); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, input[0].data); + assert_eq!(extracted[1].data, input[1].data); + } + + #[test] + #[cfg(feature = "encryption")] + fn writes_and_reads_encrypted_compressed_archive() { + let input = [FileEntry { + name: b"secret.txt", + data: b"secret compressed bytes over sixteen", + file_time: 0, + file_attr: 0x20, + password: Some(b"pass"), + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries[0].is_encrypted()); + assert_eq!(archive.entries[0].header.method, METHOD_STORE); + assert!(matches!( + collect_extract(&archive, None), + Err(Error::NeedPassword) + )); + + let extracted = collect_extract(&archive, Some(b"pass")).unwrap(); + assert_eq!(extracted[0].data, input[0].data); + } + + #[test] + fn writes_and_reads_compressed_file_comment() { + let input = [FileEntry { + name: b"commented.txt", + data: b"compressed member with file comment", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: Some(b"compressed file comment"), + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!( + archive.entries[0].file_comment().unwrap().as_deref(), + Some(&b"compressed file comment"[..]) + ); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, input[0].data); + } + + #[test] + fn writes_and_reads_stored_multivolume_archive() { + let entry = StoredEntry { + name: b"random.bin", + data: b"abcdefghijklmnopqrstuvwxyz0123456789", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + + let bytes = write_stored_volumes(entry, WriterOptions::default(), 10).unwrap(); + assert_eq!(bytes.len(), 4); + let volumes: Vec<_> = bytes + .iter() + .map(|bytes| Archive::parse(bytes).unwrap()) + .collect(); + assert!(volumes.iter().all(|archive| archive.main.is_volume())); + assert!(!volumes[0].entries[0].is_split_before()); + assert!(volumes[0].entries[0].is_split_after()); + assert!(volumes[1].entries[0].is_split_before()); + assert!(volumes[1].entries[0].is_split_after()); + assert!(volumes[3].entries[0].is_split_before()); + assert!(!volumes[3].entries[0].is_split_after()); + assert!(volumes.iter().all(|archive| archive.entries[0].is_stored())); + + let extracted = collect_extract_volumes(&volumes, None).unwrap(); + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].name, b"random.bin"); + assert_eq!(extracted[0].data, entry.data); + } + + #[test] + fn writes_and_reads_compressed_multivolume_archive() { + let data = b"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc"; + let entry = FileEntry { + name: b"repeat.txt", + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + + let bytes = write_compressed_volumes(entry, WriterOptions::default(), 8).unwrap(); + assert!(bytes.len() >= 2); + let volumes: Vec<_> = bytes + .iter() + .map(|bytes| Archive::parse(bytes).unwrap()) + .collect(); + assert!(volumes.iter().all(|archive| archive.main.is_volume())); + assert!(!volumes[0].entries[0].is_stored()); + assert!(volumes[0].entries[0].is_split_after()); + assert!(volumes.last().unwrap().entries[0].is_split_before()); + assert!(!volumes.last().unwrap().entries[0].is_split_after()); + + let extracted = collect_extract_volumes(&volumes, None).unwrap(); + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].name, b"repeat.txt"); + assert_eq!(extracted[0].data, data); + } + + fn short_lz_resistant_prefix(len: usize) -> Vec { + let mut data = Vec::with_capacity(len); + while data.len() < len { + let next = (0u8..=u8::MAX) + .find(|&candidate| { + if data.len() < 2 { + return true; + } + let start = data.len().saturating_sub(256); + !data[start..].windows(3).any(|window| { + window == [data[data.len() - 2], data[data.len() - 1], candidate] + }) + }) + .expect("byte alphabet can avoid local 3-byte repeats"); + data.push(next); + } + data + } + + #[test] + fn writes_empty_compressed_archive_member() { + let input = [FileEntry { + name: b"empty.bin", + data: b"", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_compressed_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.entries[0].header.method, METHOD_STORE); + assert_eq!(archive.entries[0].header.pack_size, 0); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, b""); + } + + #[test] + fn rejects_rar5_only_features_for_rar13() { + let mut features = FeatureSet::store_only(); + features.quick_open = true; + + let options = WriterOptions { + target: ArchiveVersion::Rar13, + features, + ..WriterOptions::default() + }; + let err = write_stored_archive(&[], options).unwrap_err(); + assert_eq!( + err, + Error::UnsupportedWriterOption { + target: ArchiveVersion::Rar13, + option: WriterOption::Feature(crate::Feature::QuickOpen), + because: None, + } + ); + assert_eq!( + err.to_string(), + "a quick-open index is not supported by rar13" + ); + } + + #[test] + fn rejects_header_encryption_for_rar13() { + let mut features = FeatureSet::store_only(); + features.header_encryption = true; + + let options = WriterOptions { + target: ArchiveVersion::Rar14, + features, + ..WriterOptions::default() + }; + let err = write_stored_archive(&[], options).unwrap_err(); + if cfg!(feature = "encryption") { + assert_eq!( + err.to_string(), + "header encryption is not supported by rar14" + ); + } else { + assert_eq!( + err, + Error::FeatureDisabled { + feature: "encryption" + } + ); + } + } + + #[test] + fn file_checksum_matches_rar13_algorithm() { + assert_eq!(file_checksum(b""), 0x0000); + assert_eq!(file_checksum(b"123456789"), 0xc78a); + } + + #[test] + fn rar13_checksum_writer_flush_propagates_to_inner_writer() { + struct FlushSpy { + data: Vec, + flushed: usize, + } + impl Write for FlushSpy { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.data.extend_from_slice(buf); + Ok(buf.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + self.flushed += 1; + Ok(()) + } + } + let mut inner = FlushSpy { + data: Vec::new(), + flushed: 0, + }; + let mut checksum = Rar13Checksum::new(); + let mut writer = Rar13ChecksumWriter { + inner: &mut inner, + checksum: &mut checksum, + }; + writer.write_all(b"hello").unwrap(); + writer.flush().unwrap(); + assert_eq!(inner.data, b"hello"); + assert_eq!(inner.flushed, 1); + } + + #[test] + fn entry_packed_data_returns_borrowed_slice_for_memory_archives() { + let payload = b"packed_data direct accessor coverage"; + let input = [StoredEntry { + name: b"slice.bin", + data: payload, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let entry = &archive.entries[0]; + + let packed = entry.packed_data(&archive).unwrap(); + assert_eq!(packed, payload); + assert!(!packed.is_empty()); + } + + #[test] + fn extract_volumes_to_annotates_failed_non_split_entry_with_at_entry() { + let payload = b"corrupt-me-please"; + let input = [StoredEntry { + name: b"plain.bin", + data: payload, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let mut bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let range = archive.entries[0].packed_range.clone(); + // Flip a byte in the stored payload so the checksum no longer matches. + bytes[range.start] ^= 0xff; + + let corrupted = Archive::parse(&bytes).unwrap(); + let err = collect_extract_volumes(std::slice::from_ref(&corrupted), None).unwrap_err(); + match err { + Error::AtEntry { + name, + operation, + source, + } => { + assert_eq!(name, b"plain.bin"); + assert_eq!(operation, "extracting"); + assert!(matches!(*source, Error::CrcMismatch { .. })); + } + other => panic!("expected AtEntry annotation, got {other:?}"), + } + } + + #[test] + fn extract_volumes_to_annotates_failed_split_completion_with_at_entry() { + let entry = StoredEntry { + name: b"split.bin", + data: b"abcdefghijklmnopqrstuvwxyz0123456789", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + + let mut volume_bytes = write_stored_volumes(entry, WriterOptions::default(), 10).unwrap(); + assert!( + volume_bytes.len() >= 2, + "need at least two volumes to exercise the split-completion path" + ); + + // Corrupt the last fragment so PendingSplitRefs::write_to fails on assembly. + let last_index = volume_bytes.len() - 1; + let last_archive = Archive::parse(&volume_bytes[last_index]).unwrap(); + let last_range = last_archive.entries[0].packed_range.clone(); + volume_bytes[last_index][last_range.start] ^= 0x7f; + + let volumes: Vec<_> = volume_bytes + .iter() + .map(|bytes| Archive::parse(bytes).unwrap()) + .collect(); + + let err = collect_extract_volumes(&volumes, None).unwrap_err(); + match err { + Error::AtEntry { + name, + operation, + source, + } => { + assert_eq!(name, b"split.bin"); + assert_eq!(operation, "extracting"); + assert!( + matches!(*source, Error::CrcMismatch { .. }), + "expected CrcMismatch source, got {source:?}" + ); + } + other => panic!("expected AtEntry annotation, got {other:?}"), + } + } + + #[test] + fn entry_packed_data_refuses_to_buffer_file_backed_archives() { + let payload = b"packed_data refuses file-backed"; + let input = [StoredEntry { + name: b"file.bin", + data: payload, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + + let dir = crate::scratch::case("rars-rar13-packed-data"); + let path = dir.join("entry.rar"); + std::fs::write(&path, &bytes).unwrap(); + + let archive = Archive::parse_path(&path).unwrap(); + let result = archive.entries[0].packed_data(&archive); + assert_eq!( + result, + Err(Error::InvalidHeader( + "RAR 1.3 file-backed packed data requires owned read" + )) + ); + } + + fn parse_volumes(bytes: &[Vec]) -> Vec { + bytes.iter().map(|b| Archive::parse(b).unwrap()).collect() + } + + fn split_volumes_for(name: &[u8], data: &[u8]) -> Vec> { + write_stored_volumes( + StoredEntry { + name, + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + WriterOptions::default(), + 10, + ) + .unwrap() + } + + #[test] + fn extract_volumes_to_rejects_pending_split_interrupted_by_regular_entry() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let mut volumes = parse_volumes(&bytes); + + // After volume 0's split_after entry, append a regular entry to the + // same volume so the loop sees pending=Some when it hits a non-split. + let mut intruder = volumes[0].entries[0].clone(); + intruder.header.flags &= !(LHD_SPLIT_BEFORE | LHD_SPLIT_AFTER); + intruder.name = b"intruder.bin".to_vec(); + volumes[0].entries.push(intruder); + + let err = collect_extract_volumes(&volumes, None).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.3 split entry is interrupted by a regular entry"), + ); + } + + #[test] + fn extract_volumes_to_rejects_split_with_inconsistent_flags() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let volumes = parse_volumes(&bytes); + + // Take just the *middle* volume in isolation: it has split_before=true + // but no preceding pending state, which the match arm treats as + // structurally inconsistent. + let middle = volumes.into_iter().nth(1).unwrap(); + let err = collect_extract_volumes(std::slice::from_ref(&middle), None).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.3 split entry flags are inconsistent"), + ); + } + + #[test] + fn extract_volumes_to_rejects_pending_split_left_incomplete_at_end() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let volumes = parse_volumes(&bytes); + + // Use only the first volume, which leaves pending=Some after the loop. + let err = collect_extract_volumes(std::slice::from_ref(&volumes[0]), None).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.3 split entry is incomplete") + ); + } + + #[test] + fn extract_volumes_to_rejects_split_fragments_with_drifted_attributes() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let mut volumes = parse_volumes(&bytes); + + // Mutate the second volume's entry name so PendingSplitRefs::append + // refuses it on a name-mismatch. + volumes[1].entries[0].name = b"different.bin".to_vec(); + + let err = collect_extract_volumes(&volumes, None).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.3 split entry name changed") + ); + } + + #[test] + fn extract_volumes_to_rejects_split_fragments_with_drifted_method() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let mut volumes = parse_volumes(&bytes); + + // Drift the compression method on the second fragment. + volumes[1].entries[0].header.method = METHOD_BEST; + let err = collect_extract_volumes(&volumes, None).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.3 split entry compression method changed"), + ); + } + + #[test] + fn extract_volumes_to_rejects_split_version_and_encryption_drift() { + let bytes = split_volumes_for(b"split.bin", b"abcdefghijklmnopqrstuvwxyz"); + let mut volumes = parse_volumes(&bytes); + volumes[1].entries[0].header.unp_ver += 1; + assert_eq!( + collect_extract_volumes(&volumes, None).unwrap_err(), + Error::InvalidHeader("RAR 1.3 split entry unpack version changed") + ); + + let mut volumes = parse_volumes(&bytes); + volumes[1].entries[0].header.flags ^= LHD_PASSWORD; + assert_eq!( + collect_extract_volumes(&volumes, None).unwrap_err(), + Error::InvalidHeader("RAR 1.3 split entry encryption flag changed") + ); + } + + #[test] + fn extract_volumes_to_carries_directory_entries_across_volume_array() { + // A directory entry has zero-length data and gets the open() callback + // invoked but no payload write. Putting it in a volumes array keeps + // the directory branch in extract_volumes_to (rather than extract_to) + // exercised. + let input = [StoredEntry { + name: b"docs", + data: b"", + file_time: 0, + file_attr: 0x10, + password: None, + file_comment: None, + }]; + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + + let extracted = collect_extract_volumes(std::slice::from_ref(&archive), None).unwrap(); + assert_eq!(extracted.len(), 1); + assert!(extracted[0].is_directory); + assert_eq!(extracted[0].name, b"docs"); + } + + #[test] + fn extract_volumes_to_routes_pending_split_reader_through_fragment_chain() { + // Larger payload over more volumes guarantees that the chained + // fragment reader reads from each volume's range_reader at least once, + // exercising the success arms of fragment_reader, write_to, and + // ChainedReader::read across multiple volumes. + let payload: Vec = (0..96).map(|i| ((i * 53) ^ 0xa5) as u8).collect(); + let bytes = split_volumes_for(b"chain.bin", &payload); + assert!( + bytes.len() >= 3, + "need at least three volumes for the chain" + ); + let volumes = parse_volumes(&bytes); + + let extracted = collect_extract_volumes(&volumes, None).unwrap(); + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].data, payload); + } + + #[test] + fn write_compressed_archive_with_comment_round_trips_through_archive_comment() { + let data = b"compressed archive comment payload payload payload"; + let comment = b"This is a compressed archive comment."; + let input = [FileEntry { + name: b"payload.txt", + data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + + let bytes = + write_compressed_archive_with_comment(&input, WriterOptions::default(), Some(comment)) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.main.has_archive_comment()); + assert!(archive.main.has_packed_comment()); + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&comment[..]) + ); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn write_compressed_archive_with_comment_emits_solid_compressed_archive() { + let data1 = b"solid compressed payload one with overlap overlap overlap"; + let data2 = b"solid compressed payload two with overlap overlap overlap"; + let mut features = FeatureSet::store_only(); + features.solid = true; + let options = WriterOptions { + target: ArchiveVersion::Rar14, + features, + ..WriterOptions::default() + }; + let input = [ + FileEntry { + name: b"a.txt", + data: data1, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + FileEntry { + name: b"b.txt", + data: data2, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + + let bytes = write_compressed_archive_with_comment(&input, options, None).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.main.is_solid()); + assert_eq!(archive.entries.len(), 2); + + let extracted = collect_extract(&archive, None).unwrap(); + assert_eq!(extracted[0].data, data1); + assert_eq!(extracted[1].data, data2); + } + + #[test] + fn write_compressed_archive_with_comment_rejects_non_rar13_target() { + let options = WriterOptions { + target: ArchiveVersion::Rar15, + ..WriterOptions::default() + }; + let err = write_compressed_archive_with_comment(&[], options, None).unwrap_err(); + assert_eq!(err, Error::UnsupportedVersion(ArchiveVersion::Rar15)); + } + + #[test] + fn parse_path_round_trips_multi_entry_archive_via_file_backed_seekable_path() { + // Two entries plus an archive comment forces parse_seekable to walk + // through more than one file-header read iteration. + let input = [ + StoredEntry { + name: b"first.txt", + data: b"first payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + StoredEntry { + name: b"second.txt", + data: b"second payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + let bytes = write_stored_archive_with_comment( + &input, + WriterOptions::default(), + Some(b"file-backed comment"), + ) + .unwrap(); + + let dir = crate::scratch::case("rars-rar13-parse-seekable"); + let path = dir.join("multi.rar"); + std::fs::write(&path, &bytes).unwrap(); + + let archive = Archive::parse_path(&path).unwrap(); + assert_eq!(archive.entries.len(), 2); + assert_eq!(archive.entries[0].name, b"first.txt"); + assert_eq!(archive.entries[1].name, b"second.txt"); + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&b"file-backed comment"[..]) + ); + } + + #[test] + fn parse_path_rejects_files_without_rar13_signature() { + let dir = crate::scratch::case("rars-rar13-parse-path-bad"); + let path = dir.join("not_a_rar.bin"); + std::fs::write(&path, [0u8; 64]).unwrap(); + + let err = Archive::parse_path(&path).unwrap_err(); + assert_eq!(err, Error::UnsupportedSignature); + } + + #[test] + fn controlled_extraction_uses_selected_directory_and_file_writers() { + let entries = [ + StoredEntry { + name: b"docs", + data: b"", + file_time: 0, + file_attr: 0x10, + password: None, + file_comment: None, + }, + StoredEntry { + name: b"docs/readme.txt", + data: b"old archive data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + let bytes = write_stored_archive(&entries, WriterOptions::default()).unwrap(); + let archive = crate::Archive::Rar13(Archive::parse(&bytes).unwrap()); + let output = Rc::new(RefCell::new(Vec::new())); + let mut seen = Vec::new(); + let outcome = archive + .extract_with_control(crate::ArchiveReadOptions::new(), |member| { + seen.push(member.meta.name.clone()); + Ok(crate::ExtractionDecision::Extract(Box::new(CollectWriter( + Rc::clone(&output), + )))) + }) + .unwrap(); + + assert_eq!(outcome, crate::ExtractionOutcome::Complete); + assert_eq!(seen, [b"docs".to_vec(), b"docs/readme.txt".to_vec()]); + assert_eq!(&*output.borrow(), b"old archive data"); + } + + #[test] + fn directory_extraction_skips_payload_even_with_compressed_method() { + let entries = [StoredEntry { + name: b"DIR", + data: b"", + file_time: 0, + file_attr: 0x10, + password: None, + file_comment: None, + }]; + let bytes = write_stored_archive(&entries, WriterOptions::default()).unwrap(); + let mut archive = Archive::parse(&bytes).unwrap(); + archive.entries[0].header.method = METHOD_BEST; + assert!(collect_extract(&archive, None).unwrap()[0].is_directory); + assert!( + collect_extract_volumes(std::slice::from_ref(&archive), None).unwrap()[0].is_directory + ); + } + + #[test] + fn empty_rar13_archive_cannot_supply_preservation_target_version() { + let bytes = write_stored_archive(&[], WriterOptions::default()).unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries.is_empty()); + assert!(archive + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("empty legacy archive"))); + } + + #[test] + fn streaming_writer_refuses_unsupported_aggregate_quotas_before_output() { + for (resources, feature) in [ + ( + WriterResources::default().with_max_preparation_bytes(0), + "preparation memory quota", + ), + ( + WriterResources::default().with_max_memory_bytes(0), + "aggregate managed-memory limit", + ), + ] { + let mut output = Vec::new(); + let error = write_streaming_archive_to( + &[], + WriterOptions::default(), + MemberCoding::Stored, + None, + &resources, + None, + &mut output, + ) + .unwrap_err(); + assert!(matches!( + error, + Error::UnsupportedFamilyFeature { feature: actual, .. } if actual == feature + )); + assert!(output.is_empty()); + } + } + + #[test] + fn volume_writer_rejects_empty_payload_for_both_codings() { + let stored = StoredEntry { + name: b"empty", + data: b"", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let compressed = FileEntry { + name: stored.name, + data: stored.data, + file_time: stored.file_time, + file_attr: stored.file_attr, + password: None, + file_comment: None, + }; + for error in [ + write_stored_volumes(stored, WriterOptions::default(), 1024).unwrap_err(), + write_compressed_volumes(compressed, WriterOptions::default(), 1024).unwrap_err(), + ] { + assert!(matches!( + error.root_cause(), + Error::InvalidArgument("RAR 1.3 volume writer needs a non-empty packed payload") + )); + } + } + + #[test] + fn archive_comment_rejects_packed_output_beyond_header_field() { + let mut state = 0x1234_5678u32; + let comment: Vec<_> = (0..u16::MAX) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + let valid = write_stored_archive_with_comment( + &[], + WriterOptions::default(), + Some(&comment[..64755]), + ) + .unwrap(); + assert_eq!( + Archive::parse(&valid) + .unwrap() + .archive_comment() + .unwrap() + .unwrap(), + comment[..64755] + ); + assert_eq!( + encode_archive_comment(Some(&comment[..64760])) + .unwrap() + .len(), + 65530 + ); + assert_eq!( + write_stored_archive_with_comment( + &[], + WriterOptions::default(), + Some(&comment[..64760]), + ) + .unwrap_err(), + Error::InvalidArgument("RAR 1.3 main header comment extension is too large") + ); + let error = + write_stored_archive_with_comment(&[], WriterOptions::default(), Some(&comment)) + .unwrap_err(); + assert_eq!( + error, + Error::InvalidArgument("RAR 1.3 packed archive comment is longer than 65535 bytes") + ); + } + + #[test] + fn supplied_rar13_signature_and_file_length_are_checked() { + let entries = [StoredEntry { + name: b"member", + data: b"payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + let bytes = write_stored_archive(&entries, WriterOptions::default()).unwrap(); + let signature = crate::detect_archive_family(&bytes).unwrap(); + let dir = crate::scratch::case("rars-rar13-supplied-signature"); + let path = dir.join("archive.rar"); + std::fs::write(&path, &bytes).unwrap(); + + assert_eq!( + Archive::parse_owned(bytes.clone()).unwrap().entries.len(), + 1 + ); + assert_eq!( + Archive::parse_path_with_signature(&path, signature) + .unwrap() + .entries + .len(), + 1 + ); + assert_eq!( + Archive::parse_path_with_signature_and_options( + &path, + crate::ArchiveSignature { + family: ArchiveFamily::Rar15To40, + ..signature + }, + crate::ArchiveReadOptions::new(), + ) + .unwrap_err(), + Error::UnsupportedSignature + ); + + let mut wrong_magic = bytes.clone(); + wrong_magic[0] = 0; + std::fs::write(&path, &wrong_magic).unwrap(); + assert_eq!( + Archive::parse_path_with_signature(&path, signature).unwrap_err(), + Error::UnsupportedSignature + ); + + let mut oversized_payload = bytes; + oversized_payload[7..11].copy_from_slice(&u32::MAX.to_le_bytes()); + std::fs::write(&path, &oversized_payload).unwrap(); + assert_eq!( + Archive::parse_owned(oversized_payload).unwrap_err(), + Error::TooShort + ); + assert_eq!( + Archive::parse_path_with_signature(&path, signature).unwrap_err(), + Error::TooShort + ); + + std::fs::write(&path, crate::detect::RAR15_SIGNATURE).unwrap(); + assert_eq!( + Archive::parse_path(&path).unwrap_err(), + Error::UnsupportedSignature + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn extract_to_encrypted_archive_reads_through_file_backed_decrypted_range() { + // The Memory-backed path is already exercised; this test takes the + // same encrypted archive out to disk so copy_decrypted_range_to runs + // its ArchiveSource::File branch. + let input = [StoredEntry { + name: b"secret.bin", + data: b"file-backed secret payload", + file_time: 0, + file_attr: 0x20, + password: Some(b"pw"), + file_comment: None, + }]; + let bytes = write_stored_archive(&input, WriterOptions::default()).unwrap(); + + let dir = crate::scratch::case("rars-rar13-decrypt-file"); + let path = dir.join("encrypted.rar"); + std::fs::write(&path, &bytes).unwrap(); + + let archive = Archive::parse_path(&path).unwrap(); + let extracted = collect_extract(&archive, Some(b"pw")).unwrap(); + assert_eq!(extracted[0].data, b"file-backed secret payload"); + } + + #[test] + fn write_stored_volumes_rejects_password_protected_entries() { + let entry = StoredEntry { + name: b"locked.bin", + data: b"data", + file_time: 0, + file_attr: 0x20, + password: Some(b"pw"), + file_comment: None, + }; + let err = write_stored_volumes(entry, WriterOptions::default(), 16).unwrap_err(); + assert_eq!( + err, + Error::UnsupportedWriterOption { + target: ArchiveVersion::Rar14, + option: WriterOption::Password, + because: Some("in a volume set"), + } + ); + assert_eq!( + err.to_string(), + "encryption is not supported by rar14 (in a volume set)" + ); + } + + #[test] + fn write_compressed_volumes_rejects_file_comments() { + let entry = FileEntry { + name: b"with-comment.bin", + data: b"data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: Some(b"note"), + }; + let err = write_compressed_volumes(entry, WriterOptions::default(), 16).unwrap_err(); + assert_eq!( + err.to_string(), + "a per-file comment is not supported by rar14 (in a volume set)" + ); + } + + #[test] + fn write_compressed_volumes_rejects_non_rar13_target() { + let options = WriterOptions { + target: ArchiveVersion::Rar20, + ..WriterOptions::default() + }; + let entry = FileEntry { + name: b"x.bin", + data: b"data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let err = write_compressed_volumes(entry, options, 16).unwrap_err(); + assert_eq!(err, Error::UnsupportedVersion(ArchiveVersion::Rar20)); + } + + #[test] + fn file_header_parse_rejects_input_below_base_size() { + let err = FileHeader::parse(&[0u8; FILE_HEAD_BASE_SIZE - 1]).unwrap_err(); + assert_eq!(err, Error::TooShort); + } + + #[test] + fn file_header_parse_rejects_truncated_input_against_declared_head_size() { + // Build a syntactically OK FILE_HEAD_BASE_SIZE buffer that declares a + // head_size larger than the slice we pass in — exercises the + // post-name-size length check at the end of FileHeader::parse. + let mut header = [0u8; FILE_HEAD_BASE_SIZE]; + // pack_size, unp_size, file_crc, file_time stay zero. + let declared_head_size: u16 = (FILE_HEAD_BASE_SIZE + 32) as u16; + header[10..12].copy_from_slice(&declared_head_size.to_le_bytes()); + // name_size = 0 keeps minimum_size == FILE_HEAD_BASE_SIZE so the + // earlier "shorter than its name" branch is bypassed. + header[19] = 0; + let err = FileHeader::parse(&header).unwrap_err(); + assert_eq!(err, Error::TooShort); + } + + #[test] + fn archive_comment_rejects_size_field_shorter_than_two_bytes() { + // Build a valid stored archive then patch its main header so the + // declared comment field is shorter than two bytes — exercises the + // "packed archive comment is shorter than size field" arm. + let input = [StoredEntry { + name: b"file.bin", + data: b"data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + let bytes = + write_stored_archive_with_comment(&input, WriterOptions::default(), Some(b"hi")) + .unwrap(); + let mut archive = Archive::parse(&bytes).unwrap(); + // The first two bytes of `main.extra` are the comment_field length — + // overwrite them with 1 to declare a sub-2-byte payload while keeping + // the packed-comment flag set. + archive.main.extra[0] = 1; + archive.main.extra[1] = 0; + assert_eq!( + archive.archive_comment(), + Err(Error::InvalidHeader( + "RAR 1.3 packed archive comment is shorter than size field" + )) + ); + } + + #[test] + fn archive_comment_rejects_packed_payload_extending_past_extra_buffer() { + let input = [StoredEntry { + name: b"file.bin", + data: b"data", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }]; + let bytes = + write_stored_archive_with_comment(&input, WriterOptions::default(), Some(b"hi")) + .unwrap(); + let mut archive = Archive::parse(&bytes).unwrap(); + // Pump the declared comment field length up so the packed range walks + // past the end of `main.extra`. + let inflated = (archive.main.extra.len() as u16 + 16).to_le_bytes(); + archive.main.extra[0] = inflated[0]; + archive.main.extra[1] = inflated[1]; + assert_eq!(archive.archive_comment(), Err(Error::TooShort)); + } + + #[test] + fn streaming_writer_attributes_source_size_failures() { + let missing = crate::scratch::case("rars-rar13-missing-source").join("absent"); + for (source, expected, operation) in [ + ( + EntrySource::from_path(missing), + crate::ErrorKind::Io, + "reading source", + ), + ( + EntrySource::from_opener(u64::from(u32::MAX) + 1, || { + unreachable!("oversized source must fail before opening") + }), + crate::ErrorKind::InvalidArgument, + "preparing", + ), + ] { + let entry = StreamingEntry::new(b"SOURCE.BIN".to_vec(), source); + let mut output = Vec::new(); + let error = write_streaming_archive_to( + &[entry], + WriterOptions::default(), + MemberCoding::Stored, + None, + &WriterResources::default(), + None, + &mut output, + ) + .unwrap_err(); + assert_eq!(error.kind(), expected); + assert_eq!(error.entry_context(), Some((&b"SOURCE.BIN"[..], operation))); + } + } + + #[test] + fn file_comment_respects_the_total_file_header_limit() { + let max_comment_len = u16::MAX as usize - FILE_HEAD_BASE_SIZE - 1 - 2; + let comment = vec![b'x'; max_comment_len + 1]; + let entry = StoredEntry { + name: b"f", + data: b"payload", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: Some(&comment[..max_comment_len]), + }; + let valid = write_stored_archive(&[entry], WriterOptions::default()).unwrap(); + let archive = Archive::parse(&valid).unwrap(); + assert_eq!( + archive.entries[0].file_comment().unwrap(), + Some(comment[..max_comment_len].to_vec()) + ); + + let oversized = StoredEntry { + file_comment: Some(&comment), + ..entry + }; + assert!(matches!( + write_stored_archive(&[oversized], WriterOptions::default()) + .unwrap_err() + .root_cause(), + Error::InvalidArgument("RAR 1.3 file header is longer than 65535 bytes") + )); + } + + #[test] + fn verified_encoder_retries_corrupt_payload_then_accepts_valid_fallback() { + let data = b"legacy archive payload legacy archive payload"; + let valid = unpack15_encode(data).unwrap(); + let options = Rar15EncodeOptions::new(); + let mut attempts = 0; + let packed = + encode_verified_rar15_payload_using(data, options, &mut |_| true, |_, _, _| { + attempts += 1; + Ok(if attempts == 1 { + Vec::new() + } else { + valid.clone() + }) + }) + .unwrap(); + assert_eq!(packed, Some(valid)); + assert_eq!(attempts, 2); + } + + #[test] + fn verified_encoder_progress_counts_each_retry_once() { + let data = b"legacy fallback progress payload"; + let valid = unpack15_encode(data).unwrap(); + let completed = std::sync::Mutex::new(Vec::new()); + let reporter = |event: WriteProgressEvent<'_>| { + if let WriteProgressEvent::Advanced { + completed_bytes, .. + } = event + { + completed.lock().unwrap().push(completed_bytes); + } + }; + let work = WorkTracker::new( + Some(ProgressReporter(&reporter)), + WriteOperation::Compression, + (data.len() * 3) as u64, + ); + let mut last = 0; + let mut progress = |position| advance_rar15_attempt(&mut last, &work, position); + let mut attempts = 0; + let packed = encode_verified_rar15_payload_using( + data, + Rar15EncodeOptions::new(), + &mut progress, + |input, _, report| { + attempts += 1; + assert!(report(0)); + assert!(report(input.len() / 2)); + assert!(report(input.len())); + Ok(if attempts == 1 { + Vec::new() + } else { + valid.clone() + }) + }, + ) + .unwrap(); + assert_eq!(packed, Some(valid)); + assert_eq!(attempts, 2); + let half = (data.len() / 2) as u64; + let full = data.len() as u64; + assert_eq!( + *completed.lock().unwrap(), + [0, half, full, full, full + half, full * 2] + ); + } + + #[test] + fn verified_payload_selection_preserves_storage_and_solid_history() { + let data = b"original payload"; + let (payload, method) = + select_verified_payload(std::borrow::Cow::Borrowed(data), Some(vec![1, 2]), false); + assert_eq!(payload, [1, 2]); + assert_eq!(method, METHOD_BEST); + + let owned = data.to_vec(); + let allocation = owned.as_ptr(); + let (payload, method) = select_verified_payload( + std::borrow::Cow::Owned(owned), + Some(vec![0; data.len() + 1]), + false, + ); + assert_eq!(payload, data); + assert_eq!(payload.as_ptr(), allocation); + assert_eq!(method, METHOD_STORE); + + let packed = vec![0; data.len() + 1]; + let (payload, method) = + select_verified_payload(std::borrow::Cow::Borrowed(data), Some(packed.clone()), true); + assert_eq!(payload, packed); + assert_eq!(method, METHOD_BEST); + } + + #[test] + fn verified_encoder_stores_when_every_candidate_fails_verification() { + let data = b"legacy archive payload"; + let mut attempts = 0; + let packed = encode_verified_rar15_payload_using( + data, + Rar15EncodeOptions::new(), + &mut |_| true, + |_, _, _| { + attempts += 1; + Ok(Vec::new()) + }, + ) + .unwrap(); + assert_eq!(packed, None); + let (payload, method) = + select_verified_payload(std::borrow::Cow::Borrowed(data), packed, false); + assert_eq!(payload, data); + assert_eq!(method, METHOD_STORE); + assert_eq!( + attempts, + rar15_encode_fallback_options(Rar15EncodeOptions::new()).len() + ); + } + + #[test] + fn verified_encoder_propagates_cancellation_during_fallback() { + let data = b"legacy archive payload"; + let mut attempts = 0; + let error = encode_verified_rar15_payload_using( + data, + Rar15EncodeOptions::new(), + &mut |_| true, + |_, _, _| { + attempts += 1; + if attempts == 1 { + Ok(Vec::new()) + } else { + Err(crate::codec::Error::Cancelled) + } + }, + ) + .unwrap_err(); + assert_eq!(error, Error::Cancelled); + assert_eq!(attempts, 2); + } + + #[test] + fn streaming_writer_detects_source_size_change_between_passes() { + struct ChangingLength(AtomicUsize); + impl crate::streaming::SourceFactory for ChangingLength { + fn len(&self) -> Result { + if self.0.fetch_add(1, Ordering::Relaxed) == 0 { + Ok(3) + } else { + Err(Error::SourceChanged("source size changed")) + } + } + + fn open(&self) -> Result> { + unreachable!("changed source must fail before opening") + } + } + let entry = StreamingEntry::new( + b"CHANGED.BIN".to_vec(), + EntrySource::from_factory(ChangingLength(AtomicUsize::new(0))), + ); + let error = write_streaming_archive_to( + &[entry], + WriterOptions::default(), + MemberCoding::Stored, + None, + &WriterResources::default(), + None, + &mut Vec::new(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::SourceChanged); + assert_eq!( + error.entry_context(), + Some((&b"CHANGED.BIN"[..], "reading source")) + ); + } + + #[test] + fn compression_level_zero_writes_a_stored_member() { + let entry = FileEntry { + name: b"ZERO.TXT", + data: b"zero-level compression leaves these bytes stored", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let bytes = + write_compressed_archive(&[entry], WriterOptions::default().with_compression_level(0)) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert!(archive.entries[0].is_stored()); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, entry.data); + } + + #[test] + fn level_four_uses_a_distinct_verified_fallback_plan() { + let options = rar15_encode_options_for_level(Some(4)); + let candidates = rar15_encode_fallback_options(options); + assert_eq!(candidates.len(), 2); + + let data = b"level four compressed legacy payload ".repeat(32); + let entry = FileEntry { + name: b"LEVEL4.TXT", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let bytes = + write_compressed_archive(&[entry], WriterOptions::default().with_compression_level(4)) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(collect_extract(&archive, None).unwrap()[0].data, data); + } + + #[test] + fn stored_volume_writer_refuses_non_legacy_target() { + let entry = StoredEntry { + name: b"WRONG.TXT", + data: b"contents", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()); + assert_eq!( + write_stored_volumes(entry, options, 8).unwrap_err(), + Error::UnsupportedVersion(ArchiveVersion::Rar50) + ); + } + + #[test] + fn solid_volume_writer_marks_every_fragment() { + let data = b"a stored member across several solid volumes".repeat(16); + let entry = FileEntry { + name: b"SOLID.TXT", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let mut features = FeatureSet::store_only(); + features.solid = true; + let options = WriterOptions::new(ArchiveVersion::Rar14, features); + let volumes = write_compressed_volumes(entry, options, 8).unwrap(); + assert!(volumes.len() > 1); + let archives = parse_volumes(&volumes); + assert!(archives + .iter() + .all(|archive| archive.entries[0].header.flags & LHD_SOLID != 0)); + assert_eq!( + collect_extract_volumes(&archives, None).unwrap()[0].data, + entry.data + ); + } + + #[test] + fn final_archive_progress_report_can_cancel() { + struct CancelOnAdvance(AtomicBool); + impl WriteProgress for CancelOnAdvance { + fn report(&self, event: WriteProgressEvent<'_>) { + if matches!(event, WriteProgressEvent::Advanced { .. }) { + self.0.store(true, Ordering::Relaxed); + } + } + + fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) + } + } + let reporter = CancelOnAdvance(AtomicBool::new(false)); + let error = write_streaming_archive_to( + &[], + WriterOptions::default(), + MemberCoding::Stored, + None, + &WriterResources::default(), + Some(&reporter), + &mut Vec::new(), + ) + .unwrap_err(); + assert_eq!(error, Error::Cancelled); + } + + #[test] + fn final_volume_progress_report_can_cancel() { + struct CancelOnFinalAdvance { + entry_finished: AtomicBool, + cancelled: AtomicBool, + } + impl WriteProgress for CancelOnFinalAdvance { + fn report(&self, event: WriteProgressEvent<'_>) { + match event { + WriteProgressEvent::EntryFinished { .. } => { + self.entry_finished.store(true, Ordering::Relaxed); + } + WriteProgressEvent::Advanced { .. } + if self.entry_finished.load(Ordering::Relaxed) => + { + self.cancelled.store(true, Ordering::Relaxed); + } + _ => {} + } + } + + fn is_cancelled(&self) -> bool { + self.cancelled.load(Ordering::Relaxed) + } + } + let reporter = CancelOnFinalAdvance { + entry_finished: AtomicBool::new(false), + cancelled: AtomicBool::new(false), + }; + let entry = FileEntry { + name: b"FINAL.TXT", + data: b"final progress cancellation final progress cancellation", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let error = write_compressed_volumes_with_progress( + entry, + WriterOptions::default(), + 16, + Some(&reporter), + ) + .unwrap_err(); + assert_eq!(error, Error::Cancelled); + assert!(reporter.entry_finished.load(Ordering::Relaxed)); + } + + #[test] + fn preservation_reports_unsupported_legacy_header_variants() { + let entry = StoredEntry { + name: b"DIR", + data: b"", + file_time: 0, + file_attr: 0x10, + password: None, + file_comment: None, + }; + let bytes = write_stored_archive(&[entry], WriterOptions::default()).unwrap(); + let base = Archive::parse(&bytes).unwrap(); + assert!(base.rewrite_preservation_issues().is_empty()); + + for mutate in [ + (|archive: &mut Archive| archive.main.flags |= MHD_PACK_COMMENT) as fn(&mut Archive), + |archive| archive.main.extra.push(0), + |archive| archive.entries[0].header.method = METHOD_BEST + 1, + |archive| archive.entries[0].header.flags |= LHD_SOLID, + |archive| archive.entries[0].header.pack_size = 1, + |archive| archive.entries[0].header.unp_size = 1, + ] { + let mut archive = base.clone(); + mutate(&mut archive); + assert!(!archive.rewrite_preservation_issues().is_empty()); + } + } + + #[test] + fn volume_extraction_keeps_solid_history_across_regular_members() { + let entries = [ + FileEntry { + name: b"FIRST.TXT", + data: b"first member establishes solid history first member", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + FileEntry { + name: b"SECOND.TXT", + data: b"first member establishes solid history plus a tail", + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }, + ]; + let mut features = FeatureSet::store_only(); + features.solid = true; + let bytes = write_compressed_archive( + &entries, + WriterOptions::new(ArchiveVersion::Rar14, features), + ) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let extracted = collect_extract_volumes(std::slice::from_ref(&archive), None).unwrap(); + assert_eq!(extracted.len(), entries.len()); + for (actual, entry) in extracted.iter().zip(entries) { + assert_eq!(actual.data, entry.data); + } + } + + #[test] + fn streaming_writer_rejects_directory_payload() { + let entry = StreamingEntry::new( + b"directory".to_vec(), + EntrySource::from_bytes(b"unexpected payload".to_vec()), + ) + .with_file_attr(0x10); + let error = write_streaming_archive_to( + &[entry], + WriterOptions::default(), + MemberCoding::Stored, + None, + &WriterResources::default(), + None, + &mut Vec::new(), + ) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::InvalidArgument("RAR1.3/1.4 directories must have no payload") + )); + assert_eq!( + error.entry_context(), + Some((&b"directory"[..], "preparing")) + ); + } + + #[test] + fn compressed_volumes_report_each_volume_and_honor_cancellation() { + let data = b"a repeated sequence of archive bytes ".repeat(64); + let entry = FileEntry { + name: b"VOL.TXT", + data: &data, + file_time: 0, + file_attr: 0x20, + password: None, + file_comment: None, + }; + let volume_count = AtomicUsize::new(0); + let reporter = |event: WriteProgressEvent<'_>| { + if let WriteProgressEvent::VolumeFinished { volume_number, .. } = event { + assert_eq!( + volume_number, + volume_count.fetch_add(1, Ordering::Relaxed) + 1 + ); + } + }; + let volumes = write_compressed_volumes_with_progress( + entry, + WriterOptions::default(), + 32, + Some(&reporter), + ) + .unwrap(); + assert_eq!(volume_count.load(Ordering::Relaxed), volumes.len()); + assert!(volumes.len() > 1); + + struct CancelAfterFirstVolume(AtomicUsize); + impl WriteProgress for CancelAfterFirstVolume { + fn report(&self, event: WriteProgressEvent<'_>) { + if matches!(event, WriteProgressEvent::VolumeFinished { .. }) { + self.0.fetch_add(1, Ordering::Relaxed); + } + } + + fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) != 0 + } + } + let cancelling = CancelAfterFirstVolume(AtomicUsize::new(0)); + let error = write_compressed_volumes_with_progress( + entry, + WriterOptions::default(), + 32, + Some(&cancelling), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled); + assert_eq!(cancelling.0.load(Ordering::Relaxed), 1); + } +} diff --git a/arca-rar/vendor/rars/src/rar15_40.rs b/arca-rar/vendor/rars/src/rar15_40.rs new file mode 100644 index 00000000..5710bdd6 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar15_40.rs @@ -0,0 +1,5281 @@ +use crate::codec::rar13::Reader15State; +use crate::codec::rar20::Reader20State; +use crate::codec::workspace::{Allowance, Budget, Buffer}; +use crate::crc32::{crc32, Crc32}; +#[cfg(feature = "encryption")] +use crate::crypto::rar15::Rar15Cipher; +#[cfg(feature = "encryption")] +use crate::crypto::rar20::Rar20Cipher; +#[cfg(feature = "encryption")] +use crate::crypto::rar30::{Error as Rar30Error, Rar30Cipher}; +use crate::detect::{find_archive_start, ArchiveSignature, RAR15_SIGNATURE, SFX_SCAN_LIMIT}; +use crate::error::{Error, Result}; +use crate::io_util::{read_exact_at, read_u32}; +pub(crate) use crate::source::ArchiveSource; +use crate::version::ArchiveFamily; +#[cfg(any(feature = "write", feature = "recovery"))] +use crate::ArchiveVersion; +use std::fs::File; +use std::io::{Read, Write}; +use std::ops::Range; +use std::path::Path; +use std::sync::Arc; + +pub use crate::filter::{FilterKind, FilterPolicy, FilterSpec}; +#[cfg(feature = "write")] +pub use write::{FileEntry, Rar29Method, StoredEntry, StreamingEntry, WriterOptions}; + +mod extract; +#[cfg(feature = "write")] +mod write; +#[cfg(feature = "write")] +pub use crate::streaming::{EntrySource, WriterResources}; +#[cfg(feature = "write")] +pub use crate::write_plan::MemberCoding; +pub use extract::extract_volumes_to; +use extract::{DecoderSession, DecryptingReader, PackedReader}; +#[cfg(feature = "write")] +pub(crate) use write::write_stored_volumes_with_progress; +#[cfg(feature = "write")] +pub(crate) use write::{ + write_archive_with_retained_metadata, RetainedFileEntry, RetainedMemberMetadata, +}; +#[cfg(feature = "write")] +pub use write::{ + write_compressed_archive, write_compressed_archive_with_comment, + write_compressed_archive_with_comment_and_progress, write_compressed_volumes, + write_compressed_volumes_with_progress, write_rar29_compressed_archive_with_filter_policy, + write_rar29_compressed_archive_with_filter_policy_and_progress, write_stored_archive, + write_stored_archive_with_comment, write_stored_volumes, write_streaming_archive_to, +}; + +const MARK_HEAD: u8 = 0x72; +const MAIN_HEAD: u8 = 0x73; +const FILE_HEAD: u8 = 0x74; +const COMM_HEAD: u8 = 0x75; +const PROTECT_HEAD: u8 = 0x78; +const NEWSUB_HEAD: u8 = 0x7a; +const ENDARC_HEAD: u8 = 0x7b; + +const LONG_BLOCK: u16 = 0x8000; +const MHD_VOLUME: u16 = 0x0001; +const MHD_COMMENT: u16 = 0x0002; +const MHD_SOLID: u16 = 0x0008; +const MHD_NEWNUMBERING: u16 = 0x0010; +const MHD_PROTECT: u16 = 0x0040; +const MHD_PASSWORD: u16 = 0x0080; +const MHD_FIRSTVOLUME: u16 = 0x0100; +const MHD_ENCRYPTVER: u16 = 0x0200; + +const FHD_SPLIT_BEFORE: u16 = 0x0001; +const FHD_SPLIT_AFTER: u16 = 0x0002; +const FHD_PASSWORD: u16 = 0x0004; +const FHD_COMMENT: u16 = 0x0008; +const FHD_SOLID: u16 = 0x0010; +const FHD_LARGE: u16 = 0x0100; +const FHD_UNICODE: u16 = 0x0200; +const FHD_SALT: u16 = 0x0400; +const FHD_EXTTIME: u16 = 0x1000; +const FHD_DIRECTORY_MASK: u16 = 0x00e0; + +/// Bytes in a comment block before its data starts. +const COMMENT_HEADER_SIZE: usize = 13; +/// Bytes in a main header before a nested comment block starts. +const MAIN_HEADER_SIZE: usize = 13; + +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct Archive { + pub sfx_offset: usize, + pub main: MainHeader, + pub blocks: Vec, + source: ArchiveSource, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct MainHeader { + pub head_crc: u16, + pub flags: u16, + pub head_size: u16, + pub reserved1: u16, + pub reserved2: u32, + pub encrypt_version: Option, +} + +impl MainHeader { + pub fn has_archive_comment(&self) -> bool { + self.flags & MHD_COMMENT != 0 + } + + pub fn is_volume(&self) -> bool { + self.flags & MHD_VOLUME != 0 + } + + pub fn is_solid(&self) -> bool { + self.flags & MHD_SOLID != 0 + } + + pub fn uses_new_numbering(&self) -> bool { + self.flags & MHD_NEWNUMBERING != 0 + } + + pub fn has_recovery_record(&self) -> bool { + self.flags & MHD_PROTECT != 0 + } + + pub fn has_encrypted_headers(&self) -> bool { + self.flags & MHD_PASSWORD != 0 + } + + pub fn is_first_volume(&self) -> bool { + self.flags & MHD_FIRSTVOLUME != 0 + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Block { + File(FileHeader), + Comment(CommentHeader), + Protect(ProtectHeader), + NewSub(NewSubHeader), + End(BlockHeader), + Unknown(BlockHeader), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct BlockHeader { + pub head_crc: u16, + pub head_type: u8, + pub flags: u16, + pub head_size: u16, + pub add_size: Option, + pub offset: usize, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileHeader { + pub block: BlockHeader, + pub pack_size: u64, + pub unp_size: u64, + pub host_os: u8, + pub file_crc: u32, + pub file_time: u32, + pub unp_ver: u8, + pub method: u8, + pub name: Vec, + /// Original Unicode wire name, including its legacy fallback when present. + pub unicode_name: Option>, + pub attr: u32, + pub salt: Option<[u8; 8]>, + pub file_comment: Vec, + pub ext_time: Vec, + pub packed_range: Range, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct NewSubHeader { + pub file: FileHeader, + pub kind: NewSubKind, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct CommentHeader { + pub block: BlockHeader, + pub unp_size: u16, + pub unp_ver: u8, + pub method: u8, + pub comment_crc: u16, + pub packed_range: Range, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct ProtectHeader { + pub block: BlockHeader, + pub version: u8, + pub rec_sectors: u16, + pub total_blocks: u32, + pub mark: [u8; 8], + pub data_range: Range, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum NewSubKind { + ArchiveComment, + RecoveryRecord, + Unknown(Vec), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct ExtractedEntryMeta { + pub name_is_unicode: bool, + pub name: Vec, + pub file_time: u32, + /// Sub-second detail the DOS `file_time` cannot express, from the extended + /// time field. See [`FileHeader::mtime_refinement`]. + pub mtime_refinement: Option, + pub attr: u32, + pub host_os: u8, + pub is_directory: bool, +} + +impl FileHeader { + pub fn name_bytes(&self) -> &[u8] { + &self.name + } + + /// Returns the file name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + String::from_utf8_lossy(&self.name).into_owned() + } + + pub fn is_split_before(&self) -> bool { + self.block.flags & FHD_SPLIT_BEFORE != 0 + } + + pub fn is_split_after(&self) -> bool { + self.block.flags & FHD_SPLIT_AFTER != 0 + } + + pub fn is_encrypted(&self) -> bool { + self.block.flags & FHD_PASSWORD != 0 + } + + pub fn is_solid(&self) -> bool { + self.block.flags & FHD_SOLID != 0 + } + + pub fn is_directory(&self) -> bool { + self.block.flags & FHD_DIRECTORY_MASK == FHD_DIRECTORY_MASK + || (self.unp_ver < 20 && self.attr & 0x10 != 0) + } + + pub fn has_ext_time(&self) -> bool { + self.block.flags & FHD_EXTTIME != 0 + } + + pub fn has_file_comment(&self) -> bool { + self.block.flags & FHD_COMMENT != 0 && !self.file_comment.is_empty() + } + + /// Decodes the comment block RAR 1.5 to 2.9 stored inside the file header. + /// + /// The block is a comment header followed by its data, both covered by the + /// file header's size but not by its CRC. + pub fn file_comment(&self) -> Result>> { + if !self.has_file_comment() { + return Ok(None); + } + let block = parse_block_header(&self.file_comment, 0)?; + if block.head_type != COMM_HEAD { + return Err(Error::InvalidHeader( + "RAR 1.5 file comment is not a comment block", + )); + } + let head_size = block.head_size as usize; + let header = parse_comment_header(&self.file_comment, block)?; + // Block admission bounded head_size; comment admission requires >=13. + let packed = &self.file_comment[COMMENT_HEADER_SIZE..head_size]; + header.decode(packed).map(Some) + } + + pub fn is_stored(&self) -> bool { + self.method == 0x30 + } + + pub fn packed_data(&self, archive: &Archive) -> Result> { + archive.read_range(self.packed_range.clone()) + } + + pub fn write_packed_data(&self, archive: &Archive, out: &mut impl Write) -> Result<()> { + archive.copy_range_to(self.packed_range.clone(), out) + } + + fn packed_reader_with_allowance<'a, B: crate::codec::workspace::Budget>( + &self, + archive: &'a Archive, + password: Option<&[u8]>, + allowance: &B, + ) -> Result, B>> { + let reader = archive.range_reader(self.packed_range.clone())?; + if !self.is_encrypted() { + return Ok(PackedReader::Plain(reader)); + } + crate::crypto::require_encryption()?; + let Some(password) = password else { + return Err(Error::NeedPassword); + }; + if (self.unp_ver == 20 || self.unp_ver == 26 || self.unp_ver >= 29) + && !self.packed_range.len().is_multiple_of(16) + { + return Err(Error::InvalidHeader( + "RAR encrypted payload is not block aligned", + )); + } + Ok(PackedReader::Encrypted( + crate::codec::workspace::Boxed::try_new( + || { + DecryptingReader::with_allowance( + reader, + self.unp_ver, + password, + self.salt, + allowance, + ) + }, + allowance, + )?, + )) + } + + pub fn verify_crc32(&self, data: &[u8]) -> Result<()> { + let actual = crc32(data); + if actual == self.file_crc { + Ok(()) + } else { + Err(Error::Crc32Mismatch { + expected: self.file_crc, + actual, + }) + } + } + + /// Decodes the modification time's extended-time detail, if the header + /// carries any. + /// + /// A DOS timestamp counts in two-second steps and holds nothing smaller, + /// so the extended field adds an odd-second flag and up to three bytes of + /// 100-nanosecond ticks. Ignoring it costs up to a second of accuracy on + /// every RAR 1.5-4.x archive that has one. + /// + /// The flags word splits into four nibbles, mtime first at bits 15-12, + /// then ctime, atime and arctime. Within a nibble, `0x8` marks the + /// timestamp present, `0x4` adds one second, and the low two bits count + /// the sub-second bytes. Only mtime is decoded here, and it is the first + /// entry, so nothing after it has to be walked. mtime alone reuses the + /// header's DOS time rather than carrying its own copy. + /// + /// Sub-second bytes arrive high end first: each shifts into the top of a + /// 24-bit accumulator while what is there shifts down. Fewer bytes mean a + /// coarser tick, not a smaller number, so one byte resolves to 6.55 ms and + /// three to the full 100 ns. + pub fn mtime_refinement(&self) -> Option { + const PRESENT: u8 = 0x8; + const ADD_SECOND: u8 = 0x4; + const TICK_NANOSECONDS: u32 = 100; + + let flag_bytes = self.ext_time.get(..2)?; + let flags = u16::from_le_bytes([flag_bytes[0], flag_bytes[1]]); + let rmode = ((flags >> 12) & 0xf) as u8; + if rmode & PRESENT == 0 { + return None; + } + let mut ticks = 0u32; + for &byte in self.ext_time.get(2..2 + usize::from(rmode & 0x3))? { + ticks = (u32::from(byte) << 16) | (ticks >> 8); + } + Some(crate::TimeRefinement { + add_second: rmode & ADD_SECOND != 0, + nanoseconds: ticks * TICK_NANOSECONDS, + }) + } + + pub fn metadata(&self) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name_is_unicode: self.unicode_name.is_some(), + name: self.name.clone(), + file_time: self.file_time, + mtime_refinement: self.mtime_refinement(), + attr: self.attr, + host_os: self.host_os, + is_directory: self.is_directory(), + } + } + + pub fn write_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + if self.is_directory() { + return Ok(()); + } + if self.is_stored() { + return self.write_stored_to(archive, password, out); + } + let mut session = DecoderSession::new_with_password(false, password); + session.write_file_to(archive, self, out) + } + + fn write_stored_with_allowance( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + allowance: &B, + ) -> Result<()> { + if !self.is_encrypted() && self.pack_size != self.unp_size { + return Err(Error::InvalidHeader( + "RAR 1.5 stored file has mismatched packed and unpacked sizes", + )); + } + let mut reader = self + .packed_reader_with_allowance(archive, password, allowance) + .map_err(|error| self.map_encrypted_payload_error(password, error))?; + let expected_len = usize::try_from(self.unp_size) + .map_err(|_| Error::InvalidHeader("RAR 1.5 unpacked size overflows usize"))?; + let mut crc = Crc32::new(); + let mut crc_writer = CrcWriter { + inner: out, + crc: &mut crc, + }; + let copied = std::io::copy( + &mut reader.by_ref().take(expected_len as u64), + &mut crc_writer, + )?; + if copied != expected_len as u64 { + return Err(self.map_encrypted_payload_error( + password, + Error::InvalidHeader("RAR 1.5 stored file ended before unpacked size"), + )); + } + let actual = crc.finish(); + if actual == self.file_crc { + Ok(()) + } else { + Err(self.map_encrypted_payload_error( + password, + Error::Crc32Mismatch { + expected: self.file_crc, + actual, + }, + )) + } + } + + fn write_stored_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + self.write_stored_with_allowance( + archive, + password, + out, + &crate::codec::workspace::Allowance::default(), + ) + } + + fn map_encrypted_payload_error(&self, password: Option<&[u8]>, error: Error) -> Error { + if !self.is_encrypted() || password.is_none() { + return error; + } + if matches!( + error.kind(), + crate::ErrorKind::ResourceLimit | crate::ErrorKind::Cancelled | crate::ErrorKind::Io + ) { + return error; + } + match error { + Error::FeatureDisabled { .. } + | Error::NeedPassword + | Error::UnsupportedSignature + | Error::UnsupportedVersion(_) + | Error::UnsupportedFeature { .. } + | Error::UnsupportedWriterOption { .. } + | Error::CannotSkipSolidMember + | Error::MemberOutputLimitExceeded { .. } + | Error::HeaderCountLimitExceeded { .. } + | Error::HeaderBytesLimitExceeded { .. } + | Error::TotalOutputLimitExceeded { .. } + | Error::Rar50DictionaryLimitExceeded { .. } + | Error::Rar50BufferedDecodeLimitExceeded { .. } + | Error::MemoryLimitExceeded { .. } + | Error::WriterSpoolLimitExceeded { .. } + | Error::WriterSpoolMemoryLimitExceeded { .. } + | Error::WriterPreparedHeaderLimitExceeded { .. } + | Error::WriterPreparationLimitExceeded { .. } + | Error::Rar50ScratchLimitExceeded { .. } + | Error::RewriteStagingLimitExceeded { .. } + | Error::Rar50FilterMemoryLimitExceeded { .. } + | Error::UnsupportedFamilyFeature { .. } + | Error::UnsupportedCompression { .. } + | Error::UnsupportedEncryption { .. } + | Error::TooShort + | Error::Io(_) + | Error::AtArchiveOffset { .. } + | Error::AtEntry { .. } + | Error::InVolume { .. } + | Error::Cancelled + | Error::InvalidArgument(_) + | Error::WriterFailure(_) + | Error::EntryNotFound + | Error::DuplicateEntry + | Error::InputSymlink + | Error::UnsafePath(_) + | Error::SourceChanged(_) => error, + Error::InvalidHeader(_) + | Error::Codec(_) + | Error::Rar3Recovery(_) + | Error::Rar5Recovery(_) + | Error::Rar20Crypto(_) + | Error::Rar30Crypto(_) + | Error::Rar50Crypto(_) + | Error::CrcMismatch { .. } + | Error::Crc32Mismatch { .. } + | Error::HashMismatch { .. } + | Error::WrongPasswordOrCorruptData => Error::WrongPasswordOrCorruptData, + } + } + + fn entry_error(&self, operation: &'static str, error: Error) -> Error { + if matches!( + error, + Error::NeedPassword | Error::WrongPasswordOrCorruptData + ) { + return error; + } + error.at_entry(self.name.clone(), operation) + } + + fn crc_result(&self, actual: u32, password: Option<&[u8]>) -> Result<()> { + if actual == self.file_crc { + Ok(()) + } else { + Err(self.map_encrypted_payload_error( + password, + Error::Crc32Mismatch { + expected: self.file_crc, + actual, + }, + )) + } + } +} + +impl NewSubHeader { + pub fn name_bytes(&self) -> &[u8] { + self.file.name_bytes() + } + + /// Returns the service-block name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + self.file.name_lossy() + } +} + +impl CommentHeader { + #[cfg(feature = "write")] + fn supports_rewrite(&self) -> bool { + self.block.head_type == COMM_HEAD + && self.block.flags == 0 + && self.block.add_size.is_none() + && self.block.head_size >= COMMENT_HEADER_SIZE as u16 + && usize::from(self.unp_size) <= usize::from(u16::MAX) - COMMENT_HEADER_SIZE + && (self.method == 0x30 + || ((0x31..=0x35).contains(&self.method) && matches!(self.unp_ver, 15 | 20 | 26))) + } + + /// Unpacks comment data and checks it against the header's 16-bit CRC. + fn decode(&self, packed: &[u8]) -> Result> { + self.decode_with_budget( + packed, + &mut crate::output_limit::OutputBudget::new(crate::ArchiveReadOptions::new()), + ) + } + + fn decode_with_budget( + &self, + packed: &[u8], + budget: &mut crate::output_limit::OutputBudget, + ) -> Result> { + self.decode_with_allowance(packed, budget, &Allowance::default()) + } + + fn decode_with_allowance( + &self, + packed: &[u8], + budget: &mut crate::output_limit::OutputBudget, + allowance: &B, + ) -> Result> { + let target = usize::from(self.unp_size); + budget.check(target as u64, b"CMT")?; + let control = budget.control.clone(); + let mut data = Vec::new(); + budget.run(b"CMT", &mut data, |writer| { + if self.method == 0x30 { + if packed.len() != target { + return Err(Error::InvalidHeader( + "RAR 1.5 stored comment has mismatched packed and unpacked sizes", + )); + } + writer.write_all(packed)?; + } else if self.unp_ver == 15 { + let mut decoder = crate::codec::workspace::Boxed::try_new( + || Reader15State::with_allowance(allowance), + allowance, + )?; + decoder.read_control = control; + decoder.decode_member_to(packed, target, false, writer)?; + } else if self.unp_ver == 20 || self.unp_ver == 26 { + let mut decoder = crate::codec::workspace::Boxed::try_new( + || Ok::<_, crate::codec::Error>(Reader20State::with_allowance(allowance)), + allowance, + )?; + decoder.read_control = control; + decoder.decode_member_from_reader(&mut &packed[..], target, writer)?; + } else { + return Err(Error::UnsupportedCompression { + family: "RAR 1.5 comment", + unpack_version: self.unp_ver, + method: self.method, + }); + } + Ok(()) + })?; + let actual = (crc32(&data) & 0xffff) as u16; + if actual == self.comment_crc { + budget.control.check()?; + Ok(data) + } else { + Err(Error::CrcMismatch { + expected: self.comment_crc, + actual, + }) + } + } +} + +impl Archive { + pub fn parse(input: &[u8]) -> Result { + Self::parse_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_owned(input: Vec) -> Result { + Self::parse_owned_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_with_options( + input: &[u8], + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let data: Arc<[u8]> = Arc::from(input.to_vec().into_boxed_slice()); + Self::parse_shared(data, options) + } + + pub fn parse_owned_with_options( + input: Vec, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + Self::parse_shared(Arc::from(input.into_boxed_slice()), options) + } + + pub fn parse_with_password(input: &[u8], password: Option<&[u8]>) -> Result { + Self::parse_with_options( + input, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_owned_with_password(input: Vec, password: Option<&[u8]>) -> Result { + Self::parse_owned_with_options( + input, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path(path: impl AsRef) -> Result { + Self::parse_path_with_options(path, crate::ArchiveReadOptions::default()) + } + + pub fn parse_path_with_password( + path: impl AsRef, + password: Option<&[u8]>, + ) -> Result { + Self::parse_path_with_options( + path, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path_with_options( + path: impl AsRef, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let path = Arc::new(path.as_ref().to_path_buf()); + let mut file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + let scan_len = len.min(SFX_SCAN_LIMIT as u64) as usize; + let mut scan = vec![0; scan_len]; + file.read_exact(&mut scan)?; + options.check_cancelled()?; + let sig = find_archive_start(&scan, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar15To40 { + return Err(Error::UnsupportedSignature); + } + Self::parse_seekable(file, len, sig.offset, ArchiveSource::File(path), options) + } + + pub fn parse_path_with_signature_and_password( + path: impl AsRef, + signature: ArchiveSignature, + password: Option<&[u8]>, + ) -> Result { + Self::parse_path_with_signature( + path, + signature, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path_with_signature( + path: impl AsRef, + signature: ArchiveSignature, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + if signature.family != ArchiveFamily::Rar15To40 { + return Err(Error::UnsupportedSignature); + } + let path = Arc::new(path.as_ref().to_path_buf()); + let file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + Self::parse_seekable( + file, + len, + signature.offset, + ArchiveSource::File(path), + options, + ) + } + + fn parse_shared(input: Arc<[u8]>, options: crate::ArchiveReadOptions<'_>) -> Result { + options.check_cancelled()?; + let sig = find_archive_start(&input, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar15To40 { + return Err(Error::UnsupportedSignature); + } + + let password = options.password; + let mut budget = crate::parse_budget::ParseBudget::new(options); + let archive = &input[sig.offset..]; + // find_archive_start matched these exact marker bytes, including the + // fixed MARK_HEAD type and seven-byte header length. + let marker_size = RAR15_SIGNATURE.len(); + admit_plain_header(archive, marker_size, &mut budget)?; + let main_block = parse_block_header(archive, marker_size)?; + if main_block.head_type != MAIN_HEAD { + return Err(Error::InvalidHeader("RAR 1.5 main header is missing")); + } + let main = parse_main_header(archive, &main_block)?; + let mut pos = main_block.offset + main_block.head_size as usize; + let mut blocks = Vec::new(); + if let Some(comment) = nested_main_comment( + &archive[main_block.offset..pos], + &main_block, + sig.offset + main_block.offset, + )? { + blocks.push(Block::Comment(comment)); + } + let mut encrypted_header_ciphers = EncryptedHeaderCipherCache::default(); + + while pos < archive.len() { + if archive.len() - pos < 7 { + break; + } + let (block, header, total) = if main.has_encrypted_headers() { + crate::crypto::require_encryption()?; + let password = password.ok_or(Error::NeedPassword)?; + let encrypted = decrypt_encrypted_header_at( + archive, + pos, + password, + &mut encrypted_header_ciphers, + &mut budget, + )?; + (encrypted.block, encrypted.header, encrypted.total_size) + } else { + admit_plain_header(archive, pos, &mut budget)?; + let block = parse_block_header(archive, pos)?; + let total = block_total_size(&block)?; + let header = archive[pos..pos + block.head_size as usize].to_vec(); + (block, header, total) + }; + match block.head_type { + FILE_HEAD => { + let mut file = parse_file_like_header(&header, relative_block(&block), 0)?; + let total = file_block_total_size(&block, total, file.pack_size)?; + let next = checked_block_next(&block, total, archive.len())?; + file.block.offset = block.offset; + file.packed_range = packed_range(sig.offset, next, file.pack_size); + blocks.push(Block::File(file)); + pos = next; + } + NEWSUB_HEAD => { + let mut file = parse_file_like_header(&header, relative_block(&block), 0)?; + let total = file_block_total_size(&block, total, file.pack_size)?; + let next = checked_block_next(&block, total, archive.len())?; + file.block.offset = block.offset; + file.packed_range = packed_range(sig.offset, next, file.pack_size); + let kind = classify_new_sub(&file.name); + blocks.push(Block::NewSub(NewSubHeader { file, kind })); + pos = next; + } + COMM_HEAD => { + let next = checked_block_next(&block, total, archive.len())?; + let mut comment = parse_comment_header(&header, relative_block(&block))?; + comment.block.offset = block.offset; + comment.packed_range = + sig.offset + block.offset + 13..sig.offset + block.offset + total; + blocks.push(Block::Comment(comment)); + pos = next; + } + PROTECT_HEAD => { + let next = checked_block_next(&block, total, archive.len())?; + let protect = parse_protect_header(&header, &block, sig.offset, total)?; + blocks.push(Block::Protect(protect)); + pos = next; + } + ENDARC_HEAD => { + let _next = checked_block_next(&block, total, archive.len())?; + blocks.push(Block::End(block)); + break; + } + _ => { + let next = checked_block_next(&block, total, archive.len())?; + blocks.push(Block::Unknown(block)); + pos = next; + } + } + } + + options.check_cancelled()?; + Ok(Self { + sfx_offset: sig.offset, + main, + blocks, + source: ArchiveSource::Memory(input), + }) + } + + pub(crate) fn parse_seekable( + file: impl Read + std::io::Seek, + file_len: u64, + sfx_offset: usize, + source: ArchiveSource, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let password = options.password; + let mut budget = crate::parse_budget::ParseBudget::new(options); + let mut file = budget.control.reader(file); + let marker = read_block_header_at(&mut file, file_len, sfx_offset, 0, &mut budget)?; + if marker.head_type != MARK_HEAD || marker.head_size != RAR15_SIGNATURE.len() as u16 { + return Err(Error::InvalidHeader("RAR 1.5 marker block is invalid")); + } + + let main_block = read_block_header_at( + &mut file, + file_len, + sfx_offset, + marker.head_size as usize, + &mut budget, + )?; + if main_block.head_type != MAIN_HEAD { + return Err(Error::InvalidHeader("RAR 1.5 main header is missing")); + } + // File lengths are u64, so even a complete header can cross usize on 32-bit hosts. + let mut pos = checked_file_block_next( + sfx_offset, + &main_block, + usize::from(main_block.head_size), + file_len, + )?; + let main_header = read_exact_at( + &mut file, + sfx_offset + main_block.offset, + main_block.head_size as usize, + )?; + let main = parse_main_header(&main_header, &relative_block(&main_block))?; + let mut blocks = Vec::new(); + if let Some(comment) = + nested_main_comment(&main_header, &main_block, sfx_offset + main_block.offset)? + { + blocks.push(Block::Comment(comment)); + } + let mut encrypted_header_ciphers = EncryptedHeaderCipherCache::default(); + + while file_len.saturating_sub((sfx_offset + pos) as u64) >= 7 { + let (block, header, total) = if main.has_encrypted_headers() { + crate::crypto::require_encryption()?; + let password = password.ok_or(Error::NeedPassword)?; + let encrypted = read_encrypted_header_at( + &mut file, + file_len, + sfx_offset, + pos, + password, + &mut encrypted_header_ciphers, + &mut budget, + )?; + (encrypted.block, encrypted.header, encrypted.total_size) + } else { + let block = + read_block_header_at(&mut file, file_len, sfx_offset, pos, &mut budget)?; + let total = block_total_size(&block)?; + let header = read_exact_at(&mut file, sfx_offset + pos, block.head_size as usize)?; + (block, header, total) + }; + match block.head_type { + FILE_HEAD => { + let mut file_header = + parse_file_like_header(&header, relative_block(&block), 0)?; + let total = file_block_total_size(&block, total, file_header.pack_size)?; + let next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + file_header.block.offset = block.offset; + file_header.packed_range = + packed_range(sfx_offset, next, file_header.pack_size); + blocks.push(Block::File(file_header)); + pos = next; + } + NEWSUB_HEAD => { + let mut file_header = + parse_file_like_header(&header, relative_block(&block), 0)?; + let total = file_block_total_size(&block, total, file_header.pack_size)?; + let next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + file_header.block.offset = block.offset; + file_header.packed_range = + packed_range(sfx_offset, next, file_header.pack_size); + let kind = classify_new_sub(&file_header.name); + blocks.push(Block::NewSub(NewSubHeader { + file: file_header, + kind, + })); + pos = next; + } + COMM_HEAD => { + let next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + let mut comment = parse_comment_header(&header, relative_block(&block))?; + comment.block.offset = block.offset; + comment.packed_range = + sfx_offset + block.offset + 13..sfx_offset + block.offset + total; + blocks.push(Block::Comment(comment)); + pos = next; + } + PROTECT_HEAD => { + let next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + let protect = parse_protect_header(&header, &block, sfx_offset, total)?; + blocks.push(Block::Protect(protect)); + pos = next; + } + ENDARC_HEAD => { + let _next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + blocks.push(Block::End(block)); + break; + } + _ => { + let next = checked_file_block_next(sfx_offset, &block, total, file_len)?; + blocks.push(Block::Unknown(block)); + pos = next; + } + } + } + + options.check_cancelled()?; + Ok(Self { + sfx_offset, + main, + blocks, + source, + }) + } + + /// The highest format requirement present in this container, not its creator release. + #[cfg(feature = "write")] + pub(crate) fn preservation_version(&self) -> ArchiveVersion { + if self.main.has_encrypted_headers() + || self + .new_subs() + .any(|sub| sub.kind == NewSubKind::ArchiveComment) + { + ArchiveVersion::Rar30 + } else { + match self.files().map(|file| file.unp_ver).max().unwrap_or(15) { + 29.. => ArchiveVersion::Rar29, + 20..=28 => ArchiveVersion::Rar20, + _ => ArchiveVersion::Rar15, + } + } + } + + /// Native metadata checks for the supported RAR 1.5–4.x rewrite subsets. + #[cfg(feature = "write")] + pub(crate) fn rewrite_preservation_issues(&self) -> Vec { + let mut issues = Vec::new(); + if self.main.is_volume() { + issues.push("legacy volume layout".into()); + } + if self.main.has_recovery_record() { + issues.push("legacy recovery records".into()); + } + let nested_comment_size = match self.blocks.first() { + Some(Block::Comment(comment)) + if self.main.has_archive_comment() + && self.main.head_size > MAIN_HEADER_SIZE as u16 + && comment.block.offset == RAR15_SIGNATURE.len() + MAIN_HEADER_SIZE => + { + usize::from(comment.block.head_size) + } + _ => 0, + }; + if self.main.flags & !(MHD_SOLID | MHD_PASSWORD | MHD_COMMENT) != 0 + || usize::from(self.main.head_size) != MAIN_HEADER_SIZE + nested_comment_size + || self.main.reserved1 != 0 + || self.main.reserved2 != 0 + { + issues.push("legacy main header settings, comments or extra metadata".into()); + } + if self.files().next().is_none() { + issues.push("empty legacy archive (source format cannot be inferred)".into()); + } + let version = self.preservation_version(); + let supports_extended_times = matches!( + version, + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + ); + for (index, file) in self.files().enumerate() { + let label = format!("legacy member {index} ({:?})", file.name_lossy()); + if !matches!(file.unp_ver, 15 | 20 | 26 | 29) { + issues.push(format!("{label}: legacy source format requires unpacker {} (only 15, 20, 26 and 29 are supported for preservation)", file.unp_ver)); + } + if (file.unp_ver < 29 && file.salt.is_some()) + || (file.unp_ver >= 29 && file.is_encrypted() != file.salt.is_some()) + { + issues.push(format!( + "{label}: unsupported legacy encryption salt settings" + )); + } + if !supports_extended_times && file.has_ext_time() { + issues.push(format!( + "{label}: Pre-RAR2.9 extended timestamps are unsupported" + )); + } + if file.has_ext_time() + && crate::file_times::validate_legacy_extended_times(&file.ext_time).is_err() + { + issues.push(format!( + "{label}: legacy extended timestamps are incomplete or invalid" + )); + } + if version == ArchiveVersion::Rar15 && file.host_os == 3 { + issues.push(format!( + "{label}: RAR1.5 Unix metadata cannot be represented by the compatible writer" + )); + } + if file.block.flags & FHD_COMMENT != 0 { + if self.main.has_encrypted_headers() { + issues.push(format!("{label}: embedded legacy file comments with encrypted headers are incompatible with reference readers")); + } + let supported = parse_block_header(&file.file_comment, 0) + .and_then(|block| parse_comment_header(&file.file_comment, block)) + .is_ok_and(|comment| { + comment.supports_rewrite() + && usize::from(comment.block.head_size) == file.file_comment.len() + }); + if !supported { + issues.push(format!( + "{label}: legacy file comments have unsupported or incomplete metadata" + )); + } + } + if file.is_directory() && (file.pack_size != 0 || file.unp_size != 0 || file.is_solid()) + { + issues.push(format!( + "{label}: unsupported legacy directory payload or compression" + )); + } + if let Some(raw) = &file.unicode_name { + if version == ArchiveVersion::Rar15 + || validate_unicode_name(raw, &file.name).is_err() + { + issues.push(format!( + "{label}: malformed or unsupported legacy Unicode name" + )); + } + } + if !matches!(file.host_os, 0..=3) { + issues.push(format!("{label}: legacy host metadata")); + } + if file.is_solid() && !self.main.is_solid() { + issues.push(format!( + "{label}: solid dependency without archive solid flag" + )); + } + // Only native times, salt and embedded comments are retained. Check + // the declared length too: the reader tolerates unflagged extras. + if file.block.flags + & !(LONG_BLOCK + | FHD_SOLID + | FHD_DIRECTORY_MASK + | FHD_EXTTIME + | FHD_PASSWORD + | FHD_SALT + | FHD_COMMENT + | FHD_UNICODE) + != 0 + || usize::from(file.block.head_size) + != 32 + + file.unicode_name.as_ref().map_or(file.name.len(), Vec::len) + + file.ext_time.len() + + file.file_comment.len() + + if file.salt.is_some() { 8 } else { 0 } + { + issues.push(format!("{label}: legacy file flags or extra metadata")); + } + if !(0x30..=0x35).contains(&file.method) || file.unp_size > u64::from(u32::MAX) { + issues.push(format!("{label}: unsupported legacy method or size")); + } + } + let mut archive_comments = 0; + let mut seen_file = false; + for block in &self.blocks { + match block { + Block::File(_) => seen_file = true, + Block::End(_) => {} + Block::Comment(comment) => { + archive_comments += 1; + if seen_file || !comment.supports_rewrite() { + issues.push( + "legacy archive comment location or metadata is unsupported".into(), + ); + } + } + Block::NewSub(sub) if sub.kind == NewSubKind::ArchiveComment => { + archive_comments += 1; + let file = &sub.file; + if seen_file + || file.is_directory() + || file.is_encrypted() != file.salt.is_some() + || file.block.flags + & !(LONG_BLOCK | FHD_DIRECTORY_MASK | 0x4000 | FHD_PASSWORD | FHD_SALT) + != 0 + || file.block.head_size != 35 + if file.salt.is_some() { 8 } else { 0 } + || file.unp_ver != 29 + || !(0x30..=0x35).contains(&file.method) + || file.attr != 0 + || !matches!(file.host_os, 0..=3) + || file.unp_size > u64::from(u32::MAX) + { + issues.push( + "legacy CMT service metadata or encryption is unsupported".into(), + ); + } + } + _ => issues.push("legacy recovery or other service records".into()), + } + } + if archive_comments > 1 { + issues.push("duplicate legacy archive comments".into()); + } + if self.main.has_archive_comment() && archive_comments == 0 { + issues.push("missing or malformed legacy archive comment".into()); + } + let complete_end = match self.blocks.last() { + Some(Block::End(end)) => { + end.flags & !0x4000 == 0 + && end.head_size == 7 + && end.add_size.is_none() + && end + .offset + .checked_add(if self.main.has_encrypted_headers() { + // Eight-byte salt plus one AES block for this header. + 24 + } else { + 7 + }) + .and_then(|end| end.checked_add(self.sfx_offset)) + .is_some_and(|end| Some(end) == self.source.len().ok()) + } + // Legacy archives may terminate immediately after the last file. + Some(Block::File(file)) => Some(file.packed_range.end) == self.source.len().ok(), + _ => false, + }; + if !complete_end { + issues.push("legacy end header metadata or trailing bytes".into()); + } + issues + } + + fn read_range(&self, range: Range) -> Result> { + self.source.read_range(range) + } + + fn copy_range_to(&self, range: Range, out: &mut impl Write) -> Result<()> { + self.source.copy_range_to(range, out) + } + + fn range_reader(&self, range: Range) -> Result> { + self.source.range_reader(range) + } + + pub fn files(&self) -> impl Iterator { + self.blocks.iter().filter_map(|block| match block { + Block::File(file) => Some(file), + _ => None, + }) + } + + pub fn new_subs(&self) -> impl Iterator { + self.blocks.iter().filter_map(|block| match block { + Block::NewSub(sub) => Some(sub), + _ => None, + }) + } + + pub fn protect_records(&self) -> impl Iterator { + self.blocks.iter().filter_map(|block| match block { + Block::Protect(protect) => Some(protect), + _ => None, + }) + } + + #[cfg(feature = "recovery")] + fn source_bytes(&self) -> Result> { + self.source.bytes() + } + + pub fn repair_protect_head(&self) -> Result> { + Ok(self.repair_protect_head_with_report()?.data) + } + + /// Repaired archive bytes plus whether any protected sector was rebuilt. + pub fn repair_protect_head_with_report(&self) -> Result { + self.repair_protect_head_with_options(crate::ArchiveReadOptions::new()) + } + + /// Repairs protected sectors with cooperative cancellation; other read limits do not apply. + pub fn repair_protect_head_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + #[cfg(not(feature = "recovery"))] + { + let _ = (self, options); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + options.check_cancelled()?; + let control = crate::read_control::ReadControl::new(options.cancellation); + let (data, data_repaired) = if let Some(recovery) = self + .new_subs() + .find(|sub| sub.kind == NewSubKind::RecoveryRecord) + { + repair_newsub_recovery_bytes( + &self.source_bytes()?, + self.sfx_offset, + self, + recovery, + &control, + )? + } else { + let protect = self.protect_records().next().ok_or(Error::InvalidHeader( + "RAR 2.x archive does not contain a PROTECT_HEAD recovery record", + ))?; + repair_protect_head_bytes( + &self.source_bytes()?, + self.sfx_offset, + protect, + &control, + )? + }; + control.check()?; + Ok(crate::RecoveryRepairResult { + data, + report: crate::RecoveryRepairReport { + changed: data_repaired, + data_repaired, + ..Default::default() + }, + }) + } + } + + /// Streams extracted entries to caller-provided writers. + pub fn extract_to(&self, options: crate::ArchiveReadOptions<'_>, mut open: F) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.extract_impl(options, &mut open, None, None) + .map(|_| ()) + } + + pub(crate) fn extract_controlled( + &self, + options: crate::ArchiveReadOptions<'_>, + selector: &mut crate::extraction_control::Selector<'_>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result { + self.extract_impl( + options, + &mut |_| unreachable!("controlled selection supplies writer"), + Some(selector), + on_error, + ) + } + + fn extract_impl( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + selector: Option<&mut crate::extraction_control::Selector<'_>>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.extract_with_allowance( + options, + open, + selector, + on_error, + &crate::codec::workspace::Allowance::limited(limit), + ); + } + self.extract_with_allowance( + options, + open, + selector, + on_error, + &crate::codec::workspace::Allowance::default(), + ) + } + + fn extract_with_allowance( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + mut selector: Option<&mut crate::extraction_control::Selector<'_>>, + mut on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + allowance: &B, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + let mut session = DecoderSession::with_allowance(self.main.is_solid(), password, allowance); + session.read_control = budget.control.clone(); + let solid = selector.is_some() + && (self.main.is_solid() || self.files().any(|file| file.is_solid())); + for file in self.files() { + let selected = crate::extraction_control::select( + &mut selector, + options, + || crate::rar15_40_member(file), + solid, + )?; + let mut selected_writer = match selected { + Some(crate::ExtractionDecision::Skip) => continue, + Some(crate::ExtractionDecision::Stop) => { + return Ok(crate::ExtractionOutcome::Stopped) + } + Some(crate::ExtractionDecision::Extract(writer)) => Some(writer), + None => None, + }; + let result = (|| { + options.check_cancelled()?; + if file.is_split_before() || file.is_split_after() { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry requires multivolume extraction", + )); + } + let meta = file.metadata(); + if meta.is_directory { + options.check_cancelled()?; + let _ = match selected_writer.take() { + Some(writer) => writer, + None => open(&meta)?, + }; + options.check_cancelled()?; + return Ok(()); + } + budget.check(file.unp_size, &file.name)?; + options.check_cancelled()?; + let mut writer = match selected_writer.take() { + Some(writer) => writer, + None => open(&meta)?, + }; + options.check_cancelled()?; + budget.run(&file.name, &mut writer, |mut writer| { + if file.is_stored() { + file.write_stored_with_allowance(self, password, &mut writer, allowance) + .map_err(|error| file.entry_error("extracting", error))?; + } else { + session + .write_file_to(self, file, &mut writer) + .map_err(|error| file.entry_error("extracting", error))?; + } + Ok(()) + })?; + Ok(()) + })(); + if crate::extraction_control::finish_member( + &mut on_error, + options, + || crate::rar15_40_member(file), + solid, + result, + )? { + session = DecoderSession::with_allowance(false, password, allowance); + session.read_control = budget.control.clone(); + } + } + options.check_cancelled()?; + Ok(crate::ExtractionOutcome::Complete) + } + + /// Decodes independent members in batches of at most the worker count, + /// emitting each batch in archive order before decoding the next. + /// Completed batches can have been emitted when a later batch fails. + /// This bounds retained result count, not payload bytes or decoder memory. + /// A configured total output ceiling selects sequential extraction. + pub fn extract_to_parallel_buffered( + &self, + options: crate::ArchiveReadOptions<'_>, + mut open: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + // Total accounting belongs to the operation, before any worker dispatch. + if options.max_total_output_bytes.is_some() + || self.main.is_solid() + || self + .files() + .any(|file| file.is_solid() || file.is_split_before() || file.is_split_after()) + { + return self.extract_to(options, open); + } + + if let Some(limit) = options.max_reader_workspace_bytes { + let ledger = Allowance::limited(limit); + let publication = crate::read_control::ReadControl::new(options.cancellation); + return crate::codec::workspace::coordinator::extract_windowed( + self.files(), + &ledger, + |file| { + if file.is_directory() { + 0 + } else if file.is_stored() { + file.unp_size + } else { + file.unp_size + .saturating_add(file.pack_size) + .saturating_add(if file.unp_ver == 15 { 65536 } else { 0 }) + .saturating_add(8192) + } + }, + |file, local| { + options.check_cancelled()?; + decode_parallel_entry_with_allowance(self, file, options, local) + }, + |entry| write_parallel_entry(entry, &mut open, &publication), + ); + } + + let mut files = self.files().peekable(); + let window = crate::parallel::default_window().max(1); + let publication = crate::read_control::ReadControl::new(options.cancellation); + while files.peek().is_some() { + options.check_cancelled()?; + let batch = files.by_ref().take(window).collect(); + // Write the verified members ahead of a failure before reporting it. + let (entries, failure) = crate::parallel::map_prefix(batch, |file| { + decode_parallel_entry(self, file, options) + }); + for entry in entries { + write_parallel_entry(entry, &mut open, &publication)?; + } + if let Some(error) = failure { + return Err(error); + } + } + options.check_cancelled()?; + Ok(()) + } + + pub fn archive_comment(&self) -> Result>> { + self.archive_comment_with_password(None) + } + + pub fn archive_comment_with_password( + &self, + password: Option<&[u8]>, + ) -> Result>> { + self.archive_comment_with_options(crate::ArchiveReadOptions::with_optional_password( + password, + )) + } + + /// Decodes the archive comment under the same policy as [`crate::Archive::comment_with_options`]. + pub fn archive_comment_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + ) -> Result>> { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.archive_comment_with_allowance(options, &Allowance::limited(limit)); + } + self.archive_comment_with_allowance(options, &Allowance::default()) + } + + fn archive_comment_with_allowance( + &self, + options: crate::ArchiveReadOptions<'_>, + allowance: &B, + ) -> Result>> { + options.check_cancelled()?; + let mut budget = crate::output_limit::OutputBudget::new(options); + if let Some(comment) = self.blocks.iter().find_map(|block| match block { + Block::Comment(comment) => Some(comment), + _ => None, + }) { + budget.check(u64::from(comment.unp_size), b"CMT")?; + let mut packed = Buffer::new(allowance); + let mut reader = budget + .control + .reader(self.range_reader(comment.packed_range.clone())?); + packed.read_to_end(&mut reader)?; + return comment + .decode_with_allowance(&packed, &mut budget, allowance) + .map(Some); + } + + let Some(comment) = self + .new_subs() + .find(|sub| sub.kind == NewSubKind::ArchiveComment) + else { + return Ok(None); + }; + let file = &comment.file; + budget.check(file.unp_size, b"CMT")?; + let mut data = Vec::new(); + let mut session = DecoderSession::with_allowance(false, options.password, allowance); + session.read_control = budget.control.clone(); + budget.run(b"CMT", &mut data, |mut writer| { + if file.is_stored() { + file.write_stored_with_allowance(self, options.password, &mut writer, allowance) + } else { + session.write_file_to(self, file, &mut writer) + } + })?; + Ok(Some(data)) + } +} + +fn decode_parallel_entry( + archive: &Archive, + file: &FileHeader, + options: crate::ArchiveReadOptions<'_>, +) -> Result { + decode_parallel_entry_with_allowance(archive, file, options, &Allowance::default()) +} + +enum ParallelExtractedEntry { + Directory(ExtractedEntryMeta), + File { + meta: ExtractedEntryMeta, + data: Buffer, + }, +} + +fn decode_parallel_entry_with_allowance( + archive: &Archive, + file: &FileHeader, + options: crate::ArchiveReadOptions<'_>, + allowance: &B, +) -> Result> { + options.check_cancelled()?; + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + // The only caller dispatches workers after excluding split members. + let meta = file.metadata(); + if meta.is_directory { + return Ok(ParallelExtractedEntry::Directory(meta)); + } + budget.check(file.unp_size, &file.name)?; + let mut data = Buffer::new(allowance); + let control = budget.control.clone(); + budget.run(&file.name, &mut data, |mut data| { + if file.is_stored() { + file.write_stored_with_allowance(archive, password, &mut data, allowance) + .map_err(|error| file.entry_error("extracting", error))?; + } else { + let mut session = DecoderSession::with_allowance(false, password, allowance); + session.read_control = control.clone(); + session + .write_file_to(archive, file, &mut data) + .map_err(|error| file.entry_error("extracting", error))?; + } + options.check_cancelled()?; + Ok(()) + })?; + Ok(ParallelExtractedEntry::File { meta, data }) +} + +fn write_parallel_entry( + entry: ParallelExtractedEntry, + open: &mut F, + control: &crate::read_control::ReadControl, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + control.check()?; + match entry { + ParallelExtractedEntry::Directory(meta) => { + let _ = open(&meta)?; + } + ParallelExtractedEntry::File { meta, data } => { + let mut writer = open(&meta)?; + control.check()?; + control + .write_all(&mut writer, &data) + .map_err(|error| Error::from(error).at_entry(meta.name.clone(), "extracting"))?; + } + } + control.check()?; + Ok(()) +} + +fn classify_new_sub(name: &[u8]) -> NewSubKind { + match name { + b"CMT" => NewSubKind::ArchiveComment, + b"RR" => NewSubKind::RecoveryRecord, + _ => NewSubKind::Unknown(name.to_vec()), + } +} + +fn parse_main_header(input: &[u8], block: &BlockHeader) -> Result { + if block.head_size < 13 { + return Err(Error::InvalidHeader("RAR 1.5 main header is too short")); + } + let start = block.offset; + let head_end = start + block.head_size as usize; + // Both callers have already read and validated this entire block. + let fixed = &input[start + 7..start + 13]; + + let encrypt_version = if block.flags & MHD_ENCRYPTVER != 0 { + Some( + *input + .get(start + 13..head_end) + .and_then(|bytes| bytes.first()) + .ok_or(Error::TooShort)?, + ) + } else { + None + }; + + Ok(MainHeader { + head_crc: block.head_crc, + flags: block.flags, + head_size: block.head_size, + reserved1: u16::from_le_bytes([fixed[0], fixed[1]]), + reserved2: u32::from_le_bytes([fixed[2], fixed[3], fixed[4], fixed[5]]), + encrypt_version, + }) +} + +fn parse_comment_header(input: &[u8], block: BlockHeader) -> Result { + if block.head_size < 13 { + return Err(Error::InvalidHeader("RAR 1.5 comment header is too short")); + } + let start = block.offset; + // Callers admitted the complete block before its fixed fields are decoded. + let fixed = &input[start + 7..start + 13]; + Ok(CommentHeader { + block, + unp_size: u16::from_le_bytes([fixed[0], fixed[1]]), + unp_ver: fixed[2], + method: fixed[3], + comment_crc: u16::from_le_bytes([fixed[4], fixed[5]]), + packed_range: 0..0, + }) +} + +/// Finds where a comment block starting at `start` ends, or `None` when the +/// bytes there are not one that fits inside `head_end`. +/// +/// Old readers skipped what they could not make sense of here rather than +/// rejecting the file, and a comment is never worth losing a member over. +fn comment_block_end(input: &[u8], start: usize, head_end: usize) -> Option { + if start + COMMENT_HEADER_SIZE > head_end { + return None; + } + // Callers supply a complete u16-sized header and an in-header position. + let head_size = u16::from_le_bytes([input[start + 5], input[start + 6]]) as usize; + let end = start + head_size; + (input[start + 2] == COMM_HEAD && head_size >= COMMENT_HEADER_SIZE && end <= head_end) + .then_some(end) +} + +/// Reads the archive comment RAR 1.5 to 2.9 could nest inside the main header. +/// +/// The main header's size covers the comment block, so the block loop steps +/// straight over it and this is the only place it can be seen. `main` locates +/// the main header inside the archive, `main_header` holds its bytes on their +/// own, and `source_offset` is where those bytes sit in the file. +fn nested_main_comment( + main_header: &[u8], + main: &BlockHeader, + source_offset: usize, +) -> Result> { + if main.flags & MHD_COMMENT == 0 { + return Ok(None); + } + let head_size = main.head_size as usize; + let Some(end) = comment_block_end(main_header, MAIN_HEADER_SIZE, head_size) else { + return Ok(None); + }; + let block = parse_block_header(main_header, MAIN_HEADER_SIZE)?; + let mut comment = parse_comment_header(main_header, block)?; + comment.block.offset = main.offset + MAIN_HEADER_SIZE; + comment.packed_range = + source_offset + MAIN_HEADER_SIZE + COMMENT_HEADER_SIZE..source_offset + end; + Ok(Some(comment)) +} + +fn parse_protect_header( + input: &[u8], + block: &BlockHeader, + archive_offset: usize, + total_size: usize, +) -> Result { + if block.head_size != 26 { + return Err(Error::InvalidHeader( + "RAR 2.x recovery header size is invalid", + )); + } + let add_size = block.add_size.ok_or(Error::InvalidHeader( + "RAR 2.x recovery header is missing data size", + ))?; + // The parser admitted the complete 26-byte block before dispatching here. + let fixed = &input[..26]; + let rec_sectors = u16::from_le_bytes([fixed[12], fixed[13]]); + let total_blocks = u32::from_le_bytes([fixed[14], fixed[15], fixed[16], fixed[17]]); + // These wire fields are u32 and u16; their maximum sum fits in u64. + let expected_add_size = u64::from(total_blocks) * 2 + u64::from(rec_sectors) * 512; + if add_size != expected_add_size { + return Err(Error::InvalidHeader( + "RAR 2.x recovery data size does not match header", + )); + } + let mark: [u8; 8] = fixed[18..26].try_into().expect("RAR protect mark size"); + // Both parser callers admitted this entire block's absolute next offset. + let data_start = archive_offset + block.offset + usize::from(block.head_size); + let data_end = archive_offset + block.offset + total_size; + Ok(ProtectHeader { + block: block.clone(), + version: fixed[11], + rec_sectors, + total_blocks, + mark, + data_range: data_start..data_end, + }) +} + +/// Repaired bytes plus whether any sector was actually rebuilt. +#[cfg(feature = "recovery")] +fn repair_protect_head_bytes( + source: &[u8], + sfx_offset: usize, + protect: &ProtectHeader, + control: &crate::read_control::ReadControl, +) -> Result<(Vec, bool)> { + control.check()?; + if protect.rec_sectors == 0 { + return Err(Error::InvalidHeader( + "RAR 2.x recovery record has no parity sectors", + )); + } + if protect.mark != *b"Protect!" { + return Err(Error::InvalidHeader("RAR 2.x recovery mark is invalid")); + } + let protected_start = sfx_offset; + // A u32 count fits the supported 32/64-bit host address sizes. + let declared_blocks = protect.total_blocks as usize; + let protected_len = declared_blocks + .checked_mul(512) + .ok_or(Error::InvalidHeader( + "RAR 2.x protected sector size overflows", + ))?; + let protected_end = protected_start + .checked_add(protected_len) + .ok_or(Error::InvalidHeader( + "RAR 2.x protected sector range overflows", + ))?; + if protected_end > source.len() { + return Err(Error::InvalidHeader( + "RAR 2.x protected sector range is invalid", + )); + } + let recovery_data = source + .get(protect.data_range.clone()) + .ok_or(Error::TooShort)?; + // The successful 512-byte sector calculation also bounds two-byte tags. + let tag_len = declared_blocks * 2; + // A u16 sector count needs at most 33553920 parity bytes on either host. + let parity_len = usize::from(protect.rec_sectors) * 512; + if recovery_data.len() != tag_len + parity_len { + return Err(Error::InvalidHeader( + "RAR 2.x recovery data size is invalid", + )); + } + let tags = &recovery_data[..tag_len]; + let parity = &recovery_data[tag_len..]; + // RAR 2.50 records may declare a final sector that starts before + // PROTECT_HEAD but overlaps the recovery block. Only complete sectors + // before the recovery block are safely repairable. + let repairable_blocks = declared_blocks.min(protect.block.offset / 512); + + let mut damaged = Vec::new(); + for index in 0..repairable_blocks { + control.check()?; + let sector_start = protected_start + index * 512; + let sector = &source[sector_start..sector_start + 512]; + let actual = (!crc32(sector) & 0xffff) as u16; + let expected = u16::from_le_bytes([tags[index * 2], tags[index * 2 + 1]]); + if actual != expected { + damaged.push(index); + } + } + if damaged.is_empty() { + return Ok((source.to_vec(), false)); + } + if damaged.len() > usize::from(protect.rec_sectors) { + return Err(Error::InvalidHeader( + "RAR 2.x recovery damage exceeds parity sector count", + )); + } + + let mut used_slots = vec![false; usize::from(protect.rec_sectors)]; + for &index in &damaged { + control.check()?; + let slot = index % usize::from(protect.rec_sectors); + if used_slots[slot] { + return Err(Error::InvalidHeader( + "RAR 2.x recovery cannot repair multiple sectors in the same parity group", + )); + } + used_slots[slot] = true; + } + + let mut repaired = source.to_vec(); + for &missing_index in &damaged { + control.check()?; + let slot = missing_index % usize::from(protect.rec_sectors); + let mut sector = parity[slot * 512..slot * 512 + 512].to_vec(); + for index in (slot..repairable_blocks).step_by(usize::from(protect.rec_sectors)) { + control.check()?; + if index == missing_index { + continue; + } + let sector_start = protected_start + index * 512; + for (out, byte) in sector + .iter_mut() + .zip(&repaired[sector_start..sector_start + 512]) + { + *out ^= *byte; + } + } + let sector_start = protected_start + missing_index * 512; + repaired[sector_start..sector_start + 512].copy_from_slice(§or); + let actual = (!crc32(§or) & 0xffff) as u16; + let expected = u16::from_le_bytes( + tags[missing_index * 2..missing_index * 2 + 2] + .try_into() + .unwrap(), + ); + if actual != expected { + return Err(Error::CrcMismatch { expected, actual }); + } + } + Ok((repaired, true)) +} + +/// Repaired bytes plus whether any sector was actually rebuilt. +#[cfg(feature = "recovery")] +fn repair_newsub_recovery_bytes( + source: &[u8], + sfx_offset: usize, + archive: &Archive, + recovery: &NewSubHeader, + control: &crate::read_control::ReadControl, +) -> Result<(Vec, bool)> { + control.check()?; + let recovery_data = newsub_recovery_data(archive, recovery, control)?; + let expected_unpacked = usize::try_from(recovery.file.unp_size) + .map_err(|_| Error::InvalidHeader("RAR 3.x recovery unpacked size overflows usize"))?; + if recovery_data.len() != expected_unpacked { + return Err(Error::InvalidHeader( + "RAR 3.x recovery data size does not match unpacked size", + )); + } + let protected_start = sfx_offset; + let protected_end = + sfx_offset + .checked_add(recovery.file.block.offset) + .ok_or(Error::InvalidHeader( + "RAR 3.x recovery protected range overflows", + ))?; + if protected_end > source.len() { + return Err(Error::InvalidHeader( + "RAR 3.x recovery protected range is invalid", + )); + } + let protected_len = protected_end - protected_start; + let protected_sectors = protected_len.div_ceil(512); + if protected_sectors == 0 { + return Err(Error::InvalidHeader( + "RAR 3.x recovery record has no protected sectors", + )); + } + // Sector count is ceil(an already-admitted physical extent / 512). + let tag_len = protected_sectors * 2; + if recovery_data.len() <= tag_len || !(recovery_data.len() - tag_len).is_multiple_of(512) { + return Err(Error::InvalidHeader( + "RAR 3.x recovery data size is invalid", + )); + } + let parity_sectors = (recovery_data.len() - tag_len) / 512; + let tags = &recovery_data[..tag_len]; + let parity = &recovery_data[tag_len..]; + + let mut damaged = Vec::new(); + for index in 0..protected_sectors { + control.check()?; + let sector = protected_sector(source, protected_start, protected_len, index); + let actual = (!crc32(§or) & 0xffff) as u16; + let expected = u16::from_le_bytes([tags[index * 2], tags[index * 2 + 1]]); + if actual != expected { + damaged.push(index); + } + } + if damaged.is_empty() { + return Ok((source.to_vec(), false)); + } + if damaged.len() > parity_sectors { + return Err(Error::InvalidHeader( + "RAR 3.x recovery damage exceeds parity sector count", + )); + } + + let mut used_slots = vec![false; parity_sectors]; + for &index in &damaged { + control.check()?; + let slot = index % parity_sectors; + if used_slots[slot] { + return Err(Error::InvalidHeader( + "RAR 3.x recovery cannot repair multiple sectors in the same parity group", + )); + } + used_slots[slot] = true; + } + + let mut repaired = source.to_vec(); + for &missing_index in &damaged { + control.check()?; + let slot = missing_index % parity_sectors; + let mut sector = parity[slot * 512..slot * 512 + 512].to_vec(); + for index in (slot..protected_sectors).step_by(parity_sectors) { + control.check()?; + if index == missing_index { + continue; + } + let other = protected_sector(&repaired, protected_start, protected_len, index); + for (out, byte) in sector.iter_mut().zip(other) { + control.check()?; + *out ^= byte; + } + } + let actual = (!crc32(§or) & 0xffff) as u16; + let expected = u16::from_le_bytes( + tags[missing_index * 2..missing_index * 2 + 2] + .try_into() + .unwrap(), + ); + if actual != expected { + return Err(Error::CrcMismatch { expected, actual }); + } + let sector_start = protected_start + missing_index * 512; + let write_len = 512.min(protected_end - sector_start); + repaired[sector_start..sector_start + write_len].copy_from_slice(§or[..write_len]); + } + + Ok((repaired, true)) +} + +#[cfg(feature = "recovery")] +fn newsub_recovery_data( + archive: &Archive, + recovery: &NewSubHeader, + control: &crate::read_control::ReadControl, +) -> Result> { + if recovery.file.is_encrypted() { + return Err(Error::UnsupportedFeature { + version: ArchiveVersion::Rar30, + feature: "encrypted RAR 3.x NEWSUB recovery record", + }); + } + if recovery.file.method == 0x30 { + if recovery.file.pack_size != recovery.file.unp_size { + return Err(Error::InvalidHeader( + "RAR 3.x recovery record packed size does not match unpacked size", + )); + } + return recovery.file.packed_data(archive); + } + let mut session = DecoderSession::new(false); + session.read_control = control.clone(); + control.finish(session.decode_file_data(archive, &recovery.file)) +} + +#[cfg(feature = "recovery")] +fn protected_sector( + source: &[u8], + protected_start: usize, + protected_len: usize, + index: usize, +) -> [u8; 512] { + // Both callers bound index by ceil(protected_len / 512), after validating + // the complete protected range against source. + let sector_offset = index * 512; + debug_assert!(sector_offset < protected_len); + let sector_start = protected_start + sector_offset; + let available = 512.min(protected_len - sector_offset); + let mut sector = [0u8; 512]; + sector[..available].copy_from_slice(&source[sector_start..sector_start + available]); + sector +} + +pub fn repair_rev3_volumes_to( + data_volumes: &[Option<&[u8]>], + recovery_count: usize, + recovery_volumes: &[(usize, &[u8])], + mut write: F, +) -> Result<()> +where + F: FnMut(usize, &[u8]) -> Result<()>, +{ + #[cfg(not(feature = "recovery"))] + { + let _ = (data_volumes, recovery_volumes, recovery_count, &mut write); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + for (index, bytes) in crate::recovery::rar3::reconstruct_data_volumes( + data_volumes, + recovery_count, + recovery_volumes, + ) + .map_err(Error::from)? + .into_iter() + .enumerate() + { + let bytes = truncate_repaired_rev3_volume(bytes); + write(index, &bytes)?; + } + Ok(()) + } +} + +#[cfg(feature = "recovery")] +fn truncate_repaired_rev3_volume(mut bytes: Vec) -> Vec { + let Ok(archive) = Archive::parse(&bytes) else { + return bytes; + }; + let Some(end) = archive.blocks.iter().find_map(|block| match block { + Block::End(end) => Some(end), + _ => None, + }) else { + return bytes; + }; + // Successful parsing admitted this end block and its full physical extent. + let end_size = (u64::from(end.head_size) + end.add_size.unwrap_or(0)) as usize; + let end_pos = archive.sfx_offset + end.offset + end_size; + if end_pos < bytes.len() && bytes[end_pos..].iter().all(|&byte| byte == 0) { + bytes.truncate(end_pos); + } + bytes +} + +struct EncryptedHeader { + block: BlockHeader, + header: Vec, + total_size: usize, +} + +#[derive(Default)] +struct EncryptedHeaderCipherCache { + #[cfg(feature = "encryption")] + salt: Option<[u8; 8]>, + #[cfg(feature = "encryption")] + cipher: Option, +} + +#[cfg(feature = "encryption")] +impl EncryptedHeaderCipherCache { + fn cipher(&mut self, password: &[u8], salt: [u8; 8]) -> Result { + if self.salt != Some(salt) { + self.salt = Some(salt); + self.cipher = + Some(Rar30Cipher::new(password, Some(salt)).map_err(map_rar30_crypto_error)?); + } + Ok(self + .cipher + .as_ref() + .expect("RAR 3 encrypted header cipher cache initialized") + .clone()) + } +} + +#[cfg(feature = "encryption")] +fn map_rar30_crypto_error(error: Rar30Error) -> Error { + Error::from(error) +} + +fn decrypt_encrypted_header_at( + archive: &[u8], + offset: usize, + password: &[u8], + cipher_cache: &mut EncryptedHeaderCipherCache, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + #[cfg(not(feature = "encryption"))] + { + let _ = (archive, offset, password, cipher_cache, budget); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + let salt = read_header_salt(archive, offset)?; + let first_ciphertext = archive + .get(offset + 8..offset + 24) + .ok_or(Error::TooShort)?; + budget.check_count(offset)?; + let mut cipher = cipher_cache.cipher(password, salt)?; + let mut first_block = [0u8; 16]; + first_block.copy_from_slice(first_ciphertext); + cipher.decrypt_block(&mut first_block); + let head_size = u16::from_le_bytes([first_block[5], first_block[6]]) as usize; + if head_size < 7 { + return Err(Error::InvalidHeader("RAR 1.5 block header is too short")); + } + // A u16 wire length rounds to at most 65536, including on 32-bit hosts. + let encrypted_header_size = head_size.next_multiple_of(16); + // offset is within a physical slice (at most isize::MAX); this u16 wire + // length adds at most 65544, which fits usize on both supported widths. + let encrypted_end = offset + 8 + encrypted_header_size; + if encrypted_end > archive.len() { + return Err(Error::TooShort); + } + budget.admit(head_size, offset)?; + // The first 24 bytes and the rounded header end were admitted above. + let encrypted_rest = &archive[offset + 24..encrypted_end]; + let mut header = Vec::with_capacity(encrypted_header_size); + header.extend_from_slice(&first_block); + header.extend_from_slice(encrypted_rest); + // The rounded header minus its first block is a whole number of AES blocks. + for block in header[16..].as_chunks_mut::<16>().0.iter_mut() { + cipher.decrypt_block(block); + } + header.truncate(head_size); + + let mut block = parse_block_header(&header, 0)?; + block.offset = offset; + // Parsed add_size is a widened wire u32 and fits both supported widths. + let payload_size = block.add_size.unwrap_or(0) as usize; + let total_size = 8usize + .checked_add(encrypted_header_size) + .and_then(|size| size.checked_add(payload_size)) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize"))?; + Ok(EncryptedHeader { + block, + header, + total_size, + }) + } +} + +fn read_encrypted_header_at( + file: &mut (impl Read + std::io::Seek), + file_len: u64, + archive_offset: usize, + offset: usize, + password: &[u8], + cipher_cache: &mut EncryptedHeaderCipherCache, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + #[cfg(not(feature = "encryption"))] + { + let _ = ( + file, + file_len, + archive_offset, + offset, + password, + cipher_cache, + budget, + ); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + let absolute = archive_offset + .checked_add(offset) + .ok_or(Error::InvalidHeader("RAR 1.5 block offset overflows usize"))?; + let remaining = file_len + .checked_sub(absolute as u64) + .ok_or(Error::TooShort)?; + if remaining < 24 { + return Err(Error::TooShort); + } + let first = read_exact_at(file, absolute, 24)?; + let salt = read_header_salt(&first, 0)?; + budget.check_count(offset)?; + let mut cipher = cipher_cache.cipher(password, salt)?; + let mut first_block = [0u8; 16]; + first_block.copy_from_slice(&first[8..24]); + cipher.decrypt_block(&mut first_block); + let head_size = u16::from_le_bytes([first_block[5], first_block[6]]) as usize; + if head_size < 7 { + return Err(Error::InvalidHeader("RAR 1.5 block header is too short")); + } + // A u16 wire length rounds to at most 65536, including on 32-bit hosts. + let encrypted_header_size = head_size.next_multiple_of(16); + let encrypted_start = absolute + .checked_add(8) + .ok_or(Error::InvalidHeader("RAR 1.5 block offset overflows usize"))?; + if encrypted_header_size as u64 > remaining - 8 { + return Err(Error::TooShort); + } + budget.admit(head_size, offset)?; + let encrypted_rest_start = encrypted_start + .checked_add(16) + .ok_or(Error::InvalidHeader("RAR 1.5 block offset overflows usize"))?; + let encrypted_rest = read_exact_at(file, encrypted_rest_start, encrypted_header_size - 16)?; + let mut header = Vec::with_capacity(encrypted_header_size); + header.extend_from_slice(&first_block); + header.extend_from_slice(&encrypted_rest); + // The rounded header minus its first block is a whole number of AES blocks. + for block in header[16..].as_chunks_mut::<16>().0.iter_mut() { + cipher.decrypt_block(block); + } + header.truncate(head_size); + + let mut block = parse_block_header(&header, 0)?; + block.offset = offset; + // Parsed add_size is a widened wire u32 and fits both supported widths. + let payload_size = block.add_size.unwrap_or(0) as usize; + let total_size = 8usize + .checked_add(encrypted_header_size) + .and_then(|size| size.checked_add(payload_size)) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize"))?; + Ok(EncryptedHeader { + block, + header, + total_size, + }) + } +} + +#[cfg(feature = "encryption")] +fn read_header_salt(input: &[u8], offset: usize) -> Result<[u8; 8]> { + input + .get(offset..offset + 8) + .ok_or(Error::TooShort) + .map(|salt| salt.try_into().expect("RAR 3 salt size")) +} + +fn parse_file_like_header( + input: &[u8], + block: BlockHeader, + archive_offset: usize, +) -> Result { + if block.head_size < 32 { + return Err(Error::InvalidHeader("RAR 1.5 file header is too short")); + } + if block.flags & LONG_BLOCK == 0 { + return Err(Error::InvalidHeader( + "RAR 1.5 file header is missing packed data size", + )); + } + + let start = block.offset; + let head_end = start + block.head_size as usize; + + // Complete block admission plus the minimum-size guard bounds base fields. + let fixed = &input[start..start + 32]; + let pack_low = u32::from_le_bytes([fixed[7], fixed[8], fixed[9], fixed[10]]) as u64; + let unp_low = u32::from_le_bytes([fixed[11], fixed[12], fixed[13], fixed[14]]) as u64; + let host_os = fixed[15]; + let file_crc = u32::from_le_bytes([fixed[16], fixed[17], fixed[18], fixed[19]]); + let file_time = u32::from_le_bytes([fixed[20], fixed[21], fixed[22], fixed[23]]); + let unp_ver = fixed[24]; + let method = fixed[25]; + let name_size = u16::from_le_bytes([fixed[26], fixed[27]]) as usize; + let attr = u32::from_le_bytes([fixed[28], fixed[29], fixed[30], fixed[31]]); + let mut pos = start + 32; + + let (pack_size, unp_size) = if block.flags & FHD_LARGE != 0 { + let high_pack = read_u32(input, pos)? as u64; + let high_unp = read_u32(input, pos + 4)? as u64; + pos += 8; + ((high_pack << 32) | pack_low, (high_unp << 32) | unp_low) + } else { + (pack_low, unp_low) + }; + + // Relative headers start at zero: base+LARGE prefix <=40, name is a u16. + let name_end = pos + name_size; + if name_end > head_end { + return Err(Error::InvalidHeader( + "RAR 1.5 file name extends beyond header", + )); + } + let unicode_name = (block.flags & FHD_UNICODE != 0).then(|| input[pos..name_end].to_vec()); + let name = decode_file_name(&input[pos..name_end], block.flags); + pos = name_end; + + let salt = if block.flags & FHD_SALT != 0 { + // name_end was bounded by the complete u16-sized header above. + let salt_end = pos + 8; + if salt_end > head_end { + return Err(Error::InvalidHeader( + "RAR 1.5 salt extends beyond file header", + )); + } + let salt_bytes = &input[pos..salt_end]; + pos = salt_end; + Some( + salt_bytes + .try_into() + .expect("RAR 1.5 salt slice has fixed length"), + ) + } else { + None + }; + + let file_comment = if block.flags & FHD_COMMENT != 0 { + match comment_block_end(input, pos, head_end) { + Some(comment_end) => { + let comment = input[pos..comment_end].to_vec(); + pos = comment_end; + comment + } + None => Vec::new(), + } + } else { + Vec::new() + }; + + let ext_time = if block.flags & FHD_EXTTIME != 0 { + input[pos..head_end].to_vec() + } else { + Vec::new() + }; + let data_start = head_end; + let data_len = usize::try_from(pack_size) + .map_err(|_| Error::InvalidHeader("RAR 1.5 packed file size overflows usize"))?; + let data_end = data_start + .checked_add(data_len) + .ok_or(Error::InvalidHeader( + "RAR 1.5 packed file size overflows usize", + ))?; + Ok(FileHeader { + block, + pack_size, + unp_size, + host_os, + file_crc, + file_time, + unp_ver, + method, + name, + unicode_name, + attr, + salt, + file_comment, + ext_time, + packed_range: archive_offset + data_start..archive_offset + data_end, + }) +} + +#[cfg(any(test, feature = "write"))] +pub(crate) fn validate_unicode_name(raw: &[u8], decoded: &[u8]) -> Result<()> { + if decode_file_name(raw, FHD_UNICODE) != decoded || std::str::from_utf8(decoded).is_err() { + return Err(Error::InvalidArgument("invalid legacy Unicode filename")); + } + crate::filename::validate_relative(decoded)?; + if let Some(zero) = raw.iter().position(|byte| *byte == 0) { + crate::filename::validate_relative(&raw[..zero])?; + } + Ok(()) +} + +pub(crate) fn decode_file_name(raw: &[u8], flags: u16) -> Vec { + if flags & FHD_UNICODE == 0 { + return raw.to_vec(); + } + + let Some(zero_pos) = raw.iter().position(|byte| *byte == 0) else { + return raw.to_vec(); + }; + if zero_pos + 1 >= raw.len() { + return raw[..zero_pos].to_vec(); + } + + let fallback = &raw[..zero_pos]; + let high_byte = raw[zero_pos + 1]; + let encoded = &raw[zero_pos + 2..]; + let mut pos = 0usize; + let mut flag_byte = 0u8; + let mut flag_bits = 0u8; + let mut dst_pos = 0usize; + let mut units = Vec::new(); + + while pos < encoded.len() { + if flag_bits == 0 { + flag_byte = encoded[pos]; + pos += 1; + flag_bits = 8; + } + let mode = flag_byte >> 6; + flag_byte <<= 2; + flag_bits -= 2; + + match mode { + 0 => { + let Some(&low) = encoded.get(pos) else { + return raw.to_vec(); + }; + pos += 1; + units.push(u16::from(low)); + dst_pos += 1; + } + 1 => { + let Some(&low) = encoded.get(pos) else { + return raw.to_vec(); + }; + pos += 1; + units.push((u16::from(high_byte) << 8) | u16::from(low)); + dst_pos += 1; + } + 2 => { + let Some((&low, &high)) = encoded.get(pos).zip(encoded.get(pos + 1)) else { + return raw.to_vec(); + }; + pos += 2; + units.push((u16::from(high) << 8) | u16::from(low)); + dst_pos += 1; + } + // The mode is the top two bits of a byte, so this is mode 3. + _ => { + let Some(&length_byte) = encoded.get(pos) else { + return raw.to_vec(); + }; + pos += 1; + let (count, correction, high) = if length_byte & 0x80 != 0 { + let Some(&correction) = encoded.get(pos) else { + return raw.to_vec(); + }; + pos += 1; + ((length_byte & 0x7f) as usize + 2, correction, high_byte) + } else { + (length_byte as usize + 2, 0, 0) + }; + for _ in 0..count { + let Some(&low) = fallback.get(dst_pos) else { + return raw.to_vec(); + }; + let low = low.wrapping_add(correction); + units.push((u16::from(high) << 8) | u16::from(low)); + dst_pos += 1; + } + } + } + } + + // An invalid Unicode field must not collapse distinct archive identities + // to the same replacement-character name. Keep the undecodable field, as + // for malformed encoding commands above; filesystem extraction can refuse it. + String::from_utf16(&units) + .map(String::into_bytes) + .unwrap_or_else(|_| raw.to_vec()) +} + +fn admit_plain_header( + input: &[u8], + offset: usize, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result<()> { + budget.control.check()?; + if !budget.is_limited() { + return Ok(()); + } + // Both parser call sites bound offset by the physical archive extent. + let prefix = &input[offset..]; + if prefix.len() < 7 { + return Err(Error::TooShort); + } + let size = u16::from_le_bytes([prefix[5], prefix[6]]) as usize; + if size < 7 { + return Err(Error::InvalidHeader("RAR 1.5 block header is too short")); + } + if size > prefix.len() { + return Err(Error::TooShort); + } + budget.admit(size, offset) +} + +fn read_block_header_at( + file: &mut (impl Read + std::io::Seek), + file_len: u64, + archive_offset: usize, + offset: usize, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + let absolute = archive_offset + .checked_add(offset) + .ok_or(Error::InvalidHeader("RAR 1.5 block offset overflows usize"))?; + let remaining = file_len + .checked_sub(absolute as u64) + .ok_or(Error::TooShort)?; + if remaining < 7 { + return Err(Error::TooShort); + } + let base = read_exact_at(file, absolute, 7)?; + // A successful exact read has admitted the entire fixed prefix. + let head_size = u16::from_le_bytes([base[5], base[6]]) as usize; + if head_size < 7 { + return Err(Error::InvalidHeader("RAR 1.5 block header is too short")); + } + if head_size as u64 > remaining { + return Err(Error::TooShort); + } + if offset != 0 { + budget.admit(head_size, offset)?; + } + let header = if head_size == 7 { + base + } else { + read_exact_at(file, absolute, head_size)? + }; + let mut block = parse_block_header(&header, 0)?; + block.offset = offset; + Ok(block) +} + +fn relative_block(block: &BlockHeader) -> BlockHeader { + let mut relative = block.clone(); + relative.offset = 0; + relative +} + +struct CrcWriter<'a, W: Write + ?Sized> { + inner: &'a mut W, + crc: &'a mut Crc32, +} + +impl Write for CrcWriter<'_, W> { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + let written = self.inner.write(buf)?; + self.crc.update(&buf[..written]); + Ok(written) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.inner.flush() + } +} + +fn parse_block_header(input: &[u8], offset: usize) -> Result { + if input.len() < offset + 7 { + return Err(Error::TooShort); + } + let prefix = &input[offset..offset + 7]; + let head_crc = u16::from_le_bytes([prefix[0], prefix[1]]); + let head_type = prefix[2]; + let flags = u16::from_le_bytes([prefix[3], prefix[4]]); + let head_size = u16::from_le_bytes([prefix[5], prefix[6]]); + if head_size < 7 { + return Err(Error::InvalidHeader("RAR 1.5 block header is too short")); + } + let add_size = if flags & LONG_BLOCK != 0 { + Some(read_u32(input, offset + 7)? as u64) + } else { + None + }; + if offset + head_size as usize > input.len() { + return Err(Error::TooShort); + } + if head_type != MARK_HEAD && should_validate_header_crc(head_type) { + let header_end = header_crc_end(input, offset, head_type, flags, head_size)?; + let actual = (crc32(&input[offset + 2..header_end]) & 0xffff) as u16; + if actual != head_crc { + return Err(Error::CrcMismatch { + expected: head_crc, + actual, + }); + } + } + validate_legacy_auth_block_size(head_type, head_size)?; + + Ok(BlockHeader { + head_crc, + head_type, + flags, + head_size, + add_size, + offset, + }) +} + +fn header_crc_end( + input: &[u8], + offset: usize, + head_type: u8, + flags: u16, + head_size: u16, +) -> Result { + let full_end = offset + head_size as usize; + let fixed_end = match head_type { + MAIN_HEAD if flags & MHD_COMMENT != 0 => Some(offset + 13), + COMM_HEAD => Some(offset + 13), + FILE_HEAD if flags & FHD_COMMENT != 0 => Some(file_header_comment_crc_end(input, offset)?), + _ => None, + }; + Ok(fixed_end.unwrap_or(full_end).min(full_end)) +} + +fn file_header_comment_crc_end(input: &[u8], offset: usize) -> Result { + if input.len() < offset + 32 { + return Err(Error::TooShort); + } + let fixed = &input[offset..offset + 32]; + let flags = u16::from_le_bytes([fixed[3], fixed[4]]); + let name_size = u16::from_le_bytes([fixed[26], fixed[27]]) as usize; + let mut end = offset + 32; + // Offset is within a physical slice; the remaining fields add at most + // a u16 name length plus two eight-byte fields, so usize cannot overflow. + if flags & FHD_LARGE != 0 { + end += 8; + } + end += name_size; + if flags & FHD_SALT != 0 { + end += 8; + } + Ok(end) +} + +fn should_validate_header_crc(head_type: u8) -> bool { + // Historical AV/SIGN blocks are documented with inconsistent CRC fields in + // real archives, so readers must not reject them solely on HEAD_CRC. + !matches!(head_type, 0x76 | 0x79) +} + +fn validate_legacy_auth_block_size(head_type: u8, head_size: u16) -> Result<()> { + let minimum = match head_type { + 0x76 => 21, + 0x79 => 182, + _ => return Ok(()), + }; + if head_size < minimum { + return Err(Error::InvalidHeader( + "RAR legacy authenticity block is too short", + )); + } + Ok(()) +} + +fn block_total_size(block: &BlockHeader) -> Result { + let total = block.head_size as u64 + block.add_size.unwrap_or(0); + usize::try_from(total).map_err(|_| Error::InvalidHeader("RAR 1.5 block size overflows usize")) +} + +fn file_block_total_size( + block: &BlockHeader, + default_total: usize, + pack_size: u64, +) -> Result { + // Parsed add_size is a widened u32, and default_total already includes it. + let low_payload_size = block.add_size.unwrap_or(0) as usize; + let header_prefix = default_total - low_payload_size; + // Every caller obtained pack_size from parse_file_like_header, which + // admitted its conversion and relative payload end before returning. + let pack_size = pack_size as usize; + header_prefix + .checked_add(pack_size) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize")) +} + +fn checked_block_next(block: &BlockHeader, total: usize, archive_len: usize) -> Result { + let next = block + .offset + .checked_add(total) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize"))?; + if next > archive_len { + return Err(Error::TooShort); + } + Ok(next) +} + +fn checked_file_block_next( + sfx_offset: usize, + block: &BlockHeader, + total: usize, + file_len: u64, +) -> Result { + let next = block + .offset + .checked_add(total) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize"))?; + let absolute_next = sfx_offset + .checked_add(next) + .ok_or(Error::InvalidHeader("RAR 1.5 block size overflows usize"))?; + if absolute_next as u64 > file_len { + return Err(Error::TooShort); + } + Ok(next) +} + +/// Called only after full packed-size conversion and the next block extent have +/// been admitted. The checked total includes the payload, so subtraction fits. +fn packed_range(archive_offset: usize, next: usize, pack_size: u64) -> Range { + let block_end = archive_offset + next; + block_end - pack_size as usize..block_end +} + +#[cfg(all(test, feature = "write"))] +mod tests { + use crate::FeatureSet; + #[test] + fn header_budget_refuses_full_reads_after_plain_and_encrypted_prefixes() { + use crate::parse_budget::{ParseBudget, PrefixReader}; + let options = crate::ArchiveReadOptions::new().with_max_header_bytes(63); + let mut plain = vec![0u8; 16]; + plain[5] = 64; + let mut prefix = vec![0; 7]; // skipped marker bytes + prefix.extend_from_slice(&plain[..7]); + let mut reader = PrefixReader::new(prefix); + let e = super::read_block_header_at(&mut reader, 128, 0, 7, &mut ParseBudget::new(options)) + .map(|_| ()) + .expect_err("header budget must refuse"); + assert!(matches!( + e.root_cause(), + crate::Error::HeaderBytesLimitExceeded { required: 64, .. } + )); + assert_eq!(reader.reads, [7]); + + #[cfg(feature = "encryption")] + { + let mut cipher = + crate::crypto::rar30::Rar30Cipher::new(b"secret", Some([0; 8])).unwrap(); + cipher.encrypt_in_place(&mut plain).unwrap(); + let mut prefix = vec![0; 8]; + prefix.extend_from_slice(&plain); + let mut reader = PrefixReader::new(prefix); + let e = super::read_encrypted_header_at( + &mut reader, + 128, + 0, + 0, + b"secret", + &mut super::EncryptedHeaderCipherCache::default(), + &mut ParseBudget::new(options), + ) + .map(|_| ()) + .expect_err("header budget must refuse"); + assert!(matches!( + e.root_cause(), + crate::Error::HeaderBytesLimitExceeded { required: 64, .. } + )); + assert_eq!(reader.reads, [24]); + } + } + use super::*; + use crate::io_util::read_u16; + + #[test] + fn declared_payload_extents_are_checked_for_each_block_kind() { + for head_type in [ + FILE_HEAD, + NEWSUB_HEAD, + COMM_HEAD, + PROTECT_HEAD, + ENDARC_HEAD, + 0x7e, + ] { + let size: u16 = match head_type { + FILE_HEAD | NEWSUB_HEAD => 33, + PROTECT_HEAD => 26, + COMM_HEAD => 13, + _ => 11, + }; + let mut header = vec![0; usize::from(size)]; + header[2] = head_type; + header[3..5].copy_from_slice(&LONG_BLOCK.to_le_bytes()); + header[5..7].copy_from_slice(&size.to_le_bytes()); + header[7..11].copy_from_slice(&4u32.to_le_bytes()); + if matches!(head_type, FILE_HEAD | NEWSUB_HEAD) { + header[24] = 29; + header[25] = 0x30; + header[26..28].copy_from_slice(&1u16.to_le_bytes()); + header[32] = b'x'; + } else if head_type == PROTECT_HEAD { + header[14..18].copy_from_slice(&2u32.to_le_bytes()); + header[18..26].copy_from_slice(b"Protect!"); + } + test_write_header_crc(&mut header, 0); + for available in 0..=4 { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, 0); + bytes.extend_from_slice(&header); + bytes.resize(bytes.len() + available, 0); + for result in [ + Archive::parse(&bytes), + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + if available < 4 { + assert!( + matches!(result, Err(Error::TooShort)), + "type {head_type:x}, extent {available}: {result:?}" + ); + } else { + assert_eq!(result.unwrap().blocks.len(), 1); + } + } + } + } + } + + #[test] + fn large_file_totals_refuse_relative_and_encrypted_prefix_overflow() { + for head_type in [FILE_HEAD, NEWSUB_HEAD] { + for encrypted in crate::test_features::encryption_cases() { + let pack_size = u64::MAX - 41; + let mut header = vec![0; 41]; + header[2] = head_type; + header[3..5].copy_from_slice(&(LONG_BLOCK | FHD_LARGE).to_le_bytes()); + header[5..7].copy_from_slice(&41u16.to_le_bytes()); + header[7..11].copy_from_slice(&(pack_size as u32).to_le_bytes()); + header[24] = 29; + header[25] = 0x30; + header[26..28].copy_from_slice(&1u16.to_le_bytes()); + header[32..36].copy_from_slice(&((pack_size >> 32) as u32).to_le_bytes()); + header[40] = b'x'; + test_write_header_crc(&mut header, 0); + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, if encrypted { MHD_PASSWORD } else { 0 }); + if encrypted { + #[cfg(feature = "encryption")] + { + header.resize(48, 0); + crate::crypto::rar30::Rar30Cipher::new(b"pw", Some([0; 8])) + .unwrap() + .encrypt_in_place(&mut header) + .unwrap(); + bytes.extend_from_slice(&[0; 8]); + } + } + bytes.extend_from_slice(&header); + let options = crate::ArchiveReadOptions::with_password(b"pw"); + for result in [ + Archive::parse_with_options(&bytes, options), + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + options, + ), + ] { + // On 64-bit, plain relative FILE size fits exactly, but the + // containing archive offset (or encrypted physical prefix) does not. + let expected = if usize::BITS == 32 && !encrypted { + "RAR 1.5 packed file size overflows usize" + } else { + "RAR 1.5 block size overflows usize" + }; + assert!( + matches!(result, Err(Error::InvalidHeader(message)) if message == expected), + "{result:?}" + ); + } + } + } + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_source_failures_are_preserved_after_successful_parsing() { + use std::sync::atomic::{AtomicBool, Ordering}; + struct FailingSource { + bytes: std::io::Cursor>, + fail: Arc, + } + impl Read for FailingSource { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + if self.fail.load(Ordering::Relaxed) { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "recovery source denied", + )) + } else { + self.bytes.read(bytes) + } + } + } + impl std::io::Seek for FailingSource { + fn seek(&mut self, from: std::io::SeekFrom) -> std::io::Result { + self.bytes.seek(from) + } + } + for bytes in [ + &include_bytes!("../tests/fixtures/rar15_40/rar250_protect_head_rr1.rar")[..], + &include_bytes!("../tests/fixtures/rar15_40/rar300/with_recovery_rar300.rar")[..], + ] { + let fail = Arc::new(AtomicBool::new(false)); + let source = crate::source::ReaderSource::new(FailingSource { + bytes: std::io::Cursor::new(bytes.to_vec()), + fail: fail.clone(), + }) + .unwrap(); + let archive = Archive::parse_seekable( + source.cursor(), + bytes.len() as u64, + 0, + ArchiveSource::Reader(source), + crate::ArchiveReadOptions::new(), + ) + .unwrap(); + fail.store(true, Ordering::Relaxed); + assert!( + matches!(archive.repair_protect_head(), Err(Error::Io(error)) + if error.kind == std::io::ErrorKind::PermissionDenied && error.message == "recovery source denied") + ); + } + let archive = preservation_seed(ArchiveVersion::Rar29); + assert!(matches!( + archive.repair_protect_head(), + Err(Error::InvalidHeader( + "RAR 2.x archive does not contain a PROTECT_HEAD recovery record" + )) + )); + } + + #[test] + fn complete_header_crc_failures_survive_plain_and_encrypted_adapters() { + for encrypted in crate::test_features::encryption_cases() { + for corrupt in [false, true] { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, if encrypted { MHD_PASSWORD } else { 0 }); + let mut header = vec![0; 7]; + header[2] = ENDARC_HEAD; + header[5..7].copy_from_slice(&7u16.to_le_bytes()); + test_write_header_crc(&mut header, 0); + if corrupt { + header[0] ^= 1; + } + if encrypted { + #[cfg(feature = "encryption")] + { + header.resize(16, 0); + crate::crypto::rar30::Rar30Cipher::new(b"pw", Some([0; 8])) + .unwrap() + .encrypt_in_place(&mut header) + .unwrap(); + bytes.extend_from_slice(&[0; 8]); + } + } + bytes.extend_from_slice(&header); + let options = crate::ArchiveReadOptions::with_password(b"pw"); + for result in [ + Archive::parse_with_options(&bytes, options), + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + options, + ), + ] { + if corrupt { + assert!( + matches!(result, Err(Error::CrcMismatch { .. })), + "{result:?}" + ); + } else { + assert!(matches!(result.unwrap().blocks.last(), Some(Block::End(_)))); + } + } + } + } + } + + #[test] + #[cfg(feature = "recovery")] + fn rev3_repair_preserves_reconstruction_and_publication_failures() { + let mut calls = 0; + let error = repair_rev3_volumes_to(&[], 1, &[(0, b"data")], |_, _| { + calls += 1; + Ok(()) + }) + .unwrap_err(); + assert!(matches!( + error, + Error::Rar3Recovery(crate::recovery::rar3::Error::InvalidCodewordSize) + )); + assert_eq!(calls, 0); + + let volumes: &[Option<&[u8]>] = &[Some(b"data"), Some(b"next")]; + let error = repair_rev3_volumes_to(volumes, 1, &[(0, b"0000")], |index, bytes| { + calls += 1; + assert_eq!(index, 0); + assert_eq!(bytes, b"data"); + Err( + std::io::Error::new(std::io::ErrorKind::PermissionDenied, "publication denied") + .into(), + ) + }) + .unwrap_err(); + assert!( + matches!(error, Error::Io(ref source) if source.kind == std::io::ErrorKind::PermissionDenied && source.message == "publication denied") + ); + assert_eq!(calls, 1, "publication stops at the failing volume"); + let mut published = Vec::new(); + repair_rev3_volumes_to(volumes, 1, &[(0, b"0000")], |index, bytes| { + published.push((index, bytes.to_vec())); + Ok(()) + }) + .unwrap(); + assert_eq!(published, [(0, b"data".to_vec()), (1, b"next".to_vec())]); + } + + #[test] + fn preservation_refuses_unsafe_unicode_names_and_independent_fallbacks() { + for unsafe_decoded in [false, true] { + let mut archive = preservation_seed(ArchiveVersion::Rar29); + let file = preservation_file(&mut archive); + if unsafe_decoded { + file.name = b"../entry".to_vec(); + file.unicode_name = Some(b"../entry\0".to_vec()); + } else { + let mut raw = crate::filename::encode_legacy_unicode(b"entry").unwrap(); + // Full UTF-16 commands leave the decoded name independent of this fallback. + raw[..5].copy_from_slice(b"/evil"); + assert_eq!(decode_file_name(&raw, FHD_UNICODE), b"entry"); + file.unicode_name = Some(raw); + } + assert!(archive + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("malformed or unsupported legacy Unicode name"))); + } + } + + #[test] + fn nested_comment_crc_failure_survives_both_parser_adapters() { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, MHD_COMMENT); + let nested = bytes.len(); + bytes.extend_from_slice(&comment_block(b"note")); + let main = RAR15_SIGNATURE.len(); + let size = (bytes.len() - main) as u16; + bytes[main + 5..main + 7].copy_from_slice(&size.to_le_bytes()); + test_write_header_crc(&mut bytes[..main + MAIN_HEADER_SIZE], main); + for corrupt in [false, true] { + let mut input = bytes.clone(); + if corrupt { + input[nested] ^= 1; + } + let memory = Archive::parse(&input); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&input), + input.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(input.clone())), + crate::ArchiveReadOptions::new(), + ); + if corrupt { + assert!(matches!(memory, Err(Error::CrcMismatch { .. }))); + assert!(matches!(seekable, Err(Error::CrcMismatch { .. }))); + } else { + for archive in [memory.unwrap(), seekable.unwrap()] { + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&b"note"[..]) + ); + } + } + } + } + + #[test] + fn edited_archive_comment_range_preserves_source_refusal() { + let mut builder = crate::Builder::new(ArchiveVersion::Rar15) + .store(true) + .comment(Some(b"note".to_vec())); + builder + .add_bytes(b"entry".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let mut archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.archive_comment().unwrap().as_deref(), + Some(&b"note"[..]) + ); + let comment = archive + .blocks + .iter_mut() + .find_map(|block| match block { + Block::Comment(comment) => Some(comment), + _ => None, + }) + .unwrap(); + comment.packed_range = usize::MAX..usize::MAX; + assert!(matches!(archive.archive_comment(), Err(Error::TooShort))); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn seekable_offsets_above_native_address_size_are_refused() { + use std::io::{self, Read, Seek, SeekFrom}; + struct HighInput<'a> { + start: u64, + position: u64, + bytes: &'a [u8], + } + impl Read for HighInput<'_> { + fn read(&mut self, output: &mut [u8]) -> io::Result { + if !(self.start..self.start + self.bytes.len() as u64).contains(&self.position) { + return Ok(0); + } + let offset = (self.position - self.start) as usize; + let length = output.len().min(self.bytes.len() - offset); + output[..length].copy_from_slice(&self.bytes[offset..offset + length]); + self.position += length as u64; + Ok(length) + } + } + impl Seek for HighInput<'_> { + fn seek(&mut self, position: SeekFrom) -> io::Result { + match position { + SeekFrom::Start(position) => { + self.position = position; + Ok(position) + } + _ => Err(io::ErrorKind::Unsupported.into()), + } + } + } + let mut main = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut main, 0); + for (start, bytes, expected) in [ + ( + u64::from(u32::MAX) - 3, + &RAR15_SIGNATURE[..], + "RAR 1.5 block offset overflows usize", + ), + ( + u64::from(u32::MAX) - 17, + &main[..], + "RAR 1.5 block size overflows usize", + ), + ] { + let result = Archive::parse_seekable( + HighInput { + start, + position: 0, + bytes, + }, + start + bytes.len() as u64, + start as usize, + ArchiveSource::Memory(Arc::from(&[][..])), + crate::ArchiveReadOptions::new(), + ); + assert!( + matches!(result, Err(Error::InvalidHeader(message)) if message == expected), + "{result:?}" + ); + } + // A complete salt/first AES block may fit the u64 file but leave the + // address of its (possibly empty) tail beyond native usize. + let mut header = vec![0; 16]; + header[2] = ENDARC_HEAD; + header[5..7].copy_from_slice(&7u16.to_le_bytes()); + test_write_header_crc(&mut header[..7], 0); + Rar30Cipher::new(b"pw", Some([0; 8])) + .unwrap() + .encrypt_in_place(&mut header) + .unwrap(); + let mut bytes = vec![0; 8]; + bytes.extend_from_slice(&header); + let start = u64::from(u32::MAX) - 10; + let result = read_encrypted_header_at( + &mut HighInput { + start, + position: 0, + bytes: &bytes, + }, + start + bytes.len() as u64, + start as usize, + 0, + b"pw", + &mut EncryptedHeaderCipherCache::default(), + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ); + assert!(matches!( + result, + Err(Error::InvalidHeader("RAR 1.5 block offset overflows usize")) + )); + } + + #[test] + fn protection_header_requires_a_declared_data_size() { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, 0); + let start = bytes.len(); + let mut header = vec![0; 26]; + header[2] = PROTECT_HEAD; + header[5..7].copy_from_slice(&26u16.to_le_bytes()); + bytes.extend_from_slice(&header); + test_write_header_crc(&mut bytes, start); + for result in [ + Archive::parse(&bytes), + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + assert!(matches!( + result, + Err(Error::InvalidHeader( + "RAR 2.x recovery header is missing data size" + )) + )); + } + } + + #[test] + fn maximum_large_packed_size_is_refused_before_payload_access() { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, 0); + let start = bytes.len(); + let mut header = vec![0; 41]; + header[2] = FILE_HEAD; + header[3..5].copy_from_slice(&(LONG_BLOCK | FHD_LARGE).to_le_bytes()); + header[5..7].copy_from_slice(&41u16.to_le_bytes()); + header[7..11].copy_from_slice(&u32::MAX.to_le_bytes()); + header[24] = 29; + header[25] = 0x30; + header[26..28].copy_from_slice(&1u16.to_le_bytes()); + header[32..36].copy_from_slice(&u32::MAX.to_le_bytes()); + header[40] = b'x'; + bytes.extend_from_slice(&header); + test_write_header_crc(&mut bytes, start); + for result in [ + Archive::parse(&bytes), + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + let expected = if usize::BITS == 32 { + // The low u32 payload plus its header already exceeds usize. + "RAR 1.5 block size overflows usize" + } else { + "RAR 1.5 packed file size overflows usize" + }; + assert!( + matches!( + result, + Err(Error::InvalidHeader(message)) if message == expected + ), + "expected {expected}, got {result:?}" + ); + } + } + + #[test] + fn sfx_payload_ranges_agree_for_plain_and_encrypted_headers() { + for encrypted in crate::test_features::encryption_cases() { + let mut builder = crate::Builder::new(if encrypted { + ArchiveVersion::Rar30 + } else { + ArchiveVersion::Rar29 + }) + .store(true) + .password(encrypted.then(|| b"secret".to_vec())) + .header_encryption(encrypted); + builder + .add_bytes( + b"payload".to_vec(), + b"sfx payload bytes".to_vec(), + None, + None, + ) + .unwrap(); + let mut bytes = vec![0; 19]; + bytes.extend_from_slice(&builder.to_bytes().unwrap()); + let options = crate::ArchiveReadOptions::with_optional_password( + encrypted.then_some(&b"secret"[..]), + ); + let memory = Archive::parse_with_options(&bytes, options).unwrap(); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 19, + ArchiveSource::Memory(Arc::from(bytes.clone())), + options, + ) + .unwrap(); + assert_eq!(memory.sfx_offset, 19); + assert_eq!(memory.blocks, seekable.blocks); + for archive in [&memory, &seekable] { + let mut output = Vec::new(); + archive + .files() + .next() + .unwrap() + .write_stored_to(archive, options.password, &mut output) + .unwrap(); + assert_eq!(output, b"sfx payload bytes"); + } + } + } + + #[test] + #[cfg(feature = "recovery")] + fn edited_public_recovery_ranges_keep_typed_refusals() { + let old = Archive::parse(include_bytes!( + "../tests/fixtures/rar15_40/rar250_protect_head_rr1.rar" + )) + .unwrap(); + let mut out_of_source = old.clone(); + let protect = out_of_source + .blocks + .iter_mut() + .find_map(|block| match block { + Block::Protect(protect) => Some(protect), + _ => None, + }) + .unwrap(); + protect.data_range = usize::MAX..usize::MAX; + assert!(matches!( + out_of_source.repair_protect_head(), + Err(Error::TooShort) + )); + let mut overflow = old; + overflow.sfx_offset = usize::MAX; + assert!(matches!( + overflow.repair_protect_head(), + Err(Error::InvalidHeader( + "RAR 2.x protected sector range overflows" + )) + )); + + let mut modern = Archive::parse(include_bytes!( + "../tests/fixtures/rar15_40/rar300/with_recovery_rar300.rar" + )) + .unwrap(); + modern.sfx_offset = 1; + let recovery = modern + .blocks + .iter_mut() + .find_map(|block| match block { + Block::NewSub(sub) if sub.kind == NewSubKind::RecoveryRecord => Some(sub), + _ => None, + }) + .unwrap(); + recovery.file.block.offset = usize::MAX; + assert!(matches!( + modern.repair_protect_head(), + Err(Error::InvalidHeader( + "RAR 3.x recovery protected range overflows" + )) + )); + } + + #[test] + fn comment_decoders_preserve_limits_and_each_cancellation_checkpoint() { + let text = b"checkpoint comment"; + for (version, method, packed) in [ + (15, 0x30, text.to_vec()), + ( + 15, + 0x31, + crate::codec::rar13::unpack15_encode(text).unwrap(), + ), + ( + 20, + 0x31, + crate::codec::rar20::unpack20_encode_literals(text).unwrap(), + ), + ( + 26, + 0x31, + crate::codec::rar20::unpack20_encode_literals(text).unwrap(), + ), + ] { + let mut block = block_header_with(0); + block.head_type = COMM_HEAD; + block.head_size = COMMENT_HEADER_SIZE as u16; + let comment = CommentHeader { + block, + unp_size: text.len() as u16, + unp_ver: version, + method, + comment_crc: (crc32(text) & 0xffff) as u16, + packed_range: 0..packed.len(), + }; + assert_eq!(comment.decode(&packed).unwrap(), text); + let mut limited = crate::output_limit::OutputBudget::new( + crate::ArchiveReadOptions::new().with_max_member_output_bytes(0), + ); + assert!(matches!( + comment + .decode_with_budget(&packed, &mut limited) + .unwrap_err() + .root_cause(), + Error::MemberOutputLimitExceeded { .. } + )); + let mut completed = false; + for checks in 0..128 { + let token = crate::ReadCancellation::new(); + let mut budget = crate::output_limit::OutputBudget::new( + crate::ArchiveReadOptions::new().with_cancellation(&token), + ); + budget.control.cancel_after_checks(checks); + match comment.decode_with_budget(&packed, &mut budget) { + Ok(output) => { + assert_eq!(output, text); + assert!(checks > 2); + completed = true; + break; + } + Err(error) => assert!( + matches!(error.root_cause(), Error::Cancelled), + "version {version}, check {checks}: {error:?}" + ), + } + } + assert!( + completed, + "version {version}: checkpoint sweep did not finish" + ); + } + } + + #[test] + fn file_comment_rejects_a_complete_but_undersized_comment_header() { + let mut file = file_header_with(FHD_COMMENT); + file.file_comment = comment_block(b"note"); + file.file_comment[5..7].copy_from_slice(&12u16.to_le_bytes()); + test_write_header_crc(&mut file.file_comment[..12], 0); + assert!(matches!( + file.file_comment(), + Err(Error::InvalidHeader("RAR 1.5 comment header is too short")) + )); + } + + #[test] + fn directory_callbacks_preserve_failure_and_cancellation_in_both_extractors() { + let mut builder = crate::Builder::new(ArchiveVersion::Rar29); + builder + .add_directory(b"directory".to_vec(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + for parallel in [false, true] { + for cancel in [false, true] { + let token = crate::ReadCancellation::new(); + let mut calls = 0; + let open = |meta: &ExtractedEntryMeta| -> Result> { + calls += 1; + assert!(meta.is_directory); + assert_eq!(meta.name, b"directory"); + if cancel { + token.cancel(); + Ok(Box::new(std::io::sink())) + } else { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "directory refused", + ) + .into()) + } + }; + let options = crate::ArchiveReadOptions::new().with_cancellation(&token); + let error = if parallel { + archive.extract_to_parallel_buffered(options, open) + } else { + archive.extract_to(options, open) + } + .unwrap_err(); + if cancel { + assert!(matches!(error.root_cause(), Error::Cancelled)); + } else { + assert!( + matches!(error.root_cause(), Error::Io(error) if error.kind == std::io::ErrorKind::PermissionDenied && error.message == "directory refused") + ); + } + assert_eq!(calls, 1); + } + } + } + + #[test] + fn block_prefix_truncation_returns_too_short_before_field_decoding() { + let bytes = stored_archive_bytes(b"member", b"payload"); + let file = Archive::parse(&bytes) + .unwrap() + .files() + .next() + .unwrap() + .clone(); + let header = + &bytes[file.block.offset..file.block.offset + usize::from(file.block.head_size)]; + for prefix in 0..header.len() { + assert!(matches!( + parse_block_header(&header[..prefix], 0), + Err(Error::TooShort) + )); + } + assert_eq!( + parse_block_header(header, 0).unwrap().head_size, + file.block.head_size + ); + } + + #[test] + fn incomplete_large_size_fields_have_matching_parser_refusals() { + for head_type in [FILE_HEAD, NEWSUB_HEAD] { + for size in 32u16..=40 { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, 0); + let start = bytes.len(); + let mut header = vec![0; usize::from(size)]; + header[2] = head_type; + header[3..5].copy_from_slice(&(LONG_BLOCK | FHD_LARGE).to_le_bytes()); + header[5..7].copy_from_slice(&size.to_le_bytes()); + header[24] = 29; + header[25] = 0x30; + bytes.extend_from_slice(&header); + test_write_header_crc(&mut bytes, start); + let memory = Archive::parse(&bytes); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ); + if size < 40 { + assert!(matches!(memory, Err(Error::TooShort)), "memory size {size}"); + assert!( + matches!(seekable, Err(Error::TooShort)), + "seekable size {size}" + ); + } else { + assert_eq!(memory.unwrap().blocks, seekable.unwrap().blocks); + } + } + } + } + + #[test] + fn seekable_parser_preserves_failures_at_each_input_operation() { + use std::io::{self, Cursor, Read, Seek, SeekFrom}; + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + + struct FaultReader { + input: Cursor>, + operations: Arc, + fail_at: usize, + cancellation: Option, + } + impl FaultReader { + fn check(&self) -> io::Result<()> { + let operation = self.operations.fetch_add(1, Ordering::Relaxed); + if operation == self.fail_at { + if let Some(token) = &self.cancellation { + token.cancel(); + return Ok(()); + } + Err(io::Error::new( + io::ErrorKind::PermissionDenied, + "input fault", + )) + } else { + Ok(()) + } + } + } + impl Read for FaultReader { + fn read(&mut self, output: &mut [u8]) -> io::Result { + self.check()?; + self.input.read(output) + } + } + impl Seek for FaultReader { + fn seek(&mut self, position: SeekFrom) -> io::Result { + self.check()?; + self.input.seek(position) + } + } + + let mut cases = Vec::new(); + for (target, encrypted) in [ + (ArchiveVersion::Rar15, false), + (ArchiveVersion::Rar20, false), + (ArchiveVersion::Rar29, false), + #[cfg(feature = "encryption")] + (ArchiveVersion::Rar30, true), + #[cfg(feature = "encryption")] + (ArchiveVersion::Rar40, true), + ] { + let mut builder = crate::Builder::new(target) + .store(true) + .comment(Some(b"archive comment".to_vec())) + .password(encrypted.then(|| b"secret".to_vec())) + .header_encryption(encrypted); + builder + .add_bytes(b"member".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + cases.push((builder.to_bytes().unwrap(), encrypted)); + } + // Historical recovery records cannot be produced by the legacy writer. + for bytes in [ + &include_bytes!("../tests/fixtures/rar15_40/rar250_protect_head_rr1.rar")[..], + &include_bytes!("../tests/fixtures/rar15_40/rar300/with_recovery_rar300.rar")[..], + ] { + cases.push((bytes.to_vec(), false)); + } + for (bytes, encrypted) in cases { + let options = if encrypted { + crate::ArchiveReadOptions::with_password(b"secret") + } else { + crate::ArchiveReadOptions::new() + }; + let expected = Archive::parse_with_options(&bytes, options).unwrap(); + let operations = Arc::new(AtomicUsize::new(0)); + let parse = |fail_at, cancellation: Option<&crate::ReadCancellation>| { + operations.store(0, Ordering::Relaxed); + Archive::parse_seekable( + FaultReader { + input: Cursor::new(bytes.clone()), + operations: operations.clone(), + fail_at, + cancellation: cancellation.cloned(), + }, + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + cancellation.map_or_else(|| options, |token| options.with_cancellation(token)), + ) + }; + let archive = parse(usize::MAX, None).unwrap(); + assert_eq!(archive.blocks, expected.blocks); + assert_eq!( + archive.archive_comment().unwrap(), + expected.archive_comment().unwrap() + ); + let count = operations.load(Ordering::Relaxed); + let cancelled = crate::ReadCancellation::new(); + cancelled.cancel(); + assert!(matches!( + parse(usize::MAX, Some(&cancelled)) + .unwrap_err() + .root_cause(), + Error::Cancelled + )); + assert_eq!(operations.load(Ordering::Relaxed), 0); + assert!(count > 0); + for operation in 0..count { + let error = parse(operation, None).unwrap_err(); + match error.root_cause() { + Error::Io(error) => { + assert_eq!(error.kind, io::ErrorKind::PermissionDenied); + assert_eq!(error.message, "input fault"); + } + error => panic!("operation {operation}: {error:?}"), + } + assert_eq!(operations.load(Ordering::Relaxed), operation + 1); + let token = crate::ReadCancellation::new(); + let error = parse(operation, Some(&token)).unwrap_err(); + assert!(matches!(error.root_cause(), Error::Cancelled)); + assert_eq!(operations.load(Ordering::Relaxed), operation + 1); + } + } + } + + #[test] + fn audit_nested_comments_and_time_fields_preserve_legacy_admission() { + let mut time = file_header_with(0); + time.ext_time = 0x0800u16.to_le_bytes().to_vec(); + assert_eq!(time.mtime_refinement(), None); + for (kind, size) in [(COMM_HEAD, 13u16), (COMM_HEAD, 12), (0x7f, 13)] { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, MHD_COMMENT); + let nested_start = bytes.len(); + bytes.extend_from_slice(&comment_block(b"")); + bytes[nested_start + 2] = kind; + bytes[nested_start + 5..nested_start + 7].copy_from_slice(&size.to_le_bytes()); + let main_start = RAR15_SIGNATURE.len(); + let main_len = (bytes.len() - main_start) as u16; + bytes[main_start + 5..main_start + 7].copy_from_slice(&main_len.to_le_bytes()); + test_write_header_crc(&mut bytes[..main_start + 13], main_start); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(std::sync::Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ) + .unwrap(); + assert_eq!( + seekable.blocks.len(), + usize::from(kind == COMM_HEAD && size == 13) + ); + } + assert!(matches!( + Archive::parse_with_options( + RAR15_SIGNATURE, + crate::ArchiveReadOptions::new().with_max_header_bytes(100), + ), + Err(Error::TooShort) + )); + } + + #[test] + fn seekable_comment_unknown_and_truncated_payload_match_memory_parser() { + for (kind, size, add_size) in [ + (COMM_HEAD, 13u16, 0u32), + (0x7f, 11, 0), + (0x7f, 11, 1), + (COMM_HEAD, 12, 0), + ] { + let mut bytes = RAR15_SIGNATURE.to_vec(); + test_write_main_header(&mut bytes, 0); + let start = bytes.len(); + bytes.extend_from_slice(&0u16.to_le_bytes()); + bytes.push(kind); + bytes.extend_from_slice(&0x8000u16.to_le_bytes()); + bytes.extend_from_slice(&size.to_le_bytes()); + bytes.extend_from_slice(&add_size.to_le_bytes()); + bytes.resize(start + usize::from(size), 0); + test_write_header_crc(&mut bytes, start); + let memory = Archive::parse(&bytes); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(std::sync::Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ); + if add_size != 0 || size < 13 && kind == COMM_HEAD { + assert_eq!(memory.unwrap_err().kind(), seekable.unwrap_err().kind()); + } else { + let memory = memory.unwrap(); + let seekable = seekable.unwrap(); + assert_eq!(memory.blocks, seekable.blocks); + } + } + } + + fn test_write_main_header(out: &mut Vec, flags: u16) { + let start = out.len(); + out.extend_from_slice(&0u16.to_le_bytes()); + out.push(MAIN_HEAD); + out.extend_from_slice(&flags.to_le_bytes()); + out.extend_from_slice(&13u16.to_le_bytes()); + out.extend_from_slice(&0u16.to_le_bytes()); + out.extend_from_slice(&0u32.to_le_bytes()); + test_write_header_crc(out, start); + } + + fn test_write_header_crc(out: &mut [u8], start: usize) { + let crc = (crc32(&out[start + 2..]) & 0xffff) as u16; + out[start..start + 2].copy_from_slice(&crc.to_le_bytes()); + } + + fn legacy_auth_block(head_type: u8, head_size: u16) -> Vec { + let mut block = vec![0; head_size as usize]; + block[2] = head_type; + block[5..7].copy_from_slice(&head_size.to_le_bytes()); + block + } + + #[test] + fn rejects_too_short_legacy_auth_blocks_even_without_crc_check() { + assert!(matches!( + parse_block_header(&legacy_auth_block(0x76, 20), 0), + Err(Error::InvalidHeader( + "RAR legacy authenticity block is too short" + )) + )); + assert!(matches!( + parse_block_header(&legacy_auth_block(0x79, 181), 0), + Err(Error::InvalidHeader( + "RAR legacy authenticity block is too short" + )) + )); + } + + #[test] + fn accepts_minimum_legacy_auth_block_sizes_with_bad_crc() { + assert_eq!( + parse_block_header(&legacy_auth_block(0x76, 21), 0) + .unwrap() + .head_size, + 21 + ); + assert_eq!( + parse_block_header(&legacy_auth_block(0x79, 182), 0) + .unwrap() + .head_size, + 182 + ); + } + + #[test] + fn parses_fhd_large_high_size_fields_from_file_header() { + let name = b"large.bin"; + let head_size = 32 + 8 + name.len(); + let mut header = Vec::new(); + header.extend_from_slice(&0u16.to_le_bytes()); + header.push(FILE_HEAD); + header.extend_from_slice(&(LONG_BLOCK | FHD_LARGE).to_le_bytes()); + header.extend_from_slice(&(head_size as u16).to_le_bytes()); + header.extend_from_slice(&0x89ab_cdefu32.to_le_bytes()); + header.extend_from_slice(&0x7654_3210u32.to_le_bytes()); + header.push(3); + header.extend_from_slice(&0x1234_5678u32.to_le_bytes()); + header.extend_from_slice(&0x5a21_0000u32.to_le_bytes()); + header.push(29); + header.push(0x35); + header.extend_from_slice(&(name.len() as u16).to_le_bytes()); + header.extend_from_slice(&0x20u32.to_le_bytes()); + header.extend_from_slice(&1u32.to_le_bytes()); + header.extend_from_slice(&2u32.to_le_bytes()); + header.extend_from_slice(name); + + let block = BlockHeader { + head_crc: 0, + head_type: FILE_HEAD, + flags: LONG_BLOCK | FHD_LARGE, + head_size: head_size as u16, + add_size: Some(0x89ab_cdef), + offset: 0, + }; + let parsed = parse_file_like_header(&header, block, 0); + if usize::BITS == 32 { + assert!(matches!( + parsed, + Err(Error::InvalidHeader( + "RAR 1.5 packed file size overflows usize" + )) + )); + return; + } + let file = parsed.unwrap(); + + assert_eq!(file.pack_size, 0x0000_0001_89ab_cdef); + assert_eq!(file.unp_size, 0x0000_0002_7654_3210); + assert_eq!(file.name, name); + assert_eq!( + file.packed_range, + head_size..head_size + usize::try_from(0x0000_0001_89ab_cdefu64).unwrap() + ); + } + + #[test] + fn file_header_rejects_missing_size_and_overlong_optional_fields() { + let header = [0u8; 32]; + let mut block = block_header_with(LONG_BLOCK); + block.head_size = 31; + assert!(matches!( + parse_file_like_header(&header, block.clone(), 0), + Err(Error::InvalidHeader("RAR 1.5 file header is too short")) + )); + + block.head_size = 32; + block.flags = 0; + assert!(matches!( + parse_file_like_header(&header, block.clone(), 0), + Err(Error::InvalidHeader( + "RAR 1.5 file header is missing packed data size" + )) + )); + + block.flags = LONG_BLOCK; + let mut with_name = header; + with_name[26..28].copy_from_slice(&1u16.to_le_bytes()); + assert!(matches!( + parse_file_like_header(&with_name, block.clone(), 0), + Err(Error::InvalidHeader( + "RAR 1.5 file name extends beyond header" + )) + )); + + block.flags |= FHD_SALT; + assert!(matches!( + parse_file_like_header(&header, block, 0), + Err(Error::InvalidHeader( + "RAR 1.5 salt extends beyond file header" + )) + )); + } + + #[test] + fn fhd_large_archive_extent_uses_high_packed_size_without_underflowing() { + let name = b"large-zero-low.bin"; + let head_size = 32 + 8 + name.len(); + let mut archive = Vec::from(RAR15_SIGNATURE); + test_write_main_header(&mut archive, 0); + + let start = archive.len(); + archive.extend_from_slice(&0u16.to_le_bytes()); + archive.push(FILE_HEAD); + archive.extend_from_slice(&(LONG_BLOCK | FHD_LARGE).to_le_bytes()); + archive.extend_from_slice(&(head_size as u16).to_le_bytes()); + archive.extend_from_slice(&0u32.to_le_bytes()); + archive.extend_from_slice(&0u32.to_le_bytes()); + archive.push(3); + archive.extend_from_slice(&0u32.to_le_bytes()); + archive.extend_from_slice(&0x5a21_0000u32.to_le_bytes()); + archive.push(29); + archive.push(0x35); + archive.extend_from_slice(&(name.len() as u16).to_le_bytes()); + archive.extend_from_slice(&0x20u32.to_le_bytes()); + archive.extend_from_slice(&1u32.to_le_bytes()); + archive.extend_from_slice(&1u32.to_le_bytes()); + archive.extend_from_slice(name); + test_write_header_crc(&mut archive, start); + + let result = Archive::parse(&archive); + if usize::BITS == 32 { + assert!( + matches!( + result, + Err(Error::InvalidHeader( + "RAR 1.5 packed file size overflows usize" + )) + ), + "{result:?}" + ); + } else { + assert!(matches!(result, Err(Error::TooShort)), "{result:?}"); + } + } + + fn block_header_with(flags: u16) -> BlockHeader { + BlockHeader { + head_crc: 0, + head_type: FILE_HEAD, + flags, + head_size: 32, + add_size: None, + offset: 0, + } + } + + fn file_header_with(flags: u16) -> FileHeader { + FileHeader { + block: block_header_with(flags), + pack_size: 0, + unp_size: 0, + host_os: 0, + file_crc: 0, + file_time: 0, + unp_ver: 29, + method: 0x30, + name: b"entry".to_vec(), + unicode_name: None, + attr: 0, + salt: None, + file_comment: Vec::new(), + ext_time: Vec::new(), + packed_range: 0..0, + } + } + + fn main_header_with(flags: u16) -> MainHeader { + MainHeader { + head_crc: 0, + flags, + head_size: 13, + reserved1: 0, + reserved2: 0, + encrypt_version: None, + } + } + + #[test] + fn main_header_predicates_match_each_flag_bit() { + let cases = [ + (MHD_VOLUME, MainHeader::is_volume as fn(&MainHeader) -> bool), + (MHD_COMMENT, MainHeader::has_archive_comment), + (MHD_SOLID, MainHeader::is_solid), + (MHD_NEWNUMBERING, MainHeader::uses_new_numbering), + (MHD_PROTECT, MainHeader::has_recovery_record), + (MHD_PASSWORD, MainHeader::has_encrypted_headers), + (MHD_FIRSTVOLUME, MainHeader::is_first_volume), + ]; + let zero = main_header_with(0); + for (bit, predicate) in cases { + assert!( + !predicate(&zero), + "expected false when bit {bit:#x} is clear" + ); + let one = main_header_with(bit); + assert!(predicate(&one), "expected true when bit {bit:#x} is set"); + } + } + + #[test] + fn file_header_flag_predicates_track_each_bit() { + let cases = [ + ( + FHD_SPLIT_BEFORE, + FileHeader::is_split_before as fn(&FileHeader) -> bool, + ), + (FHD_SPLIT_AFTER, FileHeader::is_split_after), + (FHD_PASSWORD, FileHeader::is_encrypted), + (FHD_SOLID, FileHeader::is_solid), + (FHD_EXTTIME, FileHeader::has_ext_time), + ]; + let zero = file_header_with(0); + for (bit, predicate) in cases { + assert!( + !predicate(&zero), + "expected false on FileHeader for bit {bit:#x}" + ); + let one = file_header_with(bit); + assert!( + predicate(&one), + "expected true on FileHeader for bit {bit:#x}" + ); + } + + let directory = file_header_with(FHD_DIRECTORY_MASK); + assert!(directory.is_directory()); + assert!(!file_header_with(0).is_directory()); + + let stored = file_header_with(0); + assert!(stored.is_stored()); + let mut packed = file_header_with(0); + packed.method = 0x33; + assert!(!packed.is_stored()); + } + + /// A stored comment block holding `text`, as it sits inside a file header. + fn comment_block(text: &[u8]) -> Vec { + let head_size = (COMMENT_HEADER_SIZE + text.len()) as u16; + let mut block = vec![0, 0, COMM_HEAD, 0, 0]; + block.extend_from_slice(&head_size.to_le_bytes()); + block.extend_from_slice(&(text.len() as u16).to_le_bytes()); + block.push(15); + block.push(0x30); + block.extend_from_slice(&((crc32(text) & 0xffff) as u16).to_le_bytes()); + block.extend_from_slice(text); + let crc = (crc32(&block[2..COMMENT_HEADER_SIZE]) & 0xffff) as u16; + block[..2].copy_from_slice(&crc.to_le_bytes()); + block + } + + #[test] + fn file_header_comment_decodes_the_nested_comment_block() { + let mut without_flag = file_header_with(0); + without_flag.file_comment = comment_block(b"abc"); + assert!(!without_flag.has_file_comment()); + assert_eq!(without_flag.file_comment().unwrap(), None); + + let mut with_flag = file_header_with(FHD_COMMENT); + with_flag.file_comment = comment_block(b"hey"); + assert!(with_flag.has_file_comment()); + assert_eq!(with_flag.file_comment().unwrap().unwrap(), b"hey"); + + let mut empty_flagged = file_header_with(FHD_COMMENT); + empty_flagged.file_comment.clear(); + assert!(!empty_flagged.has_file_comment()); + + let mut truncated = file_header_with(FHD_COMMENT); + truncated.file_comment = comment_block(b"hey"); + truncated.file_comment.pop(); + assert!(matches!(truncated.file_comment(), Err(Error::TooShort))); + + let mut corrupt = file_header_with(FHD_COMMENT); + corrupt.file_comment = comment_block(b"hey"); + *corrupt.file_comment.last_mut().unwrap() = b'!'; + assert!(matches!( + corrupt.file_comment(), + Err(Error::CrcMismatch { .. }) + )); + + // The bare size and text RAR 1.3 uses, which this writer emitted by + // mistake until 0.7. + let mut bare_size = file_header_with(FHD_COMMENT); + bare_size.file_comment = vec![3, 0, b'h', b'e', b'y']; + assert!(bare_size.file_comment().is_err()); + } + + #[test] + fn file_header_comment_rejects_wrong_block_type_and_unsupported_codec() { + let mut wrong_type = file_header_with(FHD_COMMENT); + wrong_type.file_comment = comment_block(b"note"); + wrong_type.file_comment[2] = FILE_HEAD; + test_write_header_crc(&mut wrong_type.file_comment, 0); + assert!(matches!( + wrong_type.file_comment(), + Err(Error::InvalidHeader( + "RAR 1.5 file comment is not a comment block" + )) + )); + + let mut unsupported = file_header_with(FHD_COMMENT); + unsupported.file_comment = comment_block(b"note"); + unsupported.file_comment[9] = 29; + unsupported.file_comment[10] = 0x33; + let crc = (crc32(&unsupported.file_comment[2..COMMENT_HEADER_SIZE]) & 0xffff) as u16; + unsupported.file_comment[..2].copy_from_slice(&crc.to_le_bytes()); + let result = unsupported.file_comment(); + assert!( + matches!( + result, + Err(Error::UnsupportedCompression { + unpack_version: 29, + method: 0x33, + .. + }) + ), + "{result:?}" + ); + } + + #[test] + fn stored_file_comment_rejects_declared_size_mismatch() { + let mut header = file_header_with(FHD_COMMENT); + header.file_comment = comment_block(b"note"); + header.file_comment[7..9].copy_from_slice(&3u16.to_le_bytes()); + let crc = (crc32(&header.file_comment[2..COMMENT_HEADER_SIZE]) & 0xffff) as u16; + header.file_comment[..2].copy_from_slice(&crc.to_le_bytes()); + + assert!(matches!( + header.file_comment(), + Err(Error::InvalidHeader( + "RAR 1.5 stored comment has mismatched packed and unpacked sizes" + )) + )); + } + + #[test] + fn file_header_name_metadata_and_crc_helpers_describe_entry() { + let mut header = file_header_with(0); + header.name = b"r\xc3\xa9sum\xc3\xa9.txt".to_vec(); + header.file_crc = crc32(b"hello"); + header.attr = 0x20; + header.host_os = 3; + header.file_time = 0x5a21_0000; + + assert_eq!(header.name_bytes(), b"r\xc3\xa9sum\xc3\xa9.txt"); + assert_eq!(header.name_lossy(), "résumé.txt"); + let meta = header.metadata(); + assert_eq!(meta.name, header.name); + assert_eq!(meta.attr, 0x20); + assert_eq!(meta.host_os, 3); + assert_eq!(meta.file_time, 0x5a21_0000); + assert!(!meta.is_directory); + + header.verify_crc32(b"hello").unwrap(); + match header.verify_crc32(b"different") { + Err(Error::Crc32Mismatch { expected, actual }) => { + assert_eq!(expected, header.file_crc); + assert_ne!(actual, expected); + } + other => panic!("expected Crc32Mismatch, got {other:?}"), + } + + let directory = file_header_with(FHD_DIRECTORY_MASK); + assert!(directory.metadata().is_directory); + + // Garbage bytes still produce a String through lossy decoding. + let mut garbage = file_header_with(0); + garbage.name = vec![0xff, 0xfe, b'/', 0x80, b'x']; + let lossy = garbage.name_lossy(); + assert!(lossy.ends_with("/\u{fffd}x"), "got {lossy:?}"); + } + + #[test] + fn newsub_header_name_lossy_delegates_to_inner_file_header() { + let mut file = file_header_with(0); + file.name = b"CMT".to_vec(); + let sub = NewSubHeader { + file, + kind: NewSubKind::ArchiveComment, + }; + assert_eq!(sub.name_lossy(), "CMT"); + assert_eq!(sub.name_bytes(), b"CMT"); + } + + #[test] + fn writer_options_constructor_and_default_match_documented_targets() { + let default = WriterOptions::default(); + assert_eq!(default.target, ArchiveVersion::Rar15); + assert_eq!(default.features, FeatureSet::store_only()); + + let explicit = WriterOptions::new(ArchiveVersion::Rar20, FeatureSet::store_only()); + assert_eq!(explicit.target, ArchiveVersion::Rar20); + assert_eq!(explicit.features, FeatureSet::store_only()); + } + + fn stored_archive_bytes(name: &[u8], data: &[u8]) -> Vec { + write_stored_archive( + &[StoredEntry { + name, + data, + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }], + WriterOptions::default(), + ) + .unwrap() + } + + fn preservation_seed(target: ArchiveVersion) -> Archive { + let mut builder = crate::Builder::new(target).store(true); + builder + .add_bytes(b"entry".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + archive + } + + fn preservation_file(archive: &mut Archive) -> &mut FileHeader { + archive + .blocks + .iter_mut() + .find_map(|block| match block { + Block::File(file) => Some(file), + _ => None, + }) + .unwrap() + } + + fn preservation_comment_seed(target: ArchiveVersion) -> Archive { + let mut builder = crate::Builder::new(target) + .store(true) + .comment(Some(b"archive note".to_vec())); + builder + .add_bytes(b"entry".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"entry", Some(b"member note".to_vec())) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + archive + } + + #[test] + fn preservation_old_comment_envelopes_refuse_unsupported_metadata() { + let seed = preservation_comment_seed(ArchiveVersion::Rar20); + let comment = seed + .blocks + .iter() + .find_map(|block| match block { + Block::Comment(comment) => Some(comment), + _ => None, + }) + .unwrap(); + assert!(comment.supports_rewrite()); + type Edit = fn(&mut CommentHeader); + let edits: &[Edit] = &[ + |c| c.block.head_type = FILE_HEAD, + |c| c.block.flags = 1, + |c| c.block.add_size = Some(0), + |c| c.block.head_size = 12, + |c| c.unp_size = u16::MAX, + |c| c.method = 0x36, + |c| { + c.method = 0x31; + c.unp_ver = 29; + }, + ]; + for edit in edits { + let mut edited = comment.clone(); + edit(&mut edited); + assert!(!edited.supports_rewrite(), "{edited:?}"); + } + for version in [15, 20, 26] { + let mut supported = comment.clone(); + supported.method = 0x35; + supported.unp_ver = version; + assert!(supported.supports_rewrite()); + } + } + + #[test] + fn preservation_archive_and_member_comments_report_layout_and_envelope_refusals() { + let standalone = preservation_comment_seed(ArchiveVersion::Rar20); + // Standalone comments remain preservable even without MHD_COMMENT. + let mut unflagged = standalone.clone(); + unflagged.main.flags &= !MHD_COMMENT; + assert!(unflagged.rewrite_preservation_issues().is_empty()); + let Block::Comment(comment) = &standalone.blocks[0] else { + unreachable!() + }; + let mut bytes = standalone + .source + .read_range(0..standalone.source.len().unwrap()) + .unwrap(); + let start = RAR15_SIGNATURE.len(); + let size = MAIN_HEADER_SIZE as u16 + comment.block.head_size; + bytes[start + 3..start + 5] + .copy_from_slice(&(standalone.main.flags | MHD_COMMENT).to_le_bytes()); + bytes[start + 5..start + 7].copy_from_slice(&size.to_le_bytes()); + test_write_header_crc(&mut bytes[start..start + MAIN_HEADER_SIZE], 0); + let seed = Archive::parse_owned(bytes).unwrap(); + assert!(seed.rewrite_preservation_issues().is_empty()); + type Edit = fn(&mut Archive); + let cases: &[(&str, Edit)] = &[ + ("legacy main header settings", |a| { + a.main.flags &= !MHD_COMMENT + }), + ("legacy main header settings", |a| { + a.main.head_size = MAIN_HEADER_SIZE as u16 + 1 + }), + ("legacy main header settings", |a| { + if let Block::Comment(c) = &mut a.blocks[0] { + c.block.offset += 1; + } + }), + ("archive comment location", |a| { + let comment = a.blocks.remove(0); + a.blocks.push(comment); + }), + ("archive comment location", |a| { + if let Block::Comment(c) = &mut a.blocks[0] { + c.method = 0x36; + } + }), + ("duplicate legacy archive comments", |a| { + a.blocks.insert(1, a.blocks[0].clone()) + }), + ("file comments have unsupported", |a| { + preservation_file(a).file_comment.clear() + }), + ("file comments have unsupported", |a| { + let c = &mut preservation_file(a).file_comment; + c[10] = 0x36; + test_write_header_crc(&mut c[..COMMENT_HEADER_SIZE], 0); + }), + ("file comments have unsupported", |a| { + preservation_file(a).file_comment.push(0) + }), + ( + "embedded legacy file comments with encrypted headers", + |a| a.main.flags |= MHD_PASSWORD, + ), + ]; + for &(expected, edit) in cases { + let mut archive = seed.clone(); + edit(&mut archive); + let issues = archive.rewrite_preservation_issues(); + assert!( + issues.iter().any(|issue| issue.contains(expected)), + "{expected}: {issues:?}" + ); + } + } + + #[test] + fn preservation_cmt_services_refuse_every_unsupported_metadata_field() { + let seed = preservation_comment_seed(ArchiveVersion::Rar30); + let index = seed + .blocks + .iter() + .position(|block| { + matches!(block, + Block::NewSub(sub) if sub.kind == NewSubKind::ArchiveComment) + }) + .unwrap(); + type Edit = fn(&mut FileHeader); + let edits: &[Edit] = &[ + |f| f.block.flags |= FHD_DIRECTORY_MASK, + |f| f.block.flags |= FHD_PASSWORD, + |f| f.block.flags |= 0x0800, + |f| f.block.head_size += 1, + |f| f.unp_ver = 20, + |f| f.method = 0x36, + |f| f.attr = 1, + |f| f.host_os = 4, + |f| f.unp_size = u64::from(u32::MAX) + 1, + ]; + for edit in edits { + let mut archive = seed.clone(); + let Block::NewSub(sub) = &mut archive.blocks[index] else { + unreachable!() + }; + edit(&mut sub.file); + assert!(archive + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy CMT service metadata or encryption"))); + } + let mut late = seed.clone(); + let comment = late.blocks.remove(index); + late.blocks.push(comment); + assert!(late + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy CMT service metadata"))); + let mut duplicate = seed.clone(); + duplicate + .blocks + .insert(index, duplicate.blocks[index].clone()); + assert!(duplicate + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("duplicate legacy archive comments"))); + let mut unknown = seed; + let Block::NewSub(sub) = &mut unknown.blocks[index] else { + unreachable!() + }; + sub.kind = NewSubKind::Unknown(b"future".to_vec()); + assert!(unknown + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy recovery or other service records"))); + } + + #[test] + #[cfg(feature = "encryption")] + fn preservation_accepts_encrypted_cmt_with_its_declared_salt() { + let mut builder = crate::Builder::new(ArchiveVersion::Rar30) + .store(true) + .comment(Some(b"archive note".to_vec())) + .archive_comment_password(Some(b"secret".to_vec())); + builder + .add_bytes(b"entry".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + let comment = archive + .new_subs() + .find(|sub| sub.kind == NewSubKind::ArchiveComment) + .unwrap(); + assert!(comment.file.is_encrypted()); + assert!(comment.file.salt.is_some()); + assert!(archive.rewrite_preservation_issues().is_empty()); + } + + #[test] + fn preservation_accepts_unicode_names_and_consistent_compressed_solid_members() { + let mut builder = crate::Builder::new(ArchiveVersion::Rar29) + .solid(true) + .compression_level(Some(1)); + for name in [b"entry".as_slice(), b"second"] { + builder + .add_bytes(name.to_vec(), b"payload".repeat(50), None, None) + .unwrap(); + } + builder + .set_legacy_unicode_name( + b"entry", + crate::filename::encode_legacy_unicode(b"entry").unwrap(), + ) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.main.is_solid()); + assert!(archive.files().next().unwrap().unicode_name.is_some()); + assert!(archive.files().nth(1).unwrap().is_solid()); + assert!(archive.rewrite_preservation_issues().is_empty()); + } + + #[test] + fn preservation_end_records_require_complete_supported_layout() { + let seed = preservation_seed(ArchiveVersion::Rar29); + let mut bytes = seed + .source + .read_range(0..seed.source.len().unwrap()) + .unwrap(); + let start = bytes.len(); + bytes.extend([0, 0, ENDARC_HEAD, 0, 0, 7, 0]); + test_write_header_crc(&mut bytes[start..], 0); + let seed = Archive::parse_owned(bytes).unwrap(); + assert!(seed.rewrite_preservation_issues().is_empty()); + type Edit = fn(&mut BlockHeader); + let edits: &[Edit] = &[ + |e| e.flags = 1, + |e| e.head_size = 8, + |e| e.add_size = Some(0), + |e| e.offset += 1, + |e| e.offset = usize::MAX, + ]; + for edit in edits { + let mut archive = seed.clone(); + let Some(Block::End(end)) = archive.blocks.last_mut() else { + unreachable!() + }; + edit(end); + assert!(archive + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy end header metadata or trailing bytes"))); + } + let mut encrypted_header = seed.clone(); + encrypted_header.main.flags |= MHD_PASSWORD; + let Some(Block::End(end)) = encrypted_header.blocks.last_mut() else { + unreachable!() + }; + // Header encryption requires salt plus a padded AES header block. + assert_eq!(end.offset + 7, encrypted_header.source.len().unwrap()); + assert!(encrypted_header + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy end header metadata or trailing bytes"))); + let mut overflow = seed; + overflow.sfx_offset = usize::MAX; + assert!(overflow + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("legacy end header metadata or trailing bytes"))); + } + + #[test] + fn preservation_accepts_empty_non_solid_directories() { + for target in [ + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ] { + let mut builder = crate::Builder::new(target); + builder + .add_directory(b"empty".to_vec(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + let file = archive.files().next().unwrap(); + assert!(file.is_directory()); + assert_eq!((file.pack_size, file.unp_size), (0, 0)); + assert!(!file.is_solid()); + let issues = archive.rewrite_preservation_issues(); + assert!(issues.is_empty(), "{target:?}: {issues:?}"); + } + } + + #[test] + fn preservation_preflight_reports_public_main_header_inconsistencies() { + let seed = preservation_seed(ArchiveVersion::Rar29); + type Edit = fn(&mut Archive); + let cases: &[(&str, Edit)] = &[ + ("legacy volume layout", |a| a.main.flags |= MHD_VOLUME), + ("legacy recovery records", |a| a.main.flags |= MHD_PROTECT), + ("legacy main header settings", |a| { + a.main.flags |= MHD_NEWNUMBERING + }), + ("legacy main header settings", |a| a.main.head_size += 1), + ("legacy main header settings", |a| a.main.reserved1 = 1), + ("legacy main header settings", |a| a.main.reserved2 = 1), + ("empty legacy archive", |a| { + a.blocks.retain(|b| !matches!(b, Block::File(_))) + }), + ("missing or malformed legacy archive comment", |a| { + a.main.flags |= MHD_COMMENT + }), + ]; + // These fields are public: a caller can edit a parsed archive before + // preflight. Every such refusal must remain observable and specific. + for &(expected, edit) in cases { + let mut archive = seed.clone(); + edit(&mut archive); + let issues = archive.rewrite_preservation_issues(); + assert!( + issues.iter().any(|issue| issue.contains(expected)), + "{expected}: {issues:?}" + ); + } + } + + #[test] + fn preservation_preflight_reports_public_member_metadata_inconsistencies() { + let seed = preservation_seed(ArchiveVersion::Rar29); + type Edit = fn(&mut FileHeader); + let cases: &[(&str, Edit)] = &[ + ("requires unpacker 21", |f| f.unp_ver = 21), + ("encryption salt settings", |f| { + f.unp_ver = 20; + f.salt = Some([0; 8]); + }), + ("encryption salt settings", |f| { + f.block.flags |= FHD_PASSWORD + }), + ("Pre-RAR2.9 extended timestamps", |f| { + f.unp_ver = 20; + f.block.flags |= FHD_EXTTIME; + f.ext_time = vec![0, 0]; + }), + ("extended timestamps are incomplete", |f| { + f.block.flags |= FHD_EXTTIME; + f.ext_time = vec![0]; + }), + ("legacy host metadata", |f| f.host_os = 4), + ("solid dependency without archive solid flag", |f| { + f.block.flags |= FHD_SOLID + }), + ("legacy file flags or extra metadata", |f| { + f.block.flags |= 0x0800 + }), + ("legacy file flags or extra metadata", |f| { + f.block.head_size += 1 + }), + ("unsupported legacy method or size", |f| f.method = 0x36), + ("unsupported legacy method or size", |f| { + f.unp_size = u64::from(u32::MAX) + 1 + }), + ("unsupported legacy directory payload", |f| { + f.block.flags |= FHD_DIRECTORY_MASK + }), + ("unsupported legacy directory payload", |f| { + f.block.flags |= FHD_DIRECTORY_MASK; + f.pack_size = 0; + }), + ("unsupported legacy directory payload", |f| { + f.block.flags |= FHD_DIRECTORY_MASK | FHD_SOLID; + f.pack_size = 0; + f.unp_size = 0; + }), + ("malformed or unsupported legacy Unicode name", |f| { + f.unicode_name = Some(b"bad".to_vec()) + }), + ]; + for &(expected, edit) in cases { + let mut archive = seed.clone(); + edit(preservation_file(&mut archive)); + let issues = archive.rewrite_preservation_issues(); + assert!( + issues.iter().any(|issue| issue.contains(expected)), + "{expected}: {issues:?}" + ); + } + let mut rar15 = preservation_seed(ArchiveVersion::Rar15); + preservation_file(&mut rar15).host_os = 3; + assert!(rar15 + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("RAR1.5 Unix metadata"))); + let mut rar15 = preservation_seed(ArchiveVersion::Rar15); + preservation_file(&mut rar15).unicode_name = + Some(crate::filename::encode_legacy_unicode(b"entry").unwrap()); + assert!(rar15 + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("malformed or unsupported legacy Unicode name"))); + } + + #[test] + fn flagged_but_missing_file_comment_does_not_hide_the_member() { + let mut bytes = stored_archive_bytes(b"entry", b"payload"); + let file_start = RAR15_SIGNATURE.len() + MAIN_HEADER_SIZE; + let head_size = usize::from(u16::from_le_bytes( + bytes[file_start + 5..file_start + 7].try_into().unwrap(), + )); + let flags = u16::from_le_bytes(bytes[file_start + 3..file_start + 5].try_into().unwrap()) + | FHD_COMMENT; + bytes[file_start + 3..file_start + 5].copy_from_slice(&flags.to_le_bytes()); + test_write_header_crc(&mut bytes[file_start..file_start + head_size], 0); + + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + assert_eq!(file.name, b"entry"); + assert!(!file.has_file_comment()); + assert_eq!(file.packed_data(&archive).unwrap(), b"payload"); + } + + #[test] + #[cfg(feature = "recovery")] + fn repaired_legacy_volume_keeps_missing_end_block_and_nonzero_trailer() { + let mut bytes = stored_archive_bytes(b"entry", b"payload"); + let end_start = bytes.len(); + bytes.extend_from_slice(&[0, 0, ENDARC_HEAD, 0, 0, 7, 0]); + test_write_header_crc(&mut bytes[end_start..], 0); + let archive = Archive::parse(&bytes).unwrap(); + let end = archive + .blocks + .iter() + .find_map(|block| match block { + Block::End(end) => Some(end), + _ => None, + }) + .unwrap(); + let mut without_end = bytes[..end.offset].to_vec(); + assert!(Archive::parse(&without_end) + .unwrap() + .files() + .next() + .is_some()); + assert_eq!( + truncate_repaired_rev3_volume(without_end.clone()), + without_end + ); + + without_end = bytes; + without_end.extend_from_slice(b"not padding"); + assert_eq!( + truncate_repaired_rev3_volume(without_end.clone()), + without_end + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_header_readers_reject_short_prefixes_and_declared_headers() { + let mut cache = EncryptedHeaderCipherCache::default(); + for size in [0u16, 6, 17, 65] { + let mut plain = [0; 16]; + plain[5..7].copy_from_slice(&size.to_le_bytes()); + cache + .cipher(b"pw", [0; 8]) + .unwrap() + .encrypt_in_place(&mut plain) + .unwrap(); + let mut bytes = vec![0; 8]; + bytes.extend_from_slice(&plain); + let options = crate::ArchiveReadOptions::new(); + let memory = decrypt_encrypted_header_at( + &bytes, + 0, + b"pw", + &mut cache, + &mut crate::parse_budget::ParseBudget::new(options), + ) + .err() + .unwrap(); + let seekable = read_encrypted_header_at( + &mut std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + 0, + b"pw", + &mut cache, + &mut crate::parse_budget::ParseBudget::new(options), + ) + .err() + .unwrap(); + if size < 7 { + assert!(matches!( + memory, + Error::InvalidHeader("RAR 1.5 block header is too short") + )); + assert!(matches!( + seekable, + Error::InvalidHeader("RAR 1.5 block header is too short") + )); + } else { + assert!(matches!(memory, Error::TooShort)); + assert!(matches!(seekable, Error::TooShort)); + } + } + for available in [0, 7, 8, 23] { + let bytes = vec![0; available]; + assert!(matches!( + decrypt_encrypted_header_at( + &bytes, + 0, + b"pw", + &mut cache, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()) + ), + Err(Error::TooShort) + )); + assert!(matches!( + read_encrypted_header_at( + &mut std::io::Cursor::new(&bytes), + available as u64, + 0, + 0, + b"pw", + &mut cache, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()) + ), + Err(Error::TooShort) + )); + } + } + + #[test] + fn file_comment_crc_boundary_includes_large_sizes_name_and_salt() { + let mut short = vec![0; 11]; + short[2] = FILE_HEAD; + short[3..5].copy_from_slice(&(LONG_BLOCK | FHD_COMMENT).to_le_bytes()); + short[5..7].copy_from_slice(&11u16.to_le_bytes()); + assert!(matches!( + parse_block_header(&short, 0), + Err(Error::TooShort) + )); + for flags in [0, FHD_LARGE, FHD_SALT, FHD_LARGE | FHD_SALT] { + let name_start = 32 + if flags & FHD_LARGE != 0 { 8 } else { 0 }; + let crc_end = name_start + 4 + if flags & FHD_SALT != 0 { 8 } else { 0 }; + let mut header = vec![0; crc_end + 13]; + header[2] = FILE_HEAD; + header[3..5].copy_from_slice(&(LONG_BLOCK | FHD_COMMENT | flags).to_le_bytes()); + let size = header.len() as u16; + header[5..7].copy_from_slice(&size.to_le_bytes()); + header[24] = 29; + header[25] = 0x30; + header[26..28].copy_from_slice(&4u16.to_le_bytes()); + header[name_start..name_start + 4].copy_from_slice(b"name"); + header[crc_end + 2] = COMM_HEAD; + header[crc_end + 5..crc_end + 7].copy_from_slice(&13u16.to_le_bytes()); + assert_eq!(file_header_comment_crc_end(&header, 0).unwrap(), crc_end); + let crc = (crc32(&header[2..crc_end]) & 0xffff) as u16; + header[..2].copy_from_slice(&crc.to_le_bytes()); + let block = parse_block_header(&header, 0).unwrap(); + let file = parse_file_like_header(&header, block, 0).unwrap(); + assert_eq!(file.name, b"name"); + assert_eq!(file.file_comment.len(), 13); + } + } + + #[test] + fn main_encrypt_version_cannot_borrow_a_byte_from_the_next_header() { + let mut bytes = stored_archive_bytes(b"file", b"payload"); + let main_start = RAR15_SIGNATURE.len(); + let main_end = main_start + MAIN_HEADER_SIZE; + assert_eq!( + read_u16(&bytes, main_start + 5).unwrap(), + MAIN_HEADER_SIZE as u16 + ); + let flags = read_u16(&bytes, main_start + 3).unwrap() | MHD_ENCRYPTVER; + bytes[main_start + 3..main_start + 5].copy_from_slice(&flags.to_le_bytes()); + let crc = (crc32(&bytes[main_start + 2..main_end]) & 0xffff) as u16; + bytes[main_start..main_start + 2].copy_from_slice(&crc.to_le_bytes()); + let options = crate::ArchiveReadOptions::new(); + assert!(matches!( + Archive::parse_with_options(&bytes, options), + Err(Error::TooShort) + )); + assert!(matches!( + Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + options + ), + Err(Error::TooShort) + )); + } + + #[test] + fn memory_and_seekable_parsers_reject_invalid_file_header_lengths() { + let original = stored_archive_bytes(b"lengths.txt", b"payload"); + let file_offset = Archive::parse(&original) + .unwrap() + .files() + .next() + .unwrap() + .block + .offset; + + for (head_size, truncated) in [(6u16, false), (u16::MAX, true)] { + let mut bytes = original.clone(); + bytes[file_offset + 5..file_offset + 7].copy_from_slice(&head_size.to_le_bytes()); + + for options in [ + crate::ArchiveReadOptions::default(), + crate::ArchiveReadOptions::default().with_max_header_bytes(u64::MAX), + ] { + let memory = Archive::parse_with_options(&bytes, options).unwrap_err(); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone().into_boxed_slice())), + options, + ) + .unwrap_err(); + + if truncated { + assert!(matches!(memory, Error::TooShort)); + assert!(matches!(seekable, Error::TooShort)); + } else { + assert!(matches!(memory, Error::InvalidHeader(_))); + assert!(matches!(seekable, Error::InvalidHeader(_))); + } + } + } + } + + #[test] + fn parsers_reject_a_validly_checksummed_non_main_header() { + let mut bytes = stored_archive_bytes(b"entry.txt", b"payload"); + let main_offset = RAR15_SIGNATURE.len(); + let main_size = + u16::from_le_bytes([bytes[main_offset + 5], bytes[main_offset + 6]]) as usize; + bytes[main_offset + 2] = FILE_HEAD; + test_write_header_crc(&mut bytes[main_offset..main_offset + main_size], 0); + + let memory = Archive::parse(&bytes).unwrap_err(); + let seekable = Archive::parse_seekable( + std::io::Cursor::new(&bytes), + bytes.len() as u64, + 0, + ArchiveSource::Memory(Arc::from(bytes.clone().into_boxed_slice())), + crate::ArchiveReadOptions::default(), + ) + .unwrap_err(); + assert!(matches!( + memory, + Error::InvalidHeader("RAR 1.5 main header is missing") + )); + assert!(matches!( + seekable, + Error::InvalidHeader("RAR 1.5 main header is missing") + )); + } + + #[test] + fn archive_parse_owned_consumes_buffer_without_changing_dispatch() { + let bytes = stored_archive_bytes(b"owned.txt", b"hello rar15 owned"); + let archive = Archive::parse_owned(bytes.clone()).unwrap(); + assert_eq!(archive.files().count(), 1); + let file = archive.files().next().unwrap(); + assert_eq!(file.name, b"owned.txt"); + + // Default ArchiveReadOptions delegate also drives the same code path. + let with_options = + Archive::parse_owned_with_options(bytes.clone(), crate::ArchiveReadOptions::default()) + .unwrap(); + assert_eq!(with_options.files().count(), 1); + + let no_password = Archive::parse_owned_with_password(bytes, None).unwrap(); + assert_eq!(no_password.files().count(), 1); + } + + #[test] + #[cfg(feature = "encryption")] + fn archive_parse_owned_with_password_unlocks_encrypted_archive() { + let features = FeatureSet::store_only(); + let bytes = write_stored_archive( + &[StoredEntry { + name: b"locked.txt", + data: b"encrypted owned payload", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"pw"), + file_comment: None, + }], + WriterOptions { + target: ArchiveVersion::Rar20, + features, + compression_level: None, + dictionary_size: None, + method: Rar29Method::Auto, + archive_comment_metadata: None, + }, + ) + .unwrap(); + + let archive = Archive::parse_owned_with_password(bytes, Some(b"pw")).unwrap(); + let file = archive.files().next().unwrap(); + assert!(file.is_encrypted()); + } + + #[test] + fn file_header_write_packed_data_streams_through_writer() { + let payload = b"write_packed_data direct dump"; + let bytes = stored_archive_bytes(b"dump.bin", payload); + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + + let mut sink = Vec::new(); + file.write_packed_data(&archive, &mut sink).unwrap(); + assert_eq!(sink, payload); + } + + #[test] + fn direct_stored_writer_rejects_inconsistent_and_short_payloads() { + let bytes = stored_archive_bytes(b"entry", b"payload"); + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + + let mut inconsistent = file.clone(); + inconsistent.unp_size += 1; + let mut output = Vec::new(); + assert!(matches!( + inconsistent.write_to(&archive, None, &mut output), + Err(Error::InvalidHeader( + "RAR 1.5 stored file has mismatched packed and unpacked sizes" + )) + )); + assert!(output.is_empty()); + + // A valid header can still name a short range when its source is damaged. + let mut short = file.clone(); + short.packed_range.end -= 1; + assert!(matches!( + short.write_to(&archive, None, &mut output), + Err(Error::InvalidHeader( + "RAR 1.5 stored file ended before unpacked size" + )) + )); + assert_eq!(output, b"payloa"); + + let mut directory = file.clone(); + directory.attr |= 0x10; + let mut output = Vec::new(); + directory.write_to(&archive, None, &mut output).unwrap(); + assert!(output.is_empty()); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_stored_workspace_refusal_keeps_resource_error() { + let bytes = write_stored_archive( + &[StoredEntry { + name: b"entry", + data: b"payload", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: Some(b"secret"), + file_comment: None, + }], + WriterOptions::new(ArchiveVersion::Rar30, FeatureSet::store_only()), + ) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + let mut output = Vec::new(); + let error = file + .write_stored_with_allowance( + &archive, + Some(b"secret"), + &mut output, + &Allowance::limited(0), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert!(output.is_empty()); + } + + #[test] + fn crc_writer_flush_propagates_to_inner_writer() { + struct FlushSpy { + data: Vec, + flushed: usize, + } + impl Write for FlushSpy { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.data.extend_from_slice(buf); + Ok(buf.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + self.flushed += 1; + Ok(()) + } + } + let mut inner = FlushSpy { + data: Vec::new(), + flushed: 0, + }; + let mut crc = Crc32::new(); + let mut writer = CrcWriter { + inner: &mut inner, + crc: &mut crc, + }; + writer.write_all(b"hi").unwrap(); + writer.flush().unwrap(); + assert_eq!(inner.data, b"hi"); + assert_eq!(inner.flushed, 1); + } + + #[test] + fn parse_main_header_rejects_block_size_below_minimum() { + let block = BlockHeader { + head_crc: 0, + head_type: MAIN_HEAD, + flags: 0, + head_size: 12, + add_size: None, + offset: 0, + }; + let err = parse_main_header(&[0u8; 32], &block).unwrap_err(); + assert_eq!( + err, + Error::InvalidHeader("RAR 1.5 main header is too short") + ); + } + + #[test] + fn parse_main_header_reads_encrypt_version_when_flag_is_set() { + // Build a synthetic main header at offset 0: 13 bytes of base + 1 byte + // for the encrypt_version field at position 13. + let mut input = vec![0u8; 14]; + input[13] = 0x29; + let block = BlockHeader { + head_crc: 0, + head_type: MAIN_HEAD, + flags: MHD_ENCRYPTVER, + head_size: 14, + add_size: None, + offset: 0, + }; + let main = parse_main_header(&input, &block).unwrap(); + assert_eq!(main.encrypt_version, Some(0x29)); + } + + #[test] + fn malformed_unicode_filename_keeps_its_identity() { + let first = b"fallback\0\0\x80\0\xd8"; + let second = b"fallback\0\0\x80\x01\xd8"; + assert_eq!(decode_file_name(first, FHD_UNICODE), first); + assert_eq!(decode_file_name(second, FHD_UNICODE), second); + let invalid_copy = b"fallback\0\0\xc0\x7f"; + assert_eq!(decode_file_name(invalid_copy, FHD_UNICODE), invalid_copy); + } + + #[test] + fn decode_file_name_returns_raw_when_unicode_flag_is_clear() { + let raw = b"plain.txt"; + let decoded = decode_file_name(raw, 0); + assert_eq!(decoded, raw); + } + + #[test] + fn decode_file_name_returns_raw_when_unicode_marker_is_missing() { + // FHD_UNICODE set but no zero byte to split fallback from encoded + // payload — the decoder falls back to the raw bytes. + let raw = b"no-zero-marker"; + let decoded = decode_file_name(raw, FHD_UNICODE); + assert_eq!(decoded, raw); + } + + #[test] + fn decode_file_name_returns_fallback_when_no_encoded_payload_follows_zero() { + // Zero byte present but nothing after it — the decoder returns just + // the fallback prefix. + let mut raw = b"fallback".to_vec(); + raw.push(0); + let decoded = decode_file_name(&raw, FHD_UNICODE); + assert_eq!(decoded, b"fallback"); + } + + #[test] + fn decode_file_name_decodes_mode_zero_low_byte_only_units() { + // Mode 0 emits one ASCII byte per code unit. Encoded payload format: + // high_byte, flag_byte, byte0, byte1, ... + // flag_byte = 0b00_00_00_00 → four mode-0 emits. + let mut raw = b"orig".to_vec(); + raw.push(0); // separator + raw.push(0); // high_byte (unused for mode 0) + raw.push(0b00_00_00_00); // flag_byte: four mode-0 codes + raw.extend_from_slice(b"abcd"); + let decoded = decode_file_name(&raw, FHD_UNICODE); + assert_eq!(decoded, b"abcd"); + } + + #[test] + fn decode_file_name_decodes_mode_two_full_two_byte_units() { + // Mode 2 reads (low, high) bytes for a full UTF-16 code unit. + // Encode "Hi" via mode 2 twice: flag_byte = 0b10_10_00_00. + let mut raw = b"".to_vec(); + raw.push(0); // separator (zero_pos = 0) + raw.push(0); // high_byte placeholder + // Two mode-2 units, then two mode-0 units which we will not reach. + raw.push(0b10_10_00_00); + // First unit 'H' = U+0048: low=0x48, high=0x00 + raw.extend_from_slice(&[0x48, 0x00]); + // Second unit 'i' = U+0069 + raw.extend_from_slice(&[0x69, 0x00]); + let decoded = decode_file_name(&raw, FHD_UNICODE); + assert_eq!(decoded, b"Hi"); + } + + #[test] + fn decode_file_name_decodes_high_byte_and_copy_commands() { + assert_eq!( + decode_file_name(b"old\0\x04\x40\xe9", FHD_UNICODE), + "\u{4e9}".as_bytes() + ); + assert_eq!(decode_file_name(b"abc\0\0\xc0\x01", FHD_UNICODE), b"abc"); + assert_eq!( + decode_file_name(b"ABC\0\x01\xc0\x81\x01", FHD_UNICODE), + "\u{142}\u{143}\u{144}".as_bytes() + ); + } + + #[test] + fn truncated_unicode_commands_keep_the_raw_name() { + for raw in [ + &b"x\0\0\0"[..], // mode 0: missing low byte + &b"x\0\x01\x40"[..], // mode 1: missing low byte + &b"x\0\0\x80A"[..], // mode 2: missing high byte + &b"x\0\0\xc0"[..], // mode 3: missing run length + &b"x\0\0\xc0\x80"[..], // mode 3: missing correction + &b"x\0\0\xc0\0"[..], // mode 3: run exceeds fallback + ] { + assert_eq!(decode_file_name(raw, FHD_UNICODE), raw); + } + } +} diff --git a/arca-rar/vendor/rars/src/rar15_40/extract.rs b/arca-rar/vendor/rars/src/rar15_40/extract.rs new file mode 100644 index 00000000..94fb5fb4 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar15_40/extract.rs @@ -0,0 +1,2258 @@ +use super::*; +use crate::codec::rar13::Reader15State; +use crate::codec::rar20::Reader20State; +use crate::codec::rar29::Reader29State; +use crate::codec::workspace::{Allowance, Boxed, Budget, Buffer}; +use crate::volume_extract::{ChainedReader, SplitVolumeState, SplitVolumeStep}; +use std::io::{Read, Write}; + +enum CodecState { + Unpack15(Boxed, B>), + Unpack20(Boxed, B>), + Unpack29(Boxed, B>), +} + +impl CodecState { + fn with_allowance(file: &FileHeader, allowance: &B) -> Result { + if file.unp_ver >= 29 { + return Ok(Self::Unpack29(Boxed::try_new( + || Ok::<_, crate::codec::Error>(Reader29State::with_allowance(allowance)), + allowance, + )?)); + } + if file.unp_ver == 20 || file.unp_ver == 26 { + return Ok(Self::Unpack20(Boxed::try_new( + || Ok::<_, crate::codec::Error>(Reader20State::with_allowance(allowance)), + allowance, + )?)); + } + if file.unp_ver == 15 { + return Ok(Self::Unpack15(Boxed::try_new( + || Reader15State::with_allowance(allowance), + allowance, + )?)); + } + Err(Error::UnsupportedCompression { + family: "RAR 1.5-4.x", + unpack_version: file.unp_ver, + method: file.method, + }) + } + + fn supports(&self, file: &FileHeader) -> bool { + match self { + Self::Unpack15(_) => file.unp_ver == 15, + Self::Unpack20(_) => file.unp_ver == 20 || file.unp_ver == 26, + Self::Unpack29(_) => file.unp_ver >= 29, + } + } + + fn write_file_to( + &mut self, + archive: &Archive, + file: &FileHeader, + solid: bool, + password: Option<&[u8]>, + allowance: &B, + out: &mut impl Write, + ) -> Result<()> { + let mut packed = file + .packed_reader_with_allowance(archive, password, allowance) + .map_err(|error| file.map_encrypted_payload_error(password, error))?; + self.write_split_to(&mut packed, file, solid, password, out) + } + + fn decode_to( + &mut self, + input: &mut impl Read, + file: &FileHeader, + solid: bool, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + let target = usize::try_from(file.unp_size) + .map_err(|_| Error::InvalidHeader("RAR 1.5 split unpacked size overflows usize"))?; + match self { + Self::Unpack15(decoder) => decoder + .decode_member_from_reader(input, target, solid, out) + .map_err(Error::from) + .map_err(|error| file.map_encrypted_payload_error(password, error))?, + Self::Unpack20(decoder) => decoder + .decode_member_from_reader(input, target, out) + .map_err(Error::from) + .map_err(|error| file.map_encrypted_payload_error(password, error))?, + Self::Unpack29(decoder) => if solid { + decoder.decode_member_from_reader(input, target, out) + } else { + decoder.decode_non_solid_member_from_reader(input, target, out) + } + .map_err(Error::from) + .map_err(|error| file.map_encrypted_payload_error(password, error))?, + } + Ok(()) + } + fn write_split_to( + &mut self, + input: &mut impl Read, + file: &FileHeader, + solid: bool, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + let mut crc = Crc32::new(); + let mut crc_writer = CrcWriter { + inner: out, + crc: &mut crc, + }; + self.decode_to(input, file, solid, password, &mut crc_writer)?; + file.crc_result(crc.finish(), password) + } +} + +#[cfg(all(test, feature = "write"))] +impl CodecState { + fn new_for(file: &FileHeader) -> Result { + Self::with_allowance(file, &Allowance::default()) + } +} + +pub(super) struct DecoderSession<'a, B: Budget = Allowance> { + pub(super) read_control: crate::read_control::ReadControl, + codec: Option>, + solid: bool, + decoded_files: usize, + password: Option<&'a [u8]>, + allowance: B, +} + +impl<'a, B: Budget> DecoderSession<'a, B> { + pub(super) fn with_allowance(solid: bool, password: Option<&'a [u8]>, allowance: &B) -> Self { + Self { + read_control: crate::read_control::ReadControl::default(), + codec: None, + solid, + decoded_files: 0, + password, + allowance: allowance.clone(), + } + } + + /// Stream a compressed member; callers handle stored members separately. + pub(super) fn write_file_to( + &mut self, + archive: &Archive, + file: &FileHeader, + out: &mut impl Write, + ) -> Result<()> { + debug_assert!(!file.is_stored()); + if file.is_empty_compressed_payload() { + file.crc_result(0, self.password)?; + return Ok(()); + } + let solid = self.file_is_solid(file); + let password = self.password; + let allowance = self.allowance.clone(); + self.codec_for(file)? + .write_file_to(archive, file, solid, password, &allowance, out)?; + self.decoded_files += 1; + Ok(()) + } + + fn write_split_to( + &mut self, + input: &mut impl Read, + final_file: &FileHeader, + out: &mut impl Write, + ) -> Result<()> { + let solid = self.file_is_solid(final_file); + let password = self.password; + self.codec_for(final_file)? + .write_split_to(input, final_file, solid, password, out)?; + self.decoded_files += 1; + Ok(()) + } + + /// Decode compressed recovery data into a charged buffer. + #[cfg(any(all(test, feature = "write"), feature = "recovery"))] + pub(super) fn decode_file_owned( + &mut self, + archive: &Archive, + file: &FileHeader, + ) -> Result> { + debug_assert!(!file.is_stored()); + let mut out = Buffer::new(&self.allowance); + if file.is_empty_compressed_payload() { + file.crc_result(0, self.password)?; + return Ok(out); + } + let password = self.password; + let mut input = file.packed_reader_with_allowance(archive, password, &self.allowance)?; + let solid = self.file_is_solid(file); + self.codec_for(file)? + .decode_to(&mut input, file, solid, password, &mut out)?; + Ok(out) + } + + fn file_is_solid(&self, file: &FileHeader) -> bool { + if !self.solid || self.decoded_files == 0 { + return false; + } + // FHD_SOLID is not meaningful for unpack version < 20; rely on the + // archive-level MHD_SOLID flag in that case. + file.unp_ver < 20 || file.is_solid() + } + + fn codec_for(&mut self, file: &FileHeader) -> Result<&mut CodecState> { + self.read_control.check()?; + let reset = !self.file_is_solid(file) + || self + .codec + .as_ref() + .is_none_or(|codec| !codec.supports(file)); + if reset { + self.codec = Some(CodecState::with_allowance(file, &self.allowance)?); + } + // A missing codec always sets `reset`; successful construction then + // installs it before reaching this point. + let codec = self.codec.as_mut().expect("codec is initialized above"); + match codec { + CodecState::Unpack15(d) => d.read_control = self.read_control.clone(), + CodecState::Unpack20(d) => d.read_control = self.read_control.clone(), + CodecState::Unpack29(d) => d.read_control = self.read_control.clone(), + } + Ok(codec) + } +} + +impl<'a> DecoderSession<'a, Allowance> { + #[cfg(any(all(test, feature = "write"), feature = "recovery"))] + pub(super) fn new(solid: bool) -> Self { + Self::new_with_password(solid, None) + } + pub(super) fn new_with_password(solid: bool, password: Option<&'a [u8]>) -> Self { + Self::with_allowance(solid, password, &Allowance::default()) + } + #[cfg(any(all(test, feature = "write"), feature = "recovery"))] + pub(super) fn decode_file_data( + &mut self, + archive: &Archive, + file: &FileHeader, + ) -> Result> { + self.decode_file_owned(archive, file).map(Buffer::into_vec) + } +} + +impl FileHeader { + fn is_empty_compressed_payload(&self) -> bool { + !self.is_stored() && self.pack_size == 0 && self.unp_size == 0 + } +} + +/// Streams a multivolume archive set to caller-provided writers. +pub fn extract_volumes_to( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + open: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + if let Some(limit) = options.max_reader_workspace_bytes { + return extract_volumes_with_allowance(volumes, options, open, &Allowance::limited(limit)); + } + extract_volumes_with_allowance(volumes, options, open, &Allowance::default()) +} + +fn extract_volumes_with_allowance( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + mut open: F, + allowance: &B, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + options.check_cancelled()?; + if volumes.is_empty() { + return Err(Error::InvalidHeader("RAR 1.5 volume set is empty")); + } + + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + let mut split = SplitVolumeState::new(); + let mut session = DecoderSession::with_allowance( + volumes + .first() + .is_some_and(|archive| archive.main.is_solid()), + password, + allowance, + ); + session.read_control = budget.control.clone(); + for (volume_index, archive) in volumes.iter().enumerate() { + for (file_index, file) in archive.files().enumerate() { + options.check_cancelled()?; + match split.advance(file.is_split_before(), file.is_split_after()) { + SplitVolumeStep::Regular => { + let meta = file.metadata(); + if meta.is_directory { + options.check_cancelled()?; + let _ = open(&meta)?; + options.check_cancelled()?; + } else { + budget.check(file.unp_size, &file.name)?; + options.check_cancelled()?; + let mut writer = open(&meta)?; + options.check_cancelled()?; + budget.run(&file.name, &mut writer, |mut writer| { + if file.is_stored() { + file.write_stored_with_allowance( + archive, + password, + &mut writer, + allowance, + ) + .map_err(|error| file.entry_error("extracting", error))?; + } else { + session + .write_file_to(archive, file, &mut writer) + .map_err(|error| file.entry_error("extracting", error))?; + } + options.check_cancelled()?; + Ok(()) + })?; + } + } + SplitVolumeStep::Start => { + validate_split_fragment(file, password)?; + split.begin(PendingSplitRefs::with_allowance( + file, + volume_index, + file_index, + allowance, + )?); + } + SplitVolumeStep::Continue(current) => { + validate_split_continuation_refs(current, file, password)?; + current.append(file, volume_index, file_index)?; + } + SplitVolumeStep::Finish(mut completed) => { + validate_split_continuation_refs(&completed, file, password)?; + completed.append(file, volume_index, file_index)?; + completed.write_to( + volumes, + file, + password, + &mut session, + &mut budget, + &mut open, + )?; + } + SplitVolumeStep::MissingFirst => { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry is missing its first part", + )); + } + SplitVolumeStep::Interrupted => { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry is interrupted by a regular entry", + )); + } + } + } + } + + if split.is_pending() { + return Err(Error::InvalidHeader("RAR 1.5 split entry is incomplete")); + } + + options.check_cancelled()?; + Ok(()) +} + +fn validate_split_fragment(file: &FileHeader, password: Option<&[u8]>) -> Result<()> { + if file.is_directory() { + return Err(Error::InvalidHeader( + "RAR 1.5 split directory entry is invalid", + )); + } + if file.is_encrypted() { + crate::crypto::require_encryption()?; + } + if file.is_encrypted() && password.is_none() { + return Err(Error::NeedPassword); + } + Ok(()) +} + +fn validate_split_continuation_refs( + pending: &PendingSplitRefs, + file: &FileHeader, + password: Option<&[u8]>, +) -> Result<()> { + validate_split_fragment(file, password)?; + if file.name != pending.name { + return Err(Error::InvalidHeader("RAR 1.5 split entry name changed")); + } + if file.method != pending.method { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry compression method changed", + )); + } + if file.unp_ver != pending.unp_ver { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry unpack version changed", + )); + } + if file.is_encrypted() != pending.encrypted { + return Err(Error::InvalidHeader( + "RAR 1.5 split entry encryption flag changed", + )); + } + if pending.encrypted && pending.unp_ver >= 29 && file.salt != pending.salt { + return Err(Error::InvalidHeader("RAR 3.x split entry salt changed")); + } + Ok(()) +} + +struct PendingSplitRefs { + name: Vec, + fragments: Buffer<(usize, usize), B>, + file_time: u32, + mtime_refinement: Option, + attr: u32, + host_os: u8, + method: u8, + unp_ver: u8, + encrypted: bool, + salt: Option<[u8; 8]>, +} + +impl PendingSplitRefs { + fn with_allowance( + file: &FileHeader, + volume_index: usize, + file_index: usize, + allowance: &B, + ) -> Result { + Ok(Self { + name: file.name.clone(), + fragments: Buffer::copied(&[(volume_index, file_index)], allowance)?, + file_time: file.file_time, + mtime_refinement: file.mtime_refinement(), + attr: file.attr, + host_os: file.host_os, + method: file.method, + unp_ver: file.unp_ver, + encrypted: file.is_encrypted(), + salt: file.salt, + }) + } + + fn append(&mut self, _file: &FileHeader, volume_index: usize, file_index: usize) -> Result<()> { + self.fragments.try_push((volume_index, file_index))?; + Ok(()) + } + + fn write_to( + self, + volumes: &[Archive], + final_file: &FileHeader, + password: Option<&[u8]>, + session: &mut DecoderSession<'_, B>, + budget: &mut crate::output_limit::OutputBudget, + open: &mut F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + budget.check(final_file.unp_size, &final_file.name)?; + let meta = ExtractedEntryMeta { + name_is_unicode: final_file.unicode_name.is_some(), + name: self.name.clone(), + file_time: self.file_time, + mtime_refinement: self.mtime_refinement, + attr: self.attr, + host_os: self.host_os, + is_directory: false, + }; + let mut writer = open(&meta)?; + budget.run(&final_file.name, &mut writer, |mut writer| { + let mut reader = self.fragment_reader_with_allowance( + volumes, + password, + &self.fragments.allowance(), + )?; + + if final_file.is_stored() { + let expected_len = usize::try_from(final_file.unp_size).map_err(|_| { + Error::InvalidHeader("RAR 1.5 split unpacked size overflows usize") + })?; + let actual_len = self.packed_size(volumes)?; + let expected_packed_len = if self.encrypted && self.unp_ver >= 20 { + expected_len.checked_add(15).map(|len| len & !15).ok_or( + Error::InvalidHeader("RAR 2.x encrypted split stored size overflows"), + )? + } else { + expected_len + }; + if actual_len != expected_packed_len { + return Err(Error::InvalidHeader( + "RAR 1.5 split stored file has wrong reassembled size", + )); + } + + let mut crc = Crc32::new(); + let mut crc_writer = CrcWriter { + inner: &mut writer, + crc: &mut crc, + }; + let copied = std::io::copy(&mut reader.take(expected_len as u64), &mut crc_writer)?; + if copied != expected_len as u64 { + return Err(Error::InvalidHeader( + "RAR 1.5 split stored file ended before unpacked size", + )); + } + let actual = crc.finish(); + final_file + .crc_result(actual, password) + .map_err(|error| final_file.entry_error("extracting", error)) + } else { + session + .write_split_to(&mut reader, final_file, &mut writer) + .map_err(|error| final_file.entry_error("extracting", error)) + } + }) + } + + fn packed_size(&self, volumes: &[Archive]) -> Result { + // Fragments index the same immutable volume slice enumerated by + // extract_volumes_to; their member indices cannot disappear. + self.fragments + .iter() + .try_fold(0usize, |total, &(volume_index, file_index)| { + let archive = &volumes[volume_index]; + let file = archive + .files() + .nth(file_index) + .expect("split fragment index comes from archive enumeration"); + total + .checked_add(usize::try_from(file.pack_size).map_err(|_| { + Error::InvalidHeader("RAR 1.5 split packed size overflows usize") + })?) + .ok_or(Error::InvalidHeader( + "RAR 1.5 split packed size overflows usize", + )) + }) + } + + fn fragment_reader_with_allowance<'a>( + &self, + volumes: &'a [Archive], + password: Option<&[u8]>, + allowance: &B, + ) -> Result, B>, B>> { + let mut readers = Buffer::with_capacity(self.fragments.len(), allowance)?; + for &(volume_index, file_index) in &self.fragments { + let archive = &volumes[volume_index]; + let file = archive + .files() + .nth(file_index) + .expect("split fragment index comes from archive enumeration"); + readers.push_admitted(archive.range_reader(file.packed_range.clone())?); + } + let reader = ChainedReader::with_readers(readers); + if !self.encrypted { + return Ok(PackedReader::Plain(reader)); + } + + let password = password.expect("encrypted split fragments were admitted with a password"); + Ok(PackedReader::Encrypted(Boxed::try_new( + || { + DecryptingReader::with_allowance( + reader, + self.unp_ver, + password, + self.salt, + allowance, + ) + }, + allowance, + )?)) + } +} + +#[cfg(all(test, feature = "write"))] +impl PendingSplitRefs { + fn new(file: &FileHeader, volume_index: usize, file_index: usize) -> Self { + Self::with_allowance(file, volume_index, file_index, &Allowance::default()) + .expect("unlimited split bookkeeping") + } + #[cfg(all(test, feature = "write"))] + fn fragment_reader<'a>( + &self, + volumes: &'a [Archive], + password: Option<&[u8]>, + ) -> Result>>> { + self.fragment_reader_with_allowance(volumes, password, &Allowance::default()) + } +} + +#[cfg(feature = "encryption")] +enum SplitCipher { + Rar15(Rar15Cipher), + Rar20(Boxed), + Rar30(Boxed), +} + +#[cfg(feature = "encryption")] +impl SplitCipher { + fn with_allowance( + unp_ver: u8, + password: &[u8], + salt: Option<[u8; 8]>, + allowance: &B, + ) -> Result { + if unp_ver == 15 { + return Ok(Self::Rar15(Rar15Cipher::new(password))); + } + if unp_ver == 20 || unp_ver == 26 { + return Ok(Self::Rar20(Boxed::try_new( + || Ok::<_, crate::codec::Error>(Rar20Cipher::new(password)), + allowance, + )?)); + } + if unp_ver >= 29 { + return Ok(Self::Rar30(Boxed::try_new( + || Rar30Cipher::new(password, salt).map_err(super::map_rar30_crypto_error), + allowance, + )?)); + } + Err(Error::UnsupportedEncryption { + family: "RAR 1.5-4.x split volume", + unpack_version: unp_ver, + }) + } +} + +pub(super) enum PackedReader { + Plain(R), + Encrypted(Boxed, B>), +} +impl Read for PackedReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + match self { + Self::Plain(reader) => reader.read(out), + Self::Encrypted(reader) => reader.read(out), + } + } +} +#[cfg(not(feature = "encryption"))] +pub(super) type DecryptingReader = crate::crypto::unavailable::Reader; + +#[cfg(feature = "encryption")] +pub(super) struct DecryptingReader { + inner: R, + cipher: SplitCipher, + encrypted_block: Buffer, + decrypted: Buffer, + read_buffer: Option>, + decrypted_pos: usize, + eof: bool, +} + +#[cfg(feature = "encryption")] +impl DecryptingReader { + pub(super) fn with_allowance( + inner: R, + unp_ver: u8, + password: &[u8], + salt: Option<[u8; 8]>, + allowance: &B, + ) -> Result { + let cipher = SplitCipher::with_allowance(unp_ver, password, salt, allowance)?; + let read_buffer = matches!(cipher, SplitCipher::Rar15(_)) + .then(|| Buffer::filled(64 * 1024, 0, allowance)) + .transpose()?; + Ok(Self { + inner, + cipher, + encrypted_block: Buffer::new(allowance), + decrypted: Buffer::new(allowance), + read_buffer, + decrypted_pos: 0, + eof: false, + }) + } + + fn fill_decrypted(&mut self) -> std::io::Result<()> { + if self.decrypted_pos < self.decrypted.len() || self.eof { + return Ok(()); + } + self.decrypted.clear(); + self.decrypted_pos = 0; + + match &mut self.cipher { + SplitCipher::Rar15(cipher) => { + let read_buffer = self + .read_buffer + .as_mut() + .expect("RAR 1.5 decrypting reader has a reusable buffer"); + let count = self.inner.read(read_buffer)?; + if count == 0 { + self.eof = true; + return Ok(()); + } + self.decrypted + .extend_from_slice(&read_buffer[..count]) + .map_err(Into::::into) + .map_err(Error::from) + .map_err(std::io::Error::other)?; + cipher.crypt_in_place(&mut self.decrypted); + } + SplitCipher::Rar20(cipher) => Self::fill_block_decrypted( + &mut self.inner, + &mut self.encrypted_block, + &mut self.decrypted, + &mut self.eof, + |block| cipher.decrypt_block(block), + )?, + SplitCipher::Rar30(cipher) => Self::fill_block_decrypted( + &mut self.inner, + &mut self.encrypted_block, + &mut self.decrypted, + &mut self.eof, + |block| cipher.decrypt_block(block), + )?, + } + Ok(()) + } + + fn fill_block_decrypted( + inner: &mut R, + encrypted_block: &mut Buffer, + decrypted: &mut Buffer, + eof: &mut bool, + mut decrypt_block: impl FnMut(&mut [u8; 16]), + ) -> std::io::Result<()> { + // fill_decrypted returns before calling us once EOF is known. The only + // EOF transition below breaks the loop immediately. + while encrypted_block.len() < 16 { + let mut buf = [0u8; 64 * 1024]; + let count = inner.read(&mut buf)?; + if count == 0 { + *eof = true; + break; + } + encrypted_block + .extend_from_slice(&buf[..count]) + .map_err(Into::::into) + .map_err(Error::from) + .map_err(std::io::Error::other)?; + } + + let full_len = (encrypted_block.len() / 16) * 16; + if full_len != 0 { + let tail = Buffer::copied(&encrypted_block[full_len..], &encrypted_block.allowance()) + .map_err(Error::from) + .map_err(std::io::Error::other)?; + let mut data = std::mem::replace(encrypted_block, tail); + data.truncate(full_len); + for block in data.as_chunks_mut::<16>().0.iter_mut() { + decrypt_block(block); + } + *decrypted = data; + } else if !encrypted_block.is_empty() { + // With no full block, the loop could only have ended at EOF. + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "RAR encrypted payload is not block aligned", + )); + } + Ok(()) + } +} + +#[cfg(feature = "encryption")] +impl Read for DecryptingReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if out.is_empty() { + return Ok(0); + } + self.fill_decrypted()?; + if self.decrypted_pos == self.decrypted.len() { + return Ok(0); + } + let count = out.len().min(self.decrypted.len() - self.decrypted_pos); + out[..count] + .copy_from_slice(&self.decrypted[self.decrypted_pos..self.decrypted_pos + count]); + self.decrypted_pos += count; + Ok(count) + } +} + +#[cfg(all(test, feature = "write"))] +#[cfg(feature = "encryption")] +impl SplitCipher { + fn new(unp_ver: u8, password: &[u8], salt: Option<[u8; 8]>) -> Result { + Self::with_allowance(unp_ver, password, salt, &Allowance::default()) + } +} +#[cfg(all(test, feature = "write"))] +#[cfg(feature = "encryption")] +impl DecryptingReader { + pub(super) fn new( + inner: R, + unp_ver: u8, + password: &[u8], + salt: Option<[u8; 8]>, + ) -> Result { + Self::with_allowance(inner, unp_ver, password, salt, &Allowance::default()) + } +} +#[cfg(all(test, feature = "write"))] +mod tests { + #[test] + fn reader_workspace_split_descriptor_growth_is_admitted_before_mutation() { + let first = file(b"a.txt", FHD_SPLIT_AFTER); + let bytes = std::mem::size_of::<(usize, usize)>() as u64; + let quota = Allowance::limited(bytes); + let mut pending = PendingSplitRefs::with_allowance(&first, 0, 0, "a).unwrap(); + assert_eq!(quota.used(), bytes); + let error = pending.append(&first, 1, 0).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(&pending.fragments[..], &[(0, 0)]); + assert_eq!(quota.used(), bytes); + drop(pending); + assert_eq!(quota.used(), 0); + } + + #[test] + fn reader_session_workspace_refusals_charge_every_legacy_decoder_and_encrypted_payload() { + use crate::codec::workspace::RefusingBudget; + let plain = b"abcabcabc"; + for version in [15, 20, 29] { + let packed = match version { + 15 => crate::codec::rar13::unpack15_encode(plain).unwrap(), + 20 => crate::codec::rar20::unpack20_encode_literals(plain).unwrap(), + _ => crate::codec::rar29::unpack29_encode_literals(plain).unwrap(), + }; + for encrypted in crate::test_features::encryption_cases() { + let payload = packed.clone(); + #[cfg(feature = "encryption")] + let mut payload = payload; + if encrypted { + #[cfg(feature = "encryption")] + { + match version { + 15 => Rar15Cipher::new(b"pw").crypt_in_place(&mut payload), + 20 => { + payload.resize(payload.len().div_ceil(16) * 16, 0); + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut payload) + .unwrap(); + } + _ => { + payload.resize(payload.len().div_ceil(16) * 16, 0); + Rar30Cipher::new(b"pw", None) + .unwrap() + .encrypt_in_place(&mut payload) + .unwrap(); + } + } + } + } + let mut entry = file(b"charged.bin", if encrypted { FHD_PASSWORD } else { 0 }); + entry.method = 0x33; + entry.unp_ver = version; + entry.unp_size = plain.len() as u64; + entry.pack_size = payload.len() as u64; + entry.packed_range = 0..payload.len(); + entry.file_crc = crate::crc32::crc32(plain); + let archive = archive_with_source(vec![Block::File(entry.clone())], payload); + let run = |budget: &RefusingBudget| -> Result<()> { + let mut session = DecoderSession::with_allowance(false, Some(b"pw"), budget); + let mut out = Buffer::new(budget); + session.write_file_to(&archive, &entry, &mut out)?; + assert_eq!(&out[..], plain); + let decoded = session.decode_file_owned(&archive, &entry)?; + assert_eq!(&decoded[..], plain); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + let error = run(&budget).unwrap_err(); + assert_eq!( + error.kind(), + crate::ErrorKind::Cancelled, + "version {version}, encrypted {encrypted}, allocation {index}: {error}" + ); + assert_eq!(budget.used(), 0); + } + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn reader_session_workspace_refusal_keeps_its_resource_kind_for_encrypted_members() { + let mut entry = file(b"quota.bin", FHD_PASSWORD); + entry.method = 0x33; + entry.unp_ver = 29; + entry.unp_size = 1; + entry.pack_size = 16; + entry.packed_range = 0..16; + let archive = archive_with_source(vec![Block::File(entry.clone())], vec![0; 16]); + let budget = Allowance::limited(1); + let mut session = DecoderSession::with_allowance(false, Some(b"pw"), &budget); + let error = session + .write_file_to(&archive, &entry, &mut std::io::sink()) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(budget.used(), 0); + let error = entry + .packed_reader_with_allowance(&archive, Some(b"pw"), &budget) + .err() + .unwrap(); + assert_eq!( + entry.map_encrypted_payload_error(Some(b"pw"), error).kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(budget.used(), 0); + } + + #[test] + #[cfg(feature = "encryption")] + fn reader_workspace_refusals_release_legacy_cipher_and_decryption_buffers() { + use crate::codec::workspace::RefusingBudget; + for version in [15, 20, 29] { + let plain = *b"0123456789abcdefRAR AES CBC data"; + let mut encrypted = plain; + match version { + 15 => Rar15Cipher::new(b"pw").crypt_in_place(&mut encrypted), + 20 => Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(), + _ => Rar30Cipher::new(b"pw", None) + .unwrap() + .encrypt_in_place(&mut encrypted) + .unwrap(), + } + let run = |budget: &RefusingBudget| -> Result<()> { + let input = ChunkedReader::new(Cursor::new(&encrypted), 7); + let mut reader = + DecryptingReader::with_allowance(input, version, b"pw", None, budget)?; + let mut out = Buffer::new(budget); + out.read_to_end(&mut reader)?; + assert_eq!(&out[..], &plain); + Ok(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + let error = run(&budget).unwrap_err(); + assert_eq!( + error.kind(), + crate::ErrorKind::Cancelled, + "version {version}, allocation {index}: {error}" + ); + assert_eq!(budget.used(), 0); + } + } + } + + use super::super::{ + ArchiveSource, Block, BlockHeader, MainHeader, FHD_DIRECTORY_MASK, FHD_PASSWORD, + FHD_SPLIT_AFTER, FHD_SPLIT_BEFORE, + }; + use super::*; + #[cfg(feature = "encryption")] + use std::io::Cursor; + use std::sync::Arc; + + fn block(flags: u16) -> BlockHeader { + BlockHeader { + head_crc: 0, + head_type: 0x74, + flags, + head_size: 0, + add_size: Some(0), + offset: 0, + } + } + + fn file(name: &[u8], flags: u16) -> FileHeader { + FileHeader { + block: block(flags), + pack_size: 0, + unp_size: 0, + host_os: 2, + file_crc: 0, + file_time: 0, + unp_ver: 29, + method: 0x30, + name: name.to_vec(), + unicode_name: None, + attr: 0x20, + salt: None, + file_comment: Vec::new(), + ext_time: Vec::new(), + packed_range: 0..0, + } + } + + #[cfg(feature = "encryption")] + struct ChunkedReader { + inner: R, + chunk: usize, + } + + #[cfg(feature = "encryption")] + impl ChunkedReader { + fn new(inner: R, chunk: usize) -> Self { + Self { inner, chunk } + } + } + + #[cfg(feature = "encryption")] + impl Read for ChunkedReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + let take = out.len().min(self.chunk); + self.inner.read(&mut out[..take]) + } + } + + fn read_in_small_chunks(mut reader: impl Read) -> Vec { + let mut out = Vec::new(); + let mut buf = [0u8; 7]; + loop { + let count = reader.read(&mut buf).unwrap(); + if count == 0 { + break; + } + out.extend_from_slice(&buf[..count]); + } + out + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_streams_rar15_payload() { + let plain = b"RAR 1.5 encrypted payload read in pieces"; + let mut encrypted = plain.to_vec(); + Rar15Cipher::new(b"pw").crypt_in_place(&mut encrypted); + let mut reader = DecryptingReader::new(Cursor::new(encrypted), 15, b"pw", None).unwrap(); + let mut out = Vec::new(); + let mut buf = [0u8; 3]; + + loop { + let count = reader.read(&mut buf).unwrap(); + if count == 0 { + break; + } + out.extend_from_slice(&buf[..count]); + } + + assert_eq!(out, plain); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_streams_rar20_blocks_from_short_inner_reads() { + let plain = *b"0123456789abcdefRAR2 block two!!"; + let mut encrypted = plain; + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(); + for version in [20, 26] { + let reader = DecryptingReader::new( + ChunkedReader::new(Cursor::new(encrypted), 5), + version, + b"pw", + None, + ) + .unwrap(); + assert_eq!(read_in_small_chunks(reader), plain); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_streams_rar30_blocks_from_short_inner_reads() { + let salt = Some([7u8; 8]); + let plain = *b"0123456789abcdefRAR3 block two!!"; + let mut encrypted = plain; + Rar30Cipher::new(b"pw", salt) + .unwrap() + .encrypt_in_place(&mut encrypted) + .unwrap(); + let reader = DecryptingReader::new( + ChunkedReader::new(Cursor::new(encrypted), 5), + 29, + b"pw", + salt, + ) + .unwrap(); + let out = read_in_small_chunks(reader); + + assert_eq!(out, plain); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_preserves_partial_blocks_across_source_errors() { + let plain = *b"0123456789abcdefRAR3 block two!!"; + let salt = Some([7; 8]); + for version in [15, 20, 29] { + let mut encrypted = plain; + match version { + 15 => Rar15Cipher::new(b"pw").crypt_in_place(&mut encrypted), + 20 => Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(), + _ => Rar30Cipher::new(b"pw", salt) + .unwrap() + .encrypt_in_place(&mut encrypted) + .unwrap(), + } + for kind in [ + std::io::ErrorKind::Interrupted, + std::io::ErrorKind::PermissionDenied, + ] { + for fail_at in [0, 5, 16, 21] { + let inner = + crate::read_errors::ErrorOnceReader::new(encrypted.to_vec(), fail_at, kind); + let mut reader = DecryptingReader::new(inner, version, b"pw", salt).unwrap(); + let mut out = Vec::new(); + let result = reader.read_to_end(&mut out); + if kind == std::io::ErrorKind::Interrupted { + result.unwrap(); + } else { + let error = result.unwrap_err(); + assert_eq!(error.kind(), kind); + assert_eq!(error.to_string(), "source read failed"); + let emitted = if version == 15 { + fail_at as usize + } else { + fail_at as usize / 16 * 16 + }; + assert_eq!(out, plain[..emitted]); + reader.read_to_end(&mut out).unwrap(); + } + assert_eq!(out, plain, "version {version}, error {kind:?} at {fail_at}"); + } + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_preserves_complete_blocks_and_caches_eof() { + struct CountingReader { + inner: Cursor>, + chunk: usize, + reads: usize, + } + impl Read for CountingReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + self.reads += 1; + let count = out.len().min(self.chunk); + self.inner.read(&mut out[..count]) + } + } + + let plain = *b"0123456789abcdefRAR3 block two!!"; + let salt = Some([7; 8]); + for version in [15, 20, 29] { + let mut encrypted = plain; + match version { + 15 => Rar15Cipher::new(b"pw").crypt_in_place(&mut encrypted), + 20 => Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(), + _ => Rar30Cipher::new(b"pw", salt) + .unwrap() + .encrypt_in_place(&mut encrypted) + .unwrap(), + } + for chunk in [5, 64 * 1024] { + for length in 0..=encrypted.len() { + let inner = CountingReader { + inner: Cursor::new(encrypted[..length].to_vec()), + chunk, + reads: 0, + }; + let mut reader = DecryptingReader::new(inner, version, b"pw", salt).unwrap(); + assert_eq!(reader.read(&mut []).unwrap(), 0); + assert_eq!(reader.inner.reads, 0); + let mut out = Vec::new(); + let result = loop { + let mut buf = [0; 3]; + match reader.read(&mut buf) { + Ok(0) => break Ok(()), + Ok(count) => out.extend_from_slice(&buf[..count]), + Err(error) => break Err(error), + } + }; + let complete_length = if version == 15 { + length + } else { + length / 16 * 16 + }; + assert_eq!( + out, + plain[..complete_length], + "version {version}, length {length}, chunk {chunk}" + ); + if version != 15 && length % 16 != 0 { + assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::InvalidData); + } else { + result.unwrap(); + let reads = reader.inner.reads; + assert_eq!(reader.read(&mut [0]).unwrap(), 0); + assert_eq!(reader.read(&mut [0]).unwrap(), 0); + assert_eq!(reader.inner.reads, reads, "EOF must not reread the source"); + } + } + } + } + } + + #[test] + fn validate_split_fragment_rejects_directories_and_demands_password_for_encrypted() { + let dir = file(b"d", FHD_DIRECTORY_MASK | FHD_SPLIT_AFTER); + assert!(matches!( + validate_split_fragment(&dir, None), + Err(Error::InvalidHeader(_)) + )); + + let encrypted = file(b"a", FHD_PASSWORD | FHD_SPLIT_AFTER); + #[cfg(feature = "encryption")] + { + assert!(matches!( + validate_split_fragment(&encrypted, None), + Err(Error::NeedPassword) + )); + validate_split_fragment(&encrypted, Some(b"pw")).unwrap(); + } + #[cfg(not(feature = "encryption"))] + for password in [None, Some(b"pw".as_slice())] { + assert!(matches!( + validate_split_fragment(&encrypted, password), + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + } + + let plain = file(b"a", FHD_SPLIT_AFTER); + validate_split_fragment(&plain, None).unwrap(); + } + + #[test] + fn validate_split_continuation_refs_rejects_property_drift_between_fragments() { + let first = file(b"a.txt", FHD_SPLIT_AFTER); + let pending = PendingSplitRefs::new(&first, 0, 0); + + let renamed = file(b"b.txt", FHD_SPLIT_BEFORE); + assert!(matches!( + validate_split_continuation_refs(&pending, &renamed, None), + Err(Error::InvalidHeader(_)) + )); + + let mut new_method = file(b"a.txt", FHD_SPLIT_BEFORE); + new_method.method = 0x35; + assert!(matches!( + validate_split_continuation_refs(&pending, &new_method, None), + Err(Error::InvalidHeader(_)) + )); + + let mut new_version = file(b"a.txt", FHD_SPLIT_BEFORE); + new_version.unp_ver = 20; + assert!(matches!( + validate_split_continuation_refs(&pending, &new_version, None), + Err(Error::InvalidHeader(_)) + )); + + let new_encryption = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_BEFORE); + #[cfg(feature = "encryption")] + assert!(matches!( + validate_split_continuation_refs(&pending, &new_encryption, Some(b"pw")), + Err(Error::InvalidHeader(_)) + )); + #[cfg(not(feature = "encryption"))] + assert!(matches!( + validate_split_continuation_refs(&pending, &new_encryption, Some(b"pw")), + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + + let same = file(b"a.txt", FHD_SPLIT_BEFORE); + validate_split_continuation_refs(&pending, &same, None).unwrap(); + } + + #[test] + #[cfg(feature = "encryption")] + fn validate_split_continuation_refs_rejects_salt_drift_for_rar3_encrypted_entries() { + let mut first = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.salt = Some([1u8; 8]); + let pending = PendingSplitRefs::new(&first, 0, 0); + + let mut other_salt = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_BEFORE); + other_salt.salt = Some([2u8; 8]); + assert!(matches!( + validate_split_continuation_refs(&pending, &other_salt, Some(b"pw")), + Err(Error::InvalidHeader(_)) + )); + + let mut same_salt = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_BEFORE); + same_salt.salt = Some([1u8; 8]); + validate_split_continuation_refs(&pending, &same_salt, Some(b"pw")).unwrap(); + } + + fn empty_archive() -> Archive { + Archive { + sfx_offset: 0, + main: MainHeader { + head_crc: 0, + flags: 0, + head_size: 0, + reserved1: 0, + reserved2: 0, + encrypt_version: None, + }, + blocks: Vec::new(), + source: ArchiveSource::Memory(Arc::from(Vec::new().into_boxed_slice())), + } + } + + fn archive_with(blocks: Vec) -> Archive { + let mut archive = empty_archive(); + archive.blocks = blocks; + archive + } + + fn archive_with_source(blocks: Vec, source: Vec) -> Archive { + Archive { + sfx_offset: 0, + main: MainHeader { + head_crc: 0, + flags: 0, + head_size: 0, + reserved1: 0, + reserved2: 0, + encrypt_version: None, + }, + blocks, + source: ArchiveSource::Memory(Arc::from(source.into_boxed_slice())), + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_split_fragment_reader_decrypts_after_chaining_fragments() { + let plain = *b"0123456789abcdefRAR2 block two!!"; + let mut encrypted = plain; + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(); + let split = 7; + + let mut first = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = split as u64; + first.packed_range = 0..split; + + let mut second = file(b"a.txt", FHD_PASSWORD | FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = (encrypted.len() - split) as u64; + second.packed_range = 0..(encrypted.len() - split); + + let mut pending = PendingSplitRefs::new(&first, 0, 0); + pending.append(&second, 1, 0).unwrap(); + let volumes = vec![ + archive_with_source(vec![Block::File(first)], encrypted[..split].to_vec()), + archive_with_source(vec![Block::File(second)], encrypted[split..].to_vec()), + ]; + + let reader = pending.fragment_reader(&volumes, Some(b"pw")).unwrap(); + let out = read_in_small_chunks(reader); + + assert_eq!(out, plain); + } + + fn never_open(_meta: &ExtractedEntryMeta) -> Result> { + panic!("open should not be invoked for this test"); + } + + #[test] + fn extract_volumes_to_rejects_split_state_violations() { + let empty: Vec = Vec::new(); + assert!(matches!( + extract_volumes_to(&empty, crate::ArchiveReadOptions::default(), never_open), + Err(Error::InvalidHeader(_)) + )); + + let only_continuation = vec![archive_with(vec![Block::File(file( + b"a.txt", + FHD_SPLIT_BEFORE, + ))])]; + assert!(matches!( + extract_volumes_to( + &only_continuation, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + + let interrupted = vec![archive_with(vec![ + Block::File(file(b"a.txt", FHD_SPLIT_AFTER)), + Block::File(file(b"unrelated", 0)), + ])]; + assert!(matches!( + extract_volumes_to( + &interrupted, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + + let incomplete = vec![archive_with(vec![Block::File(file( + b"a.txt", + FHD_SPLIT_AFTER, + ))])]; + assert!(matches!( + extract_volumes_to( + &incomplete, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + } + + #[test] + fn codec_state_new_for_chooses_codec_by_unpack_version() { + let mut f = file(b"a", 0); + f.unp_ver = 15; + assert!(matches!( + CodecState::new_for(&f).unwrap(), + CodecState::Unpack15(_) + )); + f.unp_ver = 20; + assert!(matches!( + CodecState::new_for(&f).unwrap(), + CodecState::Unpack20(_) + )); + f.unp_ver = 26; + assert!(matches!( + CodecState::new_for(&f).unwrap(), + CodecState::Unpack20(_) + )); + f.unp_ver = 29; + assert!(matches!( + CodecState::new_for(&f).unwrap(), + CodecState::Unpack29(_) + )); + f.unp_ver = 36; + assert!(matches!( + CodecState::new_for(&f).unwrap(), + CodecState::Unpack29(_) + )); + f.unp_ver = 14; + f.method = 0x35; + assert!(matches!( + CodecState::new_for(&f), + Err(Error::UnsupportedCompression { + unpack_version: 14, + method: 0x35, + .. + }) + )); + } + + #[test] + fn codec_state_supports_matches_codec_to_file_version() { + let mut f = file(b"a", 0); + + f.unp_ver = 15; + let unpack15 = CodecState::new_for(&f).unwrap(); + assert!(unpack15.supports(&f)); + f.unp_ver = 20; + assert!(!unpack15.supports(&f)); + f.unp_ver = 29; + assert!(!unpack15.supports(&f)); + + f.unp_ver = 20; + let unpack20 = CodecState::new_for(&f).unwrap(); + assert!(unpack20.supports(&f)); + f.unp_ver = 26; + assert!(unpack20.supports(&f)); + f.unp_ver = 15; + assert!(!unpack20.supports(&f)); + f.unp_ver = 29; + assert!(!unpack20.supports(&f)); + + f.unp_ver = 29; + let unpack29 = CodecState::new_for(&f).unwrap(); + assert!(unpack29.supports(&f)); + f.unp_ver = 36; + assert!(unpack29.supports(&f)); + f.unp_ver = 20; + assert!(!unpack29.supports(&f)); + } + + #[test] + fn decoder_session_empty_compressed_payload_does_not_reset_solid_codec() { + let mut session = DecoderSession::new(true); + let mut first = file(b"first.txt", 0); + first.unp_ver = 29; + first.method = 0x35; + session.codec = Some(CodecState::new_for(&first).unwrap()); + session.decoded_files = 4; + + let mut empty = file(b"empty.txt", super::super::FHD_SOLID); + empty.unp_ver = 20; + empty.method = 0x33; + empty.file_crc = 0; + let archive = Archive { + sfx_offset: 0, + main: MainHeader { + head_crc: 0, + flags: super::super::MHD_SOLID, + head_size: 13, + reserved1: 0, + reserved2: 0, + encrypt_version: None, + }, + blocks: vec![Block::File(empty.clone())], + source: ArchiveSource::Memory(Arc::from([])), + }; + + let mut out = Vec::new(); + session.write_file_to(&archive, &empty, &mut out).unwrap(); + + assert!(out.is_empty()); + assert_eq!(session.decoded_files, 4); + assert!(matches!(session.codec, Some(CodecState::Unpack29(_)))); + } + + #[test] + fn empty_compressed_data_decode_preserves_solid_state_and_checks_crc() { + let mut session = DecoderSession::new(true); + let mut entry = file(b"empty.txt", super::super::FHD_SOLID); + entry.method = 0x35; + session.codec = Some(CodecState::new_for(&entry).unwrap()); + session.decoded_files = 2; + let archive = archive_with(vec![Block::File(entry.clone())]); + + assert_eq!(session.decode_file_data(&archive, &entry).unwrap(), b""); + assert_eq!(session.decoded_files, 2); + assert!(matches!(session.codec, Some(CodecState::Unpack29(_)))); + + entry.file_crc = 1; + assert!(matches!( + session.decode_file_data(&archive, &entry), + Err(Error::Crc32Mismatch { + expected: 1, + actual: 0 + }) + )); + assert_eq!(session.decoded_files, 2); + } + + #[test] + #[cfg(feature = "encryption")] + fn split_cipher_new_rejects_unsupported_unpack_version() { + for ver in [14u8, 16, 19, 25, 27, 28] { + assert!( + matches!( + SplitCipher::new(ver, b"pw", None), + Err(Error::UnsupportedEncryption { unpack_version, .. }) if unpack_version == ver + ), + "unp_ver {ver} should be rejected" + ); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_rejects_non_utf8_rar30_password() { + let result = DecryptingReader::new(Cursor::new(Vec::::new()), 29, &[0xff], None); + assert!(matches!( + result, + Err(Error::Rar30Crypto(Rar30Error::NonUtf8Password)) + )); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_new_rejects_unsupported_unpack_version() { + let result = DecryptingReader::new(Cursor::new(Vec::::new()), 25, b"pw", None); + assert!(matches!( + result, + Err(Error::UnsupportedEncryption { + unpack_version: 25, + .. + }) + )); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_rejects_non_block_aligned_rar20_payload() { + let mut payload = vec![0u8; 23]; + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut payload[..16]) + .unwrap(); + let mut reader = DecryptingReader::new(Cursor::new(payload), 20, b"pw", None).unwrap(); + let mut buf = [0u8; 64]; + let err = loop { + match reader.read(&mut buf) { + Ok(0) => panic!("expected non-block-aligned data error"), + Ok(_) => continue, + Err(err) => break err, + } + }; + assert_eq!(err.kind(), std::io::ErrorKind::InvalidData); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_reports_rar30_body_crypto_errors_without_header_context() { + let error = super::map_rar30_crypto_error(Rar30Error::UnalignedInput); + assert!(matches!( + error, + Error::Rar30Crypto(Rar30Error::UnalignedInput) + )); + assert_eq!(error.to_string(), "RAR 3.x AES input is not block aligned"); + + let mapped = + file(b"encrypted.bin", FHD_PASSWORD).map_encrypted_payload_error(Some(b"pw"), error); + assert_eq!(mapped, Error::WrongPasswordOrCorruptData); + } + + #[test] + fn pending_split_refs_fragment_reader_chains_unencrypted_volumes() { + let plain: &[u8] = b"hello, this string is split across two volumes!"; + let split = 11usize; + + let mut first = file(b"a.txt", FHD_SPLIT_AFTER); + first.pack_size = split as u64; + first.packed_range = 0..split; + let mut second = file(b"a.txt", FHD_SPLIT_BEFORE); + second.pack_size = (plain.len() - split) as u64; + second.packed_range = 0..(plain.len() - split); + + let mut pending = PendingSplitRefs::new(&first, 0, 0); + pending.append(&second, 1, 0).unwrap(); + let volumes = vec![ + archive_with_source(vec![Block::File(first)], plain[..split].to_vec()), + archive_with_source(vec![Block::File(second)], plain[split..].to_vec()), + ]; + + let reader = pending.fragment_reader(&volumes, None).unwrap(); + let out = read_in_small_chunks(reader); + assert_eq!(out, plain); + } + + #[test] + fn pending_split_refs_packed_size_sums_fragment_pack_sizes() { + let mut first = file(b"a.txt", FHD_SPLIT_AFTER); + first.pack_size = 7; + let mut second = file(b"a.txt", FHD_SPLIT_BEFORE); + second.pack_size = 5; + + let mut pending = PendingSplitRefs::new(&first, 0, 0); + pending.append(&second, 1, 0).unwrap(); + let volumes = vec![ + archive_with(vec![Block::File(first)]), + archive_with(vec![Block::File(second)]), + ]; + assert_eq!(pending.packed_size(&volumes).unwrap(), 12); + } + + #[test] + fn pending_split_refs_rejects_advertised_packed_size_overflow() { + let mut first = file(b"a.txt", FHD_SPLIT_AFTER); + first.pack_size = u64::MAX; + let mut second = file(b"a.txt", FHD_SPLIT_BEFORE); + second.pack_size = 1; + + let mut pending = PendingSplitRefs::new(&first, 0, 0); + pending.append(&second, 1, 0).unwrap(); + let volumes = vec![ + archive_with(vec![Block::File(first)]), + archive_with(vec![Block::File(second)]), + ]; + assert_eq!( + pending.packed_size(&volumes).unwrap_err(), + Error::InvalidHeader("RAR 1.5 split packed size overflows usize") + ); + } + + #[derive(Default, Clone)] + struct Capture { + bytes: std::rc::Rc>>, + opened: std::rc::Rc>>, + } + + struct CaptureWriter(std::rc::Rc>>); + + impl Write for CaptureWriter { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + impl Capture { + fn opener(&self) -> impl FnMut(&ExtractedEntryMeta) -> Result> + '_ { + let bytes = self.bytes.clone(); + let opened = self.opened.clone(); + move |meta| { + opened.borrow_mut().push(meta.clone()); + Ok(Box::new(CaptureWriter(bytes.clone()))) + } + } + } + + #[test] + fn parallel_extraction_keeps_directory_callbacks_and_split_fallback() { + let directory = file(b"dir", FHD_DIRECTORY_MASK); + let archive = archive_with(vec![Block::File(directory.clone())]); + let capture = Capture::default(); + archive + .extract_to_parallel_buffered(crate::ArchiveReadOptions::new(), capture.opener()) + .unwrap(); + assert!(capture.opened.borrow()[0].is_directory); + let mut bytes = vec![]; + directory.write_to(&archive, None, &mut bytes).unwrap(); + assert!(bytes.is_empty()); + for flag in [FHD_SPLIT_BEFORE, FHD_SPLIT_AFTER] { + let archive = archive_with(vec![Block::File(file(b"split", flag))]); + let error = archive + .extract_to_parallel_buffered(crate::ArchiveReadOptions::new(), |_| { + panic!("split cannot open output") + }) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::InvalidHeader("RAR 1.5 split entry requires multivolume extraction") + )); + } + } + + #[test] + fn extract_volumes_to_invokes_open_for_directory_entries() { + let dir = file(b"d", FHD_DIRECTORY_MASK); + let volumes = vec![archive_with(vec![Block::File(dir)])]; + + let capture = Capture::default(); + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap(); + + let opened = capture.opened.borrow(); + assert_eq!(opened.len(), 1); + assert_eq!(opened[0].name, b"d"); + assert!(opened[0].is_directory); + assert!(capture.bytes.borrow().is_empty()); + } + + #[test] + fn extract_volumes_to_writes_stored_file_payload_and_verifies_crc() { + let payload = b"hello stored payload!".to_vec(); + let mut entry = file(b"hello.txt", 0); + entry.unp_ver = 20; + entry.pack_size = payload.len() as u64; + entry.unp_size = payload.len() as u64; + entry.packed_range = 0..payload.len(); + entry.file_crc = super::super::crc32(&payload); + + let volumes = vec![archive_with_source( + vec![Block::File(entry)], + payload.clone(), + )]; + + let capture = Capture::default(); + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap(); + + assert_eq!(capture.bytes.borrow().as_slice(), payload.as_slice()); + let opened = capture.opened.borrow(); + assert_eq!(opened.len(), 1); + assert_eq!(opened[0].name, b"hello.txt"); + assert!(!opened[0].is_directory); + } + + #[test] + fn extract_volumes_to_reports_stored_crc_mismatch_with_entry_context() { + let payload = b"crc mismatch payload".to_vec(); + let mut entry = file(b"bad.txt", 0); + entry.unp_ver = 20; + entry.pack_size = payload.len() as u64; + entry.unp_size = payload.len() as u64; + entry.packed_range = 0..payload.len(); + entry.file_crc = super::super::crc32(&payload).wrapping_add(1); + + let volumes = vec![archive_with_source( + vec![Block::File(entry)], + payload.clone(), + )]; + + let capture = Capture::default(); + let err = extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap_err(); + assert!( + matches!(err, Error::AtEntry { .. }), + "expected Error::AtEntry, got {err:?}" + ); + } + + #[test] + fn extract_volumes_to_writes_split_stored_file_across_volumes() { + let payload = b"this stored payload spans two volumes".to_vec(); + let split = 13usize; + + let mut first = file(b"split.txt", FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = split as u64; + first.unp_size = payload.len() as u64; + first.packed_range = 0..split; + first.file_crc = super::super::crc32(&payload); + + let mut second = file(b"split.txt", FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = (payload.len() - split) as u64; + second.unp_size = payload.len() as u64; + second.packed_range = 0..(payload.len() - split); + second.file_crc = super::super::crc32(&payload); + + let volumes = vec![ + archive_with_source(vec![Block::File(first)], payload[..split].to_vec()), + archive_with_source(vec![Block::File(second)], payload[split..].to_vec()), + ]; + + let capture = Capture::default(); + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap(); + + assert_eq!(capture.bytes.borrow().as_slice(), payload.as_slice()); + let opened = capture.opened.borrow(); + assert_eq!(opened.len(), 1); + assert_eq!(opened[0].name, b"split.txt"); + } + + #[test] + fn extract_volumes_to_rejects_split_stored_size_mismatch() { + let payload = b"split stored mismatch".to_vec(); + let split = 10usize; + let truncated = payload.len() - 3; + + let mut first = file(b"a.txt", FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = split as u64; + first.unp_size = payload.len() as u64; + first.packed_range = 0..split; + + let mut second = file(b"a.txt", FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = (truncated - split) as u64; + second.unp_size = payload.len() as u64; + second.packed_range = 0..(truncated - split); + + let volumes = vec![ + archive_with_source(vec![Block::File(first)], payload[..split].to_vec()), + archive_with_source( + vec![Block::File(second)], + payload[split..truncated].to_vec(), + ), + ]; + + let capture = Capture::default(); + let err = extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap_err(); + assert!( + matches!(err, Error::InvalidHeader(_)), + "expected Error::InvalidHeader, got {err:?}" + ); + } + + #[test] + fn split_stored_extraction_rejects_file_source_truncated_after_header_read() { + let payload = b"split file source can change"; + let split = 10; + let crc = super::super::crc32(payload); + let mut first = file(b"split.txt", FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = split as u64; + first.unp_size = payload.len() as u64; + first.packed_range = 0..split; + first.file_crc = crc; + + let mut second = file(b"split.txt", FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = (payload.len() - split) as u64; + second.unp_size = payload.len() as u64; + second.packed_range = 0..payload.len() - split; + second.file_crc = crc; + + let scratch = crate::scratch::case("legacy-split-truncated-source"); + let path = scratch.join("second.part"); + std::fs::write(&path, &payload[split..]).unwrap(); + let mut second_volume = archive_with(vec![Block::File(second)]); + second_volume.source = ArchiveSource::File(Arc::new(path.clone())); + std::fs::write(&path, &payload[split..payload.len() - 3]).unwrap(); + + let volumes = [ + archive_with_source(vec![Block::File(first)], payload[..split].to_vec()), + second_volume, + ]; + let err = extract_volumes_to(&volumes, crate::ArchiveReadOptions::default(), |_| { + Ok(Box::new(std::io::sink())) + }) + .unwrap_err(); + assert!(matches!( + err, + Error::InvalidHeader("RAR 1.5 split stored file ended before unpacked size") + )); + } + + #[test] + fn decoder_session_codec_for_resets_when_unpack_version_changes() { + let mut session = DecoderSession::new(true); + let mut f = file(b"a", 0); + f.unp_ver = 20; + assert!(matches!( + session.codec_for(&f).unwrap(), + CodecState::Unpack20(_) + )); + let mut g = file(b"b", 0); + g.unp_ver = 29; + assert!(matches!( + session.codec_for(&g).unwrap(), + CodecState::Unpack29(_) + )); + let mut h = file(b"c", 0); + h.unp_ver = 15; + assert!(matches!( + session.codec_for(&h).unwrap(), + CodecState::Unpack15(_) + )); + } + + #[test] + fn decoder_session_codec_for_propagates_unsupported_compression() { + let mut session = DecoderSession::new(false); + let mut f = file(b"a", 0); + f.unp_ver = 14; + assert!(matches!( + session.codec_for(&f), + Err(Error::UnsupportedCompression { + unpack_version: 14, + .. + }) + )); + } + + #[test] + fn decoder_session_codec_for_reuses_codec_in_solid_mode() { + let mut session = DecoderSession::new(true); + let mut f = file(b"a", 0); + f.unp_ver = 29; + let first = session.codec_for(&f).unwrap() as *const CodecState; + let second = session.codec_for(&f).unwrap() as *const CodecState; + assert_eq!(first, second); + } + + #[test] + fn public_file_writer_dispatches_stored_data_without_a_codec_session() { + let payload = b"decode_file_data stored dispatch".to_vec(); + let crc = super::super::crc32(&payload); + for unp_ver in [15u8, 20, 26, 29] { + let mut entry = file(b"a.txt", 0); + entry.unp_ver = unp_ver; + entry.pack_size = payload.len() as u64; + entry.unp_size = payload.len() as u64; + entry.packed_range = 0..payload.len(); + entry.file_crc = crc; + + let archive = archive_with_source(vec![Block::File(entry.clone())], payload.clone()); + let mut data = Vec::new(); + entry + .write_to(&archive, None, &mut data) + .unwrap_or_else(|err| panic!("write for unp_ver {unp_ver}: {err:?}")); + assert_eq!(data, payload, "unp_ver {unp_ver} payload mismatch"); + } + } + + #[test] + fn extraction_rejects_stored_members_with_mismatched_packed_size() { + let data = b"payload"; + for unpacked_size in [data.len() as u64 - 1, data.len() as u64 + 1] { + let mut entry = file(b"stored.txt", 0); + entry.pack_size = data.len() as u64; + entry.unp_size = unpacked_size; + entry.packed_range = 0..data.len(); + let archive = archive_with_source(vec![Block::File(entry)], data.to_vec()); + + for parallel in [false, true] { + let open = |_: &ExtractedEntryMeta| Ok(Box::new(std::io::sink()) as Box); + let result = if parallel { + archive.extract_to_parallel_buffered(crate::ArchiveReadOptions::default(), open) + } else { + archive.extract_to(crate::ArchiveReadOptions::default(), open) + }; + let error = result.expect_err("stored member size mismatch must fail"); + assert!(matches!(error.root_cause(), Error::InvalidHeader(_))); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_works_through_boxed_inner_reader() { + let plain = *b"0123456789abcdefRAR2 block two!!"; + let mut encrypted = plain; + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(); + let inner: Box = Box::new(Cursor::new(encrypted.to_vec())); + let reader = DecryptingReader::new(inner, 20, b"pw", None).unwrap(); + let out = read_in_small_chunks(reader); + + assert_eq!(out, plain); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_boxed_inner_rejects_non_block_aligned_eof() { + let mut payload = vec![0u8; 32]; + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut payload[..16]) + .unwrap(); + // 23 bytes of trailing data (not a multiple of 16) — should error at EOF. + payload.truncate(23); + let inner: Box = Box::new(Cursor::new(payload)); + let mut reader = DecryptingReader::new(inner, 20, b"pw", None).unwrap(); + let mut buf = [0u8; 64]; + let err = loop { + match reader.read(&mut buf) { + Ok(0) => panic!("expected non-block-aligned data error"), + Ok(_) => continue, + Err(err) => break err, + } + }; + assert_eq!(err.kind(), std::io::ErrorKind::InvalidData); + } + + #[test] + fn split_solid_rar29_member_keeps_history_from_regular_predecessor() { + let archive = Archive::parse(include_bytes!( + "../../tests/fixtures/rar15_40/rar300/solid_simple_rar300.rar" + )) + .unwrap(); + let files: Vec<_> = archive.files().cloned().collect(); + assert_eq!(files.len(), 2); + assert!(files[1].is_solid()); + let mut first_part = files[1].clone(); + let mut last_part = first_part.clone(); + let middle = first_part.packed_range.start + first_part.packed_range.len() / 2; + first_part.block.flags |= FHD_SPLIT_AFTER; + first_part.packed_range.end = middle; + first_part.pack_size = first_part.packed_range.len() as u64; + last_part.block.flags |= FHD_SPLIT_BEFORE; + last_part.packed_range.start = middle; + last_part.pack_size = last_part.packed_range.len() as u64; + let mut volume1 = archive.clone(); + volume1.blocks = vec![Block::File(files[0].clone()), Block::File(first_part)]; + let mut volume2 = archive; + volume2.blocks = vec![Block::File(last_part)]; + let capture = Capture::default(); + extract_volumes_to( + &[volume1, volume2], + crate::ArchiveReadOptions::default(), + capture.opener(), + ) + .unwrap(); + assert_eq!(capture.opened.borrow().len(), 2); + assert_eq!(capture.bytes.borrow().as_slice(), + b"shared prefix shared prefix shared prefix alpha\nshared prefix shared prefix shared prefix beta\n"); + } + + #[test] + #[cfg(feature = "encryption")] + fn split_rar15_encrypted_stored_member_has_no_block_padding() { + let payload = b"legacy byte cipher split"; + let mut encrypted = payload.to_vec(); + Rar15Cipher::new(b"pw").crypt_in_place(&mut encrypted); + let split = 7; + let mut first = file(b"split", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.unp_ver = 15; + first.unp_size = payload.len() as u64; + first.pack_size = split as u64; + first.packed_range = 0..split; + first.file_crc = crc32(payload); + let mut last = first.clone(); + last.block.flags = FHD_PASSWORD | FHD_SPLIT_BEFORE; + last.pack_size = (payload.len() - split) as u64; + last.packed_range = 0..payload.len() - split; + let volumes = [ + archive_with_source(vec![Block::File(first)], encrypted[..split].to_vec()), + archive_with_source(vec![Block::File(last)], encrypted[split..].to_vec()), + ]; + let capture = Capture::default(); + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::with_password(b"pw"), + capture.opener(), + ) + .unwrap(); + assert_eq!(capture.bytes.borrow().as_slice(), payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn extract_volumes_to_assembles_encrypted_stored_split_across_two_volumes() { + let payload: &[u8] = b"twenty-byte payload!"; // exactly 20 bytes + let unpacked_len = payload.len(); + assert_eq!(unpacked_len, 20); + let padded_len = (unpacked_len + 15) & !15; // 32 + let mut encrypted = vec![0u8; padded_len]; + encrypted[..unpacked_len].copy_from_slice(payload); + Rar20Cipher::new(b"pw") + .encrypt_in_place(&mut encrypted) + .unwrap(); + let split = 13usize; + let crc = super::super::crc32(payload); + + let mut first = file(b"split.bin", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = split as u64; + first.unp_size = unpacked_len as u64; + first.packed_range = 0..split; + first.file_crc = crc; + + let mut second = file(b"split.bin", FHD_PASSWORD | FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = (padded_len - split) as u64; + second.unp_size = unpacked_len as u64; + second.packed_range = 0..(padded_len - split); + second.file_crc = crc; + + let volumes = vec![ + archive_with_source(vec![Block::File(first)], encrypted[..split].to_vec()), + archive_with_source(vec![Block::File(second)], encrypted[split..].to_vec()), + ]; + + let capture = Capture::default(); + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::with_password(b"pw"), + capture.opener(), + ) + .unwrap(); + + assert_eq!(capture.bytes.borrow().as_slice(), payload); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_stored_split_rejects_unpacked_size_rounding_overflow() { + let mut first = file(b"overflow", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.unp_size = u64::MAX; + first.pack_size = 16; + first.packed_range = 0..16; + let mut last = first.clone(); + last.block.flags = FHD_PASSWORD | FHD_SPLIT_BEFORE; + let volumes = [ + archive_with_source(vec![Block::File(first)], vec![0; 16]), + archive_with_source(vec![Block::File(last)], vec![0; 16]), + ]; + let capture = Capture::default(); + let error = extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::with_password(b"pw"), + capture.opener(), + ) + .unwrap_err(); + let expected = if usize::BITS == 64 { + "RAR 2.x encrypted split stored size overflows" + } else { + "RAR 1.5 split unpacked size overflows usize" + }; + assert!( + matches!(error.root_cause(), Error::InvalidHeader(message) if *message == expected) + ); + assert!(capture.bytes.borrow().is_empty()); + } + + #[test] + #[cfg(feature = "encryption")] + fn extract_volumes_to_rejects_encrypted_stored_split_when_padded_size_disagrees() { + let unpacked_len = 20usize; + // Two volumes total only 30 bytes, but expected_packed_len == 32. + let payload = [0u8; 30]; + + let mut first = file(b"split.bin", FHD_PASSWORD | FHD_SPLIT_AFTER); + first.unp_ver = 20; + first.pack_size = 13; + first.unp_size = unpacked_len as u64; + first.packed_range = 0..13; + + let mut second = file(b"split.bin", FHD_PASSWORD | FHD_SPLIT_BEFORE); + second.unp_ver = 20; + second.pack_size = 17; + second.unp_size = unpacked_len as u64; + second.packed_range = 0..17; + + let volumes = vec![ + archive_with_source(vec![Block::File(first)], payload[..13].to_vec()), + archive_with_source(vec![Block::File(second)], payload[13..].to_vec()), + ]; + + let capture = Capture::default(); + let err = extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::with_password(b"pw"), + capture.opener(), + ) + .unwrap_err(); + assert!( + matches!(err, Error::InvalidHeader(msg) if msg.contains("wrong reassembled size")), + "expected wrong reassembled size error, got {err:?}" + ); + } +} diff --git a/arca-rar/vendor/rars/src/rar15_40/write.rs b/arca-rar/vendor/rars/src/rar15_40/write.rs new file mode 100644 index 00000000..4dbae85f --- /dev/null +++ b/arca-rar/vendor/rars/src/rar15_40/write.rs @@ -0,0 +1,3829 @@ +use super::*; +use crate::codec::rar13::{ + unpack15_encode_with_options_and_progress, EncodeOptions as Rar15EncodeOptions, Unpack15Encoder, +}; +use crate::codec::rar20::{ + unpack20_encode_auto_with_options_and_progress, EncodeOptions as Rar20EncodeOptions, + Unpack20Encoder, +}; +use crate::codec::rar29::{ + unpack29_encode_literals, unpack29_encode_literals_with_options, + unpack29_encode_literals_with_options_and_progress, ChainEngine, + EncodeOptions as Rar29EncodeOptions, Unpack29Encoder, +}; +use crate::crc32::Crc32; +pub use crate::filter::{FilterKind, FilterPolicy, FilterSpec}; +pub use crate::streaming::EntrySource; +use crate::streaming::WriterResources; +use crate::write_plan::{MemberCoding, PlanShape, WriterOption}; +use crate::write_progress::{ProgressReporter, WorkTracker}; +use crate::write_stream::{MemberBytes, MemberPayload}; +use crate::FeatureSet; +use crate::{WriteOperation, WriteProgress, WriteProgressEvent}; +use std::io::Write; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct WriterOptions { + pub target: ArchiveVersion, + pub features: FeatureSet, + pub compression_level: Option, + pub dictionary_size: Option, + /// Which engine compresses a member. Only the RAR 2.9 family has more than + /// one, so the other targets ignore anything but the default. + pub method: Rar29Method, + /// Retained NewSub comment DOS timestamp and host ID. + pub(crate) archive_comment_metadata: Option<(u32, u8)>, +} + +/// Which compression engine the RAR 2.9 family writer uses for a member. +/// +/// PPMd is an alternative to LZ, not a filter, even though the writer used to +/// carry it as one. Keeping the two apart is what lets a filter be chosen +/// without also deciding the engine. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +#[non_exhaustive] +pub enum Rar29Method { + /// Let the content decide. Text-shaped members are measured against PPMd; + /// anything else goes straight to LZ, so a binary member never pays for a + /// PPMd encode it was always going to lose. Compression levels 1 to 4 skip + /// the trial entirely, since those settings are asking for speed. + #[default] + Auto, + Lz, + Ppmd, +} + +impl WriterOptions { + pub const fn new(target: ArchiveVersion, features: FeatureSet) -> Self { + Self { + target, + features, + compression_level: None, + dictionary_size: None, + method: Rar29Method::Auto, + archive_comment_metadata: None, + } + } + + pub const fn with_method(mut self, method: Rar29Method) -> Self { + self.method = method; + self + } + + pub const fn with_compression_level(mut self, level: u8) -> Self { + self.compression_level = Some(level); + self + } + + pub const fn with_dictionary_size(mut self, size: usize) -> Self { + self.dictionary_size = Some(size); + self + } +} + +impl Default for WriterOptions { + fn default() -> Self { + Self { + target: ArchiveVersion::Rar15, + features: FeatureSet::store_only(), + compression_level: None, + dictionary_size: None, + method: Rar29Method::Auto, + archive_comment_metadata: None, + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct StoredEntry<'a> { + pub name: &'a [u8], + pub data: &'a [u8], + pub file_time: u32, + pub file_attr: u32, + pub host_os: u8, + pub password: Option<&'a [u8]>, + pub file_comment: Option<&'a [u8]>, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct FileEntry<'a> { + pub name: &'a [u8], + pub data: &'a [u8], + pub file_time: u32, + pub file_attr: u32, + pub host_os: u8, + pub password: Option<&'a [u8]>, + pub file_comment: Option<&'a [u8]>, +} + +/// One member of an archive written a member at a time. +/// +/// The bytes are opened when the member is coded and dropped once it is +/// written, so an archive of many files never holds more than the members +/// being worked on. A stored member is copied straight from its source and +/// never lands on the heap at all. +#[derive(Debug, Clone)] +pub struct StreamingEntry { + pub name: Vec, + pub source: EntrySource, + pub file_time: u32, + pub file_attr: u32, + pub host_os: u8, + pub password: Option>, + pub file_comment: Option>, +} + +impl StreamingEntry { + pub fn new(name: impl Into>, source: EntrySource) -> Self { + Self { + name: name.into(), + source, + file_time: 0, + file_attr: 0, + host_os: 3, + password: None, + file_comment: None, + } + } + + pub fn with_file_time(mut self, file_time: u32) -> Self { + self.file_time = file_time; + self + } + + pub fn with_file_attr(mut self, file_attr: u32) -> Self { + self.file_attr = file_attr; + self + } + + pub fn with_host_os(mut self, host_os: u8) -> Self { + self.host_os = host_os; + self + } + + pub fn with_password(mut self, password: impl Into>) -> Self { + self.password = Some(password.into()); + self + } + + pub fn with_file_comment(mut self, comment: impl Into>) -> Self { + self.file_comment = Some(comment.into()); + self + } +} + +#[cfg(any(test, feature = "encryption"))] +fn checked_align16(value: usize, message: &'static str) -> Result { + value + .checked_add(15) + .map(|size| size & !15) + .ok_or(Error::InvalidArgument(message)) +} + +const AUTO_RGB_WIDTHS: [usize; 4] = [24, 48, 96, 192]; +const MIN_STORE_FALLBACK_SIZE: usize = 1024; +const RAR29_TEXT_SAMPLE_SIZE: usize = 8192; + +/// How long a run of NUL has to be before the text screen reads it as padding +/// and stops counting it either way. +/// +/// Sixteen is well past what falls out of text (a run of NUL in a source file +/// is already unusual) and well short of the 512 byte blocks tar pads to. +/// Measured across 400 binaries over 200 KB in `/usr/bin` and +/// `/usr/lib/x86_64-linux-gnu`, 8, 16 and 32 all give the same answer, so the +/// exact number is not load-bearing. +const RAR29_NUL_RUN_IS_PADDING: usize = 16; + +/// The level an absent `--level` means for RAR 2.0, matching the method byte +/// `compression_method_for_level` writes for it. +const RAR20_DEFAULT_LEVEL: u8 = 3; +const RAR29_AUDIO_SAMPLE_SIZE: usize = 8192; +/// How much data one RAR 2.9 LZ block covers. +/// +/// Every block carries its own Huffman tables, so this is the distance over +/// which the tables have to fit the data. A megabyte was far too long a lease: +/// a binary's code and its data want different tables, and one set fitted to +/// both is worse than either. Measured on `--level 5`, packed bytes: +/// +/// ```text +/// block 16K 32K 64K 128K 1M +/// libc 686400 683942 684278 704689 797692 +/// python 632452 628926 627862 648835 738624 +/// mixed 136376 135530 135264 146831 149372 +/// lorem 16186 16186 16186 16186 16186 +/// ``` +/// +/// 64K is the best or within a rounding error of it on everything measured, +/// and text does not care either way. The curve turns back up below 32K, where +/// re-sending the tables starts to cost more than fitting them gains. +const RAR29_LZ_BLOCK_SIZE: usize = 64 * 1024; + +/// The largest dictionary the format encodes, used when a memory estimate +/// cannot resolve the real one. It has to stay an upper bound, so it does not +/// follow the block size. +const RAR29_MAX_DICTIONARY_SIZE: usize = 4 * 1024 * 1024; +#[cfg(feature = "encryption")] +const RAR15_ALIGN_OVERFLOW: &str = "RAR 1.5 block size overflows usize"; + +pub fn write_stored_archive( + entries: &[StoredEntry<'_>], + options: WriterOptions, +) -> Result> { + write_stored_archive_with_comment(entries, options, None) +} + +pub fn write_stored_archive_with_comment( + entries: &[StoredEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, +) -> Result> { + let members: Vec<_> = entries.iter().map(Member::from_stored).collect(); + collect_archive( + &members, + options, + MemberCoding::Stored, + archive_comment, + None, + ) +} + +pub(crate) struct RetainedMemberMetadata<'a> { + pub(crate) unicode_name: Option<&'a [u8]>, + pub(crate) unpack_version: Option, + pub(crate) extended_times: Option<&'a [u8]>, + pub(crate) is_directory: bool, + pub(crate) is_symlink: bool, +} + +pub(crate) struct RetainedFileEntry<'a> { + pub(crate) file: FileEntry<'a>, + pub(crate) source: Option<&'a EntrySource>, + pub(crate) metadata: RetainedMemberMetadata<'a>, +} + +/// Builder path for retained native metadata and entry kinds. Existing direct +/// entry structs keep their API. +#[allow(clippy::too_many_arguments)] +pub(crate) fn write_archive_with_retained_metadata( + entries: &[RetainedFileEntry<'_>], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + header_password: Option<&[u8]>, + archive_comment_password: Option<&[u8]>, + output: &mut dyn Write, +) -> Result<()> { + // Builder validates retained records at their setters and constructs each + // file with its metadata, so neither record validity nor array length can + // change at this private handoff. + let members: Vec<_> = entries + .iter() + .map(|entry| { + let mut member = Member::from_file(&entry.file); + if let Some(source) = entry.source { + member.bytes = MemberBytes::NamedSource(source, entry.file.name); + } + member.unicode_name = entry.metadata.unicode_name; + member.unpack_version = entry.metadata.unpack_version; + member.extended_times = entry.metadata.extended_times; + member.is_directory = entry.metadata.is_directory; + member.is_symlink = entry.metadata.is_symlink; + member + }) + .collect(); + write_archive_to( + &members, + options, + coding, + archive_comment, + resources, + progress, + output, + header_password, + archive_comment_password, + ) +} + +pub fn write_compressed_archive( + entries: &[FileEntry<'_>], + options: WriterOptions, +) -> Result> { + write_compressed_archive_with_comment(entries, options, None) +} + +pub fn write_compressed_archive_with_comment( + entries: &[FileEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, +) -> Result> { + write_compressed_archive_with_comment_and_progress(entries, options, archive_comment, None) +} + +pub fn write_compressed_archive_with_comment_and_progress( + entries: &[FileEntry<'_>], + options: WriterOptions, + archive_comment: Option<&[u8]>, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let members: Vec<_> = entries.iter().map(Member::from_file).collect(); + collect_archive( + &members, + options, + MemberCoding::Compressed, + archive_comment, + progress, + ) +} + +pub fn write_rar29_compressed_archive_with_filter_policy( + entries: &[FileEntry<'_>], + options: WriterOptions, + policy: FilterPolicy, +) -> Result> { + write_rar29_compressed_archive_with_filter_policy_and_progress(entries, options, policy, None) +} + +pub fn write_rar29_compressed_archive_with_filter_policy_and_progress( + entries: &[FileEntry<'_>], + options: WriterOptions, + policy: FilterPolicy, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let members: Vec<_> = entries.iter().map(Member::from_file).collect(); + collect_archive( + &members, + options, + MemberCoding::Filtered(policy), + None, + progress, + ) +} + +/// Writes an archive straight to `output`, holding only the members being +/// compressed rather than every input at once. +/// +/// `resources` bounds how many members are in flight, which is what keeps the +/// peak flat across an archive of many files. One member still has to fit: +/// these codecs compress a member as a unit, so a member larger than the budget +/// is compressed on its own rather than refused. +pub fn write_streaming_archive_to( + entries: &[StreamingEntry], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, +) -> Result<()> { + let members: Vec<_> = entries.iter().map(Member::from_streaming).collect(); + write_archive_to( + &members, + options, + coding, + archive_comment, + resources, + progress, + output, + None, + None, + ) +} + +/// Runs the streaming writer into a buffer, for the callers that want the +/// archive as bytes. The budget still applies, so a many-file archive holds one +/// window of members rather than all of them. +fn collect_archive( + members: &[Member<'_>], + options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + progress: Option<&dyn WriteProgress>, +) -> Result> { + let mut out = Vec::new(); + write_archive_to( + members, + options, + coding, + archive_comment, + &WriterResources::default(), + progress, + &mut out, + None, + None, + )?; + Ok(out) +} + +#[allow(clippy::too_many_arguments)] +fn write_archive_to( + members: &[Member<'_>], + mut options: WriterOptions, + coding: MemberCoding, + archive_comment: Option<&[u8]>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, + explicit_header_password: Option<&[u8]>, + archive_comment_password: Option<&[u8]>, +) -> Result<()> { + if explicit_header_password.is_some() + || archive_comment_password.is_some() + || members.iter().any(|member| member.password.is_some()) + { + crate::crypto::require_encryption()?; + } + + if resources.max_preparation_bytes().is_some() || resources.max_memory_bytes().is_some() { + return Err(Error::UnsupportedFamilyFeature { + family: options.target.family(), + feature: if resources.max_memory_bytes().is_some() { + "aggregate managed-memory limit" + } else { + "preparation memory quota" + }, + }); + } + + if let Some(password) = archive_comment_password { + if password.is_empty() + || archive_comment.is_none() + || !matches!( + options.target, + ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + ) + { + return Err(Error::InvalidArgument( + "encrypted legacy archive comments require a password and RAR3/4 CMT output", + )); + } + } + let control = + crate::write_progress::ResourceProgress::new(resources, progress.map(ProgressReporter)); + let reporting = &control as &dyn WriteProgress; + let progress = Some(reporting); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + let mut output = crate::write_progress::CancellableIo { + inner: output, + progress: progress.map(ProgressReporter), + }; + let output = &mut output as &mut dyn Write; + let has_file_comment = members.iter().any(|member| member.file_comment.is_some()); + if has_file_comment && options.features.header_encryption { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: WriterOption::FileComment, + because: Some("embedded legacy file comments with header encryption are incompatible with reference readers"), + }); + } + validate_plan( + options, + coding.shape(), + archive_comment.is_some(), + has_file_comment, + )?; + if let MemberCoding::Filtered(policy) = &coding { + validate_rar29_filter_policy(policy, options.method)?; + } + let header_password = if options.features.header_encryption { + validate_header_encrypted_archive_options( + options.target, + explicit_header_password.is_some() + || members.iter().any(|member| member.password.is_some()), + )?; + Some(if let Some(password) = explicit_header_password { + header_encryption_password( + std::iter::once(Some(password)).chain( + members + .iter() + .filter_map(|member| member.password) + .map(Some), + ), + )? + } else { + header_encryption_password(members.iter().map(|member| member.password))? + }) + } else { + None + }; + + let mut total_bytes = 0u64; + let mut largest_member = 0u64; + for member in members { + let unpacked = member.unpacked_size().map_err(|error| { + crate::write_stream::member_error(error, member.name, "reading source") + })? as u64; + total_bytes = total_bytes.saturating_add(unpacked); + largest_member = largest_member.max(unpacked); + } + if options.dictionary_size.is_none() { + // A solid run is one stream, so its window has to reach back across the + // members it already coded; independent members only ever look inside + // themselves. Validation has already rejected solid stored coding. + let reach = if options.features.solid { + total_bytes + } else { + largest_member + }; + options.dictionary_size = Some(fitted_dictionary_size(options.target, reach)); + } + // RAR 2.0 walks a non-solid member twice, once to pick a method and once to + // encode it, so its progress total counts every byte twice. + let total_work = if options.target == ArchiveVersion::Rar20 + && !options.features.solid + && coding.compresses() + { + total_bytes.saturating_mul(2) + } else { + total_bytes + }; + report_compression_operation(reporting, true, total_work, members.len()); + let work = WorkTracker::new( + Some(ProgressReporter(reporting)), + WriteOperation::Compression, + total_work, + ); + + let result = write_members_to( + members, + options, + &coding, + archive_comment, + header_password, + archive_comment_password, + resources, + &work, + output, + ); + result?; + if !work.finish() { + return Err(Error::Cancelled); + } + report_compression_operation(reporting, false, total_work, members.len()); + work.check() +} + +#[allow(clippy::too_many_arguments)] +fn write_members_to( + members: &[Member<'_>], + options: WriterOptions, + coding: &MemberCoding, + archive_comment: Option<&[u8]>, + header_password: Option<&[u8]>, + archive_comment_password: Option<&[u8]>, + resources: &WriterResources, + progress: &WorkTracker<'_>, + output: &mut dyn Write, +) -> Result<()> { + output.write_all(RAR15_SIGNATURE)?; + let mut main_flags = 0; + if options.features.solid { + main_flags |= MHD_SOLID; + } + if header_password.is_some() { + main_flags |= MHD_PASSWORD; + } + if archive_comment.is_some() && uses_old_style_archive_comment(options.target) { + main_flags |= MHD_COMMENT; + } + let mut head = Vec::new(); + write_main_header(&mut head, main_flags); + output.write_all(&head)?; + write_archive_comment( + output, + archive_comment, + options, + header_password, + archive_comment_password, + )?; + + // Solid members share one encoder, so they are coded in order. Independent + // ones are coded a window at a time and written as each window lands. + if options.features.solid { + let mut solid_encoder = Some(SolidEncoder::for_target(options)?); + let mut solid_run_has_member = false; + for member in members { + let encoded = encode_member( + member, + options, + coding, + &mut solid_encoder, + resources, + progress, + ) + .map_err(|error| crate::write_stream::member_error(error, member.name, "preparing"))?; + let solid_continuation = encoded.method != 0x30 && solid_run_has_member; + // Storing a member rebuilds the encoder, so the chain ends there. + // An empty compressed member leaves the chain exactly as it was: + // it feeds the encoder nothing, and readers pass over an empty + // payload without advancing their decoder. Counting one as a + // member left the next one flagged as continuing a chain that had + // been broken by a stored member two places back. + if member.is_directory { + // Directory headers do not participate in the solid stream. + } else if encoded.method == 0x30 { + solid_run_has_member = false; + } else if encoded.unpacked_size != 0 { + solid_run_has_member = true; + } + write_member( + output, + member, + encoded, + options, + solid_continuation, + header_password, + progress.reporter(), + ) + .map_err(|error| crate::write_stream::member_error(error, member.name, "writing"))?; + member.bytes.release(); + } + } else { + // Scoped rewrite sources retain plaintext until emission; their disk + // quota may admit fewer inputs than the CPU pool can prepare at once. + let window = members + .iter() + .filter_map(|member| member.bytes.source()) + .map(EntrySource::max_preparation_window) + .fold(crate::parallel::default_window(), usize::min); + crate::parallel::map_slice_windowed( + members, + window, + |member| { + encode_member(member, options, coding, &mut None, resources, progress).map_err( + |error| crate::write_stream::member_error(error, member.name, "preparing"), + ) + }, + |member, encoded| { + write_member( + output, + member, + encoded, + options, + false, + header_password, + progress.reporter(), + ) + .map_err(|error| { + crate::write_stream::member_error(error, member.name, "writing") + })?; + member.bytes.release(); + Ok(()) + }, + )?; + } + if let Some(password) = header_password { + write_encrypted_end_block(output, password)?; + } + Ok(()) +} + +/// Encodes one member, choosing an engine and a filter independently. +/// +/// The two are separate questions: which engine compresses this content best, +/// and which transform makes it easier to compress. They used to be one enum, +/// which meant some combinations simply could not be asked for. +fn encode_rar29_policy_filtered_payload( + data: &[u8], + policy: &FilterPolicy, + method: Rar29Method, + options: Rar29EncodeOptions, + lz_method: u8, + ppmd_trial: bool, + progress: Option<&WorkTracker<'_>>, +) -> Result { + // An empty member is stored whatever was asked for. A filter over it is a + // 0..0 range, which the codec refuses, so an archive holding one empty file + // used to compress every other member and then fail at the last step. Only + // the search path guarded this; every explicit policy walked into it. + if lz_method == 0x30 || data.is_empty() { + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + // The method byte carries the level that was asked for, not which engine + // answered. RAR 2.9 signals PPMd inside the stream (our own decoder takes + // no method byte at all), and WinRAR 3.00 stamps 0x34 on the PPMd archive + // it writes at -m4. Stamping 0x35 on every PPMd payload only looked right + // while the trial ran at level 5, and made a level 3 archive claim to be a + // level 5 one as soon as it ran anywhere else. + let ppmd = |data: &[u8]| -> Result { + Ok(EncodedPayload { + data: with_codec_progress(progress, |report| { + crate::codec::rar29::unpack29_encode_ppmd_with_progress( + data, + true, + None, + options.max_match_distance, + report, + ) + })?, + method: lz_method, + }) + }; + match (method, policy) { + (Rar29Method::Ppmd, FilterPolicy::None) => ppmd(data), + (Rar29Method::Ppmd, FilterPolicy::Explicit(filter)) => Ok(EncodedPayload { + data: with_codec_progress(progress, |report| { + crate::codec::rar29::unpack29_encode_ppmd_with_progress( + data, + true, + Some(filter.clone()), + options.max_match_distance, + report, + ) + })?, + method: lz_method, + }), + // Filtered writes are rejected before encoding; plain compressed writes + // use FilterPolicy::None when PPMd is forced. + (Rar29Method::Ppmd, FilterPolicy::Auto) => unreachable!(), + (Rar29Method::Lz, FilterPolicy::None) => { + encode_rar29_lz_member(data, options, lz_method, progress) + } + (Rar29Method::Lz, FilterPolicy::Auto) => encode_rar29_auto_filtered_member_with_progress( + data, options, lz_method, false, progress, + ), + (Rar29Method::Lz, FilterPolicy::Explicit(filter)) => Ok(EncodedPayload { + data: with_codec_progress(progress, |report| { + Unpack29Encoder::with_options(options).encode_member_with_filters_and_progress( + data, + std::slice::from_ref(filter), + Some(report), + ) + })?, + method: lz_method, + }), + (Rar29Method::Auto, FilterPolicy::Auto) => encode_rar29_auto_filtered_member_with_progress( + data, options, lz_method, ppmd_trial, progress, + ), + (Rar29Method::Auto, policy) => { + let mut best = match policy { + FilterPolicy::Explicit(filter) => EncodedPayload { + data: with_codec_progress(progress, |report| { + Unpack29Encoder::with_options(options) + .encode_member_with_filters_and_progress( + data, + std::slice::from_ref(filter), + Some(report), + ) + })?, + method: lz_method, + }, + _ => encode_rar29_lz_member(data, options, lz_method, progress)?, + }; + // Gated on the content, so a binary member never pays for a PPMd + // encode it was always going to lose. + if ppmd_trial && is_text_ppmd_candidate(data) { + let candidate = ppmd(data)?; + if candidate.data.len() < best.data.len() { + best = candidate; + } + } + Ok(best) + } + } +} + +/// Whether this level is willing to encode the member twice to choose an engine. +/// +/// Takes the resolved level, not the option. Reading `Option` meant an +/// absent level and `--level 3` disagreed, though both write method 0x33: the +/// default paid for the trial and the level that names the same number did not, +/// so the two produced archives 24% apart on the same 4 MiB of text. +/// +/// Levels 1 and 2 are the ones asking for speed and still skip it. Level 3 is +/// the default and where most archives are written, and it is worth about a +/// fifth of the size on text for roughly twice the encode. WinRAR turns PPMd on +/// one level later, at m4: on the bench text member WinRAR 3.00 packs 657,294 +/// bytes at m3 and 585,357 at m4, where we now write 540,517 at both. +fn ppmd_trial_pays(level: u8) -> bool { + level >= 3 +} + +fn validate_rar29_filter_policy(policy: &FilterPolicy, method: Rar29Method) -> Result<()> { + // Searching for a filter means measuring candidates against each other, + // and the search only knows how to measure them through LZ. + if matches!(policy, FilterPolicy::Auto) && method == Rar29Method::Ppmd { + return Err(Error::InvalidArgument( + "RAR 2.9 cannot search for a filter while PPMd is forced", + )); + } + let filter = match policy { + FilterPolicy::Explicit(filter) => filter, + FilterPolicy::None | FilterPolicy::Auto => return Ok(()), + }; + match filter.kind { + FilterKind::Delta { channels } => { + if channels == 0 || channels > 32 { + return Err(Error::InvalidArgument( + "RAR 2.9 DELTA filter channel count is invalid", + )); + } + } + FilterKind::Audio { channels } => { + if channels == 0 || channels > 32 { + return Err(Error::InvalidArgument( + "RAR 2.9 AUDIO filter channel count is invalid", + )); + } + } + FilterKind::Rgb { width, pos_r } => { + if width == 0 || !width.is_multiple_of(3) || pos_r > 2 { + return Err(Error::InvalidArgument( + "RAR 2.9 RGB filter parameters are invalid", + )); + } + } + FilterKind::E8 | FilterKind::E8E9 | FilterKind::Itanium => {} + // Refused here rather than in the codec, so nothing is compressed + // before the caller is told the filter cannot be written. + FilterKind::Arm => { + return Err(Error::UnsupportedFeature { + version: ArchiveVersion::Rar29, + feature: "ARM filter", + }) + } + } + Ok(()) +} + +fn encode_rar29_lz_member( + data: &[u8], + options: Rar29EncodeOptions, + method: u8, + progress: Option<&WorkTracker<'_>>, +) -> Result { + let compressed = with_codec_progress(progress, |report| { + unpack29_encode_literals_with_options_and_progress(data, options, report) + })?; + if compressed.len() >= data.len() { + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + Ok(EncodedPayload { + data: compressed, + method, + }) +} + +#[cfg(test)] +fn encode_rar29_filtered_member( + data: &[u8], + filter: FilterSpec, + options: Rar29EncodeOptions, +) -> Result> { + Unpack29Encoder::with_options(options) + .encode_member_with_filter(data, filter) + .map_err(Error::from) +} + +#[cfg(test)] +fn encode_rar29_filtered_members( + data: &[u8], + filters: &[FilterSpec], + options: Rar29EncodeOptions, +) -> Result> { + Unpack29Encoder::with_options(options) + .encode_member_with_filters(data, filters) + .map_err(Error::from) +} + +/// How the RAR 2.9 family measures a filter candidate, for the shared search. +#[derive(Clone, Copy)] +struct Rar29Search; + +impl crate::filter_search::FilterSearch for Rar29Search { + type Options = Rar29EncodeOptions; + + fn screened_kinds(&self, data: &[u8]) -> Vec { + let mut kinds = vec![FilterKind::Itanium]; + for channels in 1..=4 { + kinds.push(FilterKind::Delta { channels }); + // Free to ask, and it keeps the screened set from doubling. + if is_audio_filter_candidate(data, channels) { + kinds.push(FilterKind::Audio { channels }); + } + } + kinds.extend( + AUTO_RGB_WIDTHS + .into_iter() + .filter(|&width| data.len() >= width) + .map(|width| FilterKind::Rgb { width, pos_r: 0 }), + ); + kinds + } + + /// Unlike RAR 5, a greedy parse here really is cheaper. On a megabyte of + /// binary it measured 59ms against 91ms at full effort, and it ranks + /// candidates the same way, so the screens run reduced and only the + /// finalists pay full price. + fn screen_options(&self, options: Rar29EncodeOptions) -> Rar29EncodeOptions { + let mut ranking = Rar29EncodeOptions::new(options.max_match_candidates.min(8)) + .with_lazy_matching(false) + .with_max_match_distance(options.max_match_distance); + if let Some(block_size) = options.block_size { + ranking = ranking.with_block_size(block_size); + } + ranking + } + + /// The VM filter splits a range into blocks it can address, and a delta + /// block holds whole records, so the channel count is bounded by the block + /// rather than by a field width the way RAR 5's is. + fn max_delta_channels(&self) -> usize { + crate::codec::rar29::MAX_VM_DELTA_FILTER_BLOCK_SIZE + } + + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + crate::codec::rar29::filtered_members(data, filters) + .map(|filtered| filtered.data) + .map_err(Error::from) + } + + fn encode_plain( + &self, + data: &[u8], + options: Rar29EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + match progress { + Some(progress) => { + unpack29_encode_literals_with_options_and_progress(data, options, progress) + .map_err(map_codec_cancel) + } + None => unpack29_encode_literals_with_options(data, options).map_err(Error::from), + } + } + + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: Rar29EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Unpack29Encoder::with_options(options) + .encode_member_with_filters_and_progress(data, filters, progress) + .map_err(map_codec_cancel) + } +} + +#[cfg(test)] +fn encode_rar29_auto_filtered_member( + data: &[u8], + options: Rar29EncodeOptions, + lz_method: u8, + include_ppmd: bool, +) -> Result { + encode_rar29_auto_filtered_member_with_progress(data, options, lz_method, include_ppmd, None) +} + +fn encode_rar29_auto_filtered_member_with_progress( + data: &[u8], + options: Rar29EncodeOptions, + lz_method: u8, + include_ppmd: bool, + progress: Option<&WorkTracker<'_>>, +) -> Result { + // The search measures the unfiltered member as one of its own candidates + // and returns the winner's bytes, so encoding the member plainly here as + // well was a second full pass over every binary member on the default + // settings. Text goes nowhere near the search, so it still needs one. + let text = is_text_ppmd_candidate(data); + let searching = !text && crate::filter_search::search_applies(data); + let mut best = EncodedPayload { + data: if searching { + let mut last = 0usize; + crate::filter_search::choose_filter( + &Rar29Search, + data, + options, + Some(&mut |event| match event { + crate::filter_search::EncodeProgress::PassStarted => { + last = 0; + !progress.is_some_and(WorkTracker::is_cancelled) + } + crate::filter_search::EncodeProgress::Advanced(position) => { + let delta = position.saturating_sub(last); + last = position; + progress.is_none_or(|work| work.advance(delta as u64)) + } + }), + )? + .1 + } else { + with_codec_progress(progress, |report| { + unpack29_encode_literals_with_options_and_progress(data, options, report) + })? + }, + method: lz_method, + }; + // Whichever engine wins, it wins because it was measured against the other + // over the whole member. Size used to decide it instead: under 1 MiB text + // was measured, over 16 MiB it went to PPMd unmeasured, and everything + // between kept the LZ bytes without ever encoding PPMd to compare. That + // middle band cost 24% on 2 MiB of man pages and 12% on 4 MiB, and the + // unmeasured end can lose just as badly the other way: 8 MiB of content + // that repeats every 4 MiB packs to 843 KB under LZ and 1.44 MB under PPMd. + // + // Screening on a sample first, the way the filter search earns its + // candidates, was tried and does not work here. The two engines are only + // comparable once there is enough output to compare: on 128 KiB of one + // repeating phrase LZ lands on 213 bytes and PPMd on 118, so the screen + // reads a 45% PPMd win off what is almost entirely archive overhead. And + // in the case worth catching, repetition further apart than the sample is + // wide, the sample cannot see the repetition at all. PPMd costs about + // three times LZ on the same bytes, so text at the top two levels pays for + // both engines. Levels 1 to 4 skip the trial as they always have. + if include_ppmd && text { + let ppmd = EncodedPayload { + data: with_codec_progress(progress, |report| { + crate::codec::rar29::unpack29_encode_ppmd_with_progress( + data, + true, + None, + options.max_match_distance, + report, + ) + })?, + method: lz_method, + }; + if ppmd.data.len() < best.data.len() { + best = ppmd; + } + // The escape tokens price themselves against costs measured off the + // stream they are shaping, so a member where every escape loses can + // still ratify a few before the measurements catch up. A pure-literal + // stream is the direct check. It costs a second PPMd pass over the + // member, paid only where PPMd is already being tried: text at the + // top two levels. + let ppmd_literals = EncodedPayload { + data: with_codec_progress(progress, |report| { + crate::codec::rar29::unpack29_encode_ppmd_with_progress( + data, false, None, 0, report, + ) + })?, + method: lz_method, + }; + if ppmd_literals.data.len() < best.data.len() { + best = ppmd_literals; + } + } + if best.data.len() >= data.len() { + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + Ok(best) +} + +fn is_text_ppmd_candidate(data: &[u8]) -> bool { + let mut printable = 0usize; + let mut nul = 0usize; + let mut total = 0usize; + for start in text_sample_offsets(data.len()) { + let end = start.saturating_add(RAR29_TEXT_SAMPLE_SIZE).min(data.len()); + let (window_printable, window_nul, window_total) = score_text_window(&data[start..end]); + printable += window_printable; + nul += window_nul; + total += window_total; + } + total != 0 && nul * 100 <= total && printable * 100 >= total * 85 +} + +/// Counts one sampled window as printable, NUL and total bytes. +/// +/// Counting only ASCII read every non-English member as binary. The bench's +/// text member is a set of translated man pages, 23% of it well-formed +/// multibyte UTF-8, and it scored 77% against the 85% bar and went to LZ. A +/// multibyte sequence is as much text as an ASCII letter. Accepting them costs +/// no precision either, because random binary almost never forms one: a lead +/// byte followed by a continuation byte is about 3% of positions, nowhere near +/// enough to carry a binary member over the bar. +fn score_text_window(window: &[u8]) -> (usize, usize, usize) { + let mut printable = 0usize; + let mut nul = 0usize; + let mut total = 0usize; + let mut index = 0usize; + while index < window.len() { + let byte = window[index]; + if byte == 0 { + let run = window[index..] + .iter() + .take_while(|&&byte| byte == 0) + .count(); + index += run; + // A run this long is padding rather than content, and padding says + // nothing about what surrounds it, so it is left out of the count + // instead of counted against the member. A tar pads every file to a + // 512 byte block and ends with a block of nothing, which put 27% NUL + // in front of a 1% bar and sent a tar of source files to LZ as if it + // were binary. What is left either side of the padding still decides + // it: a tar of text reads 99.8% text, and an ELF only climbs from + // 34% to 38%, nowhere near the bar. + if run < RAR29_NUL_RUN_IS_PADDING { + nul += run; + total += run; + } + } else if byte.is_ascii_graphic() || matches!(byte, b'\n' | b'\r' | b'\t' | b' ') { + printable += 1; + total += 1; + index += 1; + } else if let Some(len) = utf8_sequence_len(window, index) { + printable += len; + total += len; + index += len; + } else if utf8_lead_len(byte).is_some_and(|len| index + len > window.len()) { + // The window cut a sequence in half. That is an artefact of where + // the sample lands, not evidence of binary, so the window ends here. + break; + } else { + total += 1; + index += 1; + } + } + (printable, nul, total) +} + +/// How many bytes the sequence starting with this byte claims, if it can start +/// one. Overlong forms (`0xc0`, `0xc1`) and anything past U+10FFFF cannot. +fn utf8_lead_len(byte: u8) -> Option { + match byte { + 0xc2..=0xdf => Some(2), + 0xe0..=0xef => Some(3), + 0xf0..=0xf4 => Some(4), + _ => None, + } +} + +/// The length of the well-formed UTF-8 sequence at `index`, if there is one. +fn utf8_sequence_len(window: &[u8], index: usize) -> Option { + let len = utf8_lead_len(window[index])?; + if index + len > window.len() { + return None; + } + window[index + 1..index + len] + .iter() + .all(|byte| (0x80..=0xbf).contains(byte)) + .then_some(len) +} + +fn text_sample_offsets(len: usize) -> [usize; 3] { + [ + 0, + len.saturating_sub(RAR29_TEXT_SAMPLE_SIZE) / 2, + len.saturating_sub(RAR29_TEXT_SAMPLE_SIZE), + ] +} + +fn is_audio_filter_candidate(data: &[u8], channels: usize) -> bool { + if channels == 0 || channels > 4 || data.len() < channels * 64 { + return false; + } + + let mut total_delta = 0usize; + let mut small_delta = 0usize; + let mut compared = 0usize; + for start in text_sample_offsets(data.len()) { + // The admission check leaves at least 64 samples per channel, even + // for the shortest window, so every window has comparisons to make. + let end = start + .saturating_add(RAR29_AUDIO_SAMPLE_SIZE) + .min(data.len()); + let aligned_start = start + ((channels - start % channels) % channels); + for channel in 0..channels { + let mut previous = None; + let mut index = aligned_start + channel; + while index < end { + let byte = data[index]; + if let Some(previous) = previous { + let delta = usize::from(byte.abs_diff(previous)); + let delta = delta.min(256 - delta); + total_delta += delta; + small_delta += usize::from(delta <= 8); + compared += 1; + } + previous = Some(byte); + index += channels; + } + } + } + + total_delta <= compared * 24 && small_delta * 100 >= compared * 55 +} + +/// One member, however the caller supplied it. +struct Member<'a> { + unicode_name: Option<&'a [u8]>, + unpack_version: Option, + name: &'a [u8], + bytes: MemberBytes<'a>, + file_time: u32, + file_attr: u32, + host_os: u8, + password: Option<&'a [u8]>, + file_comment: Option<&'a [u8]>, + extended_times: Option<&'a [u8]>, + is_directory: bool, + is_symlink: bool, +} + +impl<'a> Member<'a> { + fn from_stored(entry: &'a StoredEntry<'a>) -> Self { + Self { + name: entry.name, + bytes: MemberBytes::Borrowed(entry.data), + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + password: entry.password, + file_comment: entry.file_comment, + unicode_name: None, + unpack_version: None, + extended_times: None, + is_directory: false, + is_symlink: false, + } + } + + fn from_file(entry: &'a FileEntry<'a>) -> Self { + Self { + name: entry.name, + bytes: MemberBytes::Borrowed(entry.data), + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + password: entry.password, + file_comment: entry.file_comment, + unicode_name: None, + unpack_version: None, + extended_times: None, + is_directory: false, + is_symlink: false, + } + } + + fn from_streaming(entry: &'a StreamingEntry) -> Self { + Self { + name: &entry.name, + bytes: MemberBytes::Source(&entry.source), + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + password: entry.password.as_deref(), + file_comment: entry.file_comment.as_deref(), + unicode_name: None, + unpack_version: None, + extended_times: None, + // Streaming callers have no retained metadata wrapper. The native + // attribute word already distinguishes directory sources. + is_directory: if entry.host_os == 3 { + entry.file_attr & 0o170000 == 0o040000 + } else { + entry.file_attr & 0x10 != 0 + }, + is_symlink: false, + } + } + + fn unpacked_size(&self) -> Result { + usize::try_from(self.bytes.len()?) + .map_err(|_| Error::InvalidArgument("RAR 1.5 writer does not support large files")) + } +} + +struct EncodedMember<'a> { + payload: MemberPayload<'a>, + method: u8, + unpacked_size: usize, + file_crc: u32, +} + +/// Working memory one member needs while it is coded. +/// +/// This is the admission weight that decides how many members run at once, not +/// a prediction: the encoder holds the member, its packed output, and a match +/// finder sized by the block it works in. +fn member_workspace(options: WriterOptions, unpacked: u64, compressing: bool) -> u64 { + if !compressing { + return 1024 * 1024; + } + let dictionary = + dictionary_size_for_options(options).unwrap_or(RAR29_MAX_DICTIONARY_SIZE) as u64; + unpacked + .saturating_mul(2) + .saturating_add(dictionary.saturating_mul(12)) + .saturating_add(2 * 1024 * 1024) +} + +/// Codes one member, holding its bytes only while it is being coded. +fn encode_member<'a>( + member: &Member<'a>, + options: WriterOptions, + coding: &MemberCoding, + solid_encoder: &mut Option, + resources: &WriterResources, + progress: &WorkTracker<'_>, +) -> Result> { + progress.check()?; + let unpacked_size = member.unpacked_size()?; + validate_member(member.name, unpacked_size)?; + if member.is_directory { + if unpacked_size != 0 { + return Err(Error::InvalidArgument("directory source must be empty")); + } + return Ok(EncodedMember { + payload: MemberPayload::Packed(Vec::new()), + method: 0x30, + unpacked_size: 0, + file_crc: 0, + }); + } + let _permit = resources.acquire_serialising_cancellable( + member_workspace(options, unpacked_size as u64, coding.compresses()), + &|| progress.is_cancelled(), + )?; + + // Legacy link targets must not become dependencies of later solid data: + // reference readers handle links separately from the solid unpacker. + let coding = if member.is_symlink { + if options.features.solid { + *solid_encoder = Some(SolidEncoder::for_target(options)?); + } + &MemberCoding::Stored + } else { + coding + }; + + // A stored member never needs to be resident: checksum it from its source + // and let the writer copy it straight through. + if let (MemberCoding::Stored, None, Some(source)) = + (coding, member.password, member.bytes.source()) + { + return Ok(EncodedMember { + payload: MemberPayload::Copied(source), + method: 0x30, + unpacked_size, + file_crc: { + let mut crc = Crc32::new(); + member.bytes.walk_exact_with_progress( + unpacked_size as u64, + progress.reporter(), + |chunk| { + crc.update(chunk); + progress.advance(chunk.len() as u64); + }, + )?; + crc.finish() + }, + }); + } + + let data = member + .bytes + .load_exact_with_progress(unpacked_size as u64, progress.reporter())?; + let mut crc = Crc32::new(); + for chunk in data.chunks(64 * 1024) { + progress.check()?; + crc.update(chunk); + if !coding.compresses() { + progress.advance(chunk.len() as u64); + } + } + let file_crc = crc.finish(); + progress.check()?; + let payload = match coding { + MemberCoding::Stored => EncodedPayload { + data: data.into_owned(), + method: 0x30, + }, + MemberCoding::Compressed => { + encode_or_store_payload(&data, options, solid_encoder, Some(progress))? + } + MemberCoding::Filtered(policy) => { + encode_filtered_payload(&data, policy, options, solid_encoder, Some(progress))? + } + }; + Ok(EncodedMember { + payload: MemberPayload::Packed(payload.data), + method: payload.method, + unpacked_size, + file_crc, + }) +} + +/// Writes one member's header and payload, encrypting either if asked. +fn write_member( + output: &mut dyn Write, + member: &Member<'_>, + encoded: EncodedMember<'_>, + options: WriterOptions, + solid_continuation: bool, + header_password: Option<&[u8]>, + progress: Option>, +) -> Result<()> { + let target = options.target; + crate::write_progress::check_cancelled(progress)?; + let (payload, salt) = match encoded.payload { + MemberPayload::Packed(mut packed) => { + let salt = + encrypt_packed_data_with_progress(&mut packed, target, member.password, progress)?; + (MemberPayload::Packed(packed), salt) + } + // Unencrypted by construction, so the stored bytes are their own + // payload and their size is the member's. + copied => (copied, None), + }; + let packed_size = payload.size(encoded.unpacked_size as u64); + let packed_size = usize::try_from(packed_size) + .map_err(|_| Error::InvalidArgument("RAR 1.5 packed size overflows u32"))?; + let mut flags = writer_file_flags(member.password, member.file_comment, solid_continuation); + if salt.is_some() { + flags |= FHD_SALT; + } + let wire_name = member.unicode_name.unwrap_or(member.name); + if member.unicode_name.is_some() { + flags |= super::FHD_UNICODE; + } + let mut extra = encode_file_comment(member.file_comment)?; + if let Some(raw) = member.extended_times { + flags |= FHD_EXTTIME; + extra.extend_from_slice(raw); + } + let mut header = Vec::new(); + write_file_header( + &mut header, + &FileRecord { + head_type: FILE_HEAD, + name: wire_name, + unpacked_size: encoded.unpacked_size, + file_crc: encoded.file_crc, + packed_size, + file_time: member.file_time, + file_attr: member.file_attr, + host_os: member.host_os, + target, + method: encoded.method, + dictionary_flags: if member.is_directory && target != ArchiveVersion::Rar15 { + FHD_DIRECTORY_MASK + } else { + dictionary_flags_for_options(options)? + }, + flags, + salt, + extra: &extra, + }, + )?; + if let Some(version) = member.unpack_version { + header[24] = version; + write_file_header_crc(&mut header, 0, wire_name.len(), flags); + } + match header_password { + Some(password) => write_encrypted_header(output, &header, password)?, + None => output.write_all(&header)?, + } + if matches!(payload, MemberPayload::Copied(_)) { + let mut checksum = Crc32::new(); + payload.write_to( + &mut CrcWriter { + inner: output, + crc: &mut checksum, + }, + packed_size as u64, + )?; + if checksum.finish() != encoded.file_crc { + return Err(Error::SourceChanged( + "entry source contents changed while writing", + )); + } + Ok(()) + } else { + payload.write_to(output, packed_size as u64) + } +} + +pub fn write_stored_volumes( + entry: StoredEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, +) -> Result>> { + write_stored_volumes_with_progress(entry, options, max_packed_per_volume, None) +} + +pub(crate) fn write_stored_volumes_with_progress( + entry: StoredEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, + progress: Option<&dyn WriteProgress>, +) -> Result>> { + let resources = WriterResources::default(); + let control = + crate::write_progress::ResourceProgress::new(&resources, progress.map(ProgressReporter)); + let progress = ProgressReporter(&control); + crate::write_progress::check_cancelled(Some(progress))?; + validate_plan(options, PlanShape::new().volumes(true), false, false)?; + validate_volume_writer_inputs(entry.name, entry.data, entry.file_comment, options)?; + if options.features.header_encryption { + return write_header_encrypted_split_volumes(SplitVolumeRecord { + progress, + name: entry.name, + unpacked: entry.data, + packed: entry.data, + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: options.target, + method: 0x30, + dictionary_flags: dictionary_flags_for_options(options)?, + base_flags: writer_file_flags(entry.password, None, false), + main_flags: 0, + password: entry.password, + max_packed_per_volume, + }); + } + + write_split_volumes(SplitVolumeRecord { + progress, + name: entry.name, + unpacked: entry.data, + packed: entry.data, + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: options.target, + method: 0x30, + dictionary_flags: dictionary_flags_for_options(options)?, + base_flags: writer_file_flags(entry.password, None, false), + main_flags: 0, + password: entry.password, + max_packed_per_volume, + }) +} + +pub fn write_compressed_volumes( + entry: FileEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, +) -> Result>> { + write_compressed_volumes_with_progress(entry, options, max_packed_per_volume, None) +} + +pub fn write_compressed_volumes_with_progress( + entry: FileEntry<'_>, + options: WriterOptions, + max_packed_per_volume: usize, + progress: Option<&dyn WriteProgress>, +) -> Result>> { + let resources = WriterResources::default(); + let control = + crate::write_progress::ResourceProgress::new(&resources, progress.map(ProgressReporter)); + let reporting = &control as &dyn WriteProgress; + let progress = Some(reporting); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + let total_work = if options.target == ArchiveVersion::Rar20 && !options.features.solid { + (entry.data.len() as u64).saturating_mul(2) + } else { + entry.data.len() as u64 + }; + report_compression_operation(reporting, true, total_work, 1); + let work = WorkTracker::new( + Some(ProgressReporter(reporting)), + WriteOperation::Compression, + total_work, + ); + let result = write_compressed_volumes_impl(entry, options, max_packed_per_volume, &work); + let result = result?; + if !work.finish() { + return Err(Error::Cancelled); + } + report_compression_operation(reporting, false, total_work, 1); + work.check()?; + Ok(result) +} + +fn write_compressed_volumes_impl( + entry: FileEntry<'_>, + mut options: WriterOptions, + max_packed_per_volume: usize, + progress: &WorkTracker<'_>, +) -> Result>> { + validate_plan( + options, + PlanShape::new().compressed(true).volumes(true), + false, + false, + )?; + validate_volume_writer_inputs(entry.name, entry.data, entry.file_comment, options)?; + // A volume set holds one member, and splitting it changes nothing about + // how far back the window has to reach. + if options.dictionary_size.is_none() { + options.dictionary_size = Some(fitted_dictionary_size( + options.target, + entry.data.len() as u64, + )); + } + + let mut solid_encoder = None; + let payload = encode_or_store_payload(entry.data, options, &mut solid_encoder, Some(progress)) + .map_err(|error| { + crate::write_stream::member_error(error, entry.name, "compressing volume member") + })?; + if options.features.header_encryption { + return write_header_encrypted_split_volumes(SplitVolumeRecord { + progress: progress + .reporter() + .expect("volume compression has a resource reporter"), + name: entry.name, + unpacked: entry.data, + packed: &payload.data, + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: options.target, + method: payload.method, + dictionary_flags: dictionary_flags_for_options(options)?, + base_flags: writer_file_flags(entry.password, None, false), + main_flags: if options.features.solid { MHD_SOLID } else { 0 }, + password: entry.password, + max_packed_per_volume, + }); + } + + write_split_volumes(SplitVolumeRecord { + progress: progress + .reporter() + .expect("volume compression has a resource reporter"), + name: entry.name, + unpacked: entry.data, + packed: &payload.data, + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: options.target, + method: payload.method, + dictionary_flags: dictionary_flags_for_options(options)?, + base_flags: writer_file_flags(entry.password, None, false), + main_flags: if options.features.solid { MHD_SOLID } else { 0 }, + password: entry.password, + max_packed_per_volume, + }) +} + +fn report_compression_operation( + progress: &dyn WriteProgress, + started: bool, + total_bytes: u64, + total_entries: usize, +) { + if started { + progress.report(WriteProgressEvent::OperationStarted { + operation: WriteOperation::Compression, + total_bytes: Some(total_bytes), + total_entries: Some(total_entries), + pass: 1, + }); + } else { + progress.report(WriteProgressEvent::OperationFinished { + operation: WriteOperation::Compression, + total_bytes: Some(total_bytes), + total_entries: Some(total_entries), + pass: 1, + }); + } +} + +/// Everything this writer refuses, in one place, before anything is written. +/// +/// The three near-identical checks this replaced each built a set of allowed +/// features out of the target and the request together, compared it with the +/// request, and on a mismatch said only that some feature was unsupported. +fn validate_plan( + options: WriterOptions, + shape: PlanShape, + has_archive_comment: bool, + has_file_comment: bool, +) -> Result<()> { + if options.archive_comment_metadata.is_some() + && (!has_archive_comment + || !matches!( + options.target, + ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + )) + { + return Err(Error::InvalidArgument( + "retained archive comment metadata requires a RAR3/4 archive comment", + )); + } + if options.target.family() != crate::version::ArchiveFamily::Rar15To40 { + return Err(Error::UnsupportedVersion(options.target)); + } + crate::write_plan::validate_features(options.target, options.features, shape)?; + crate::write_plan::validate_compression_level(options.target, options.compression_level)?; + if options.method == Rar29Method::Ppmd { + crate::write_plan::validate_option(options.target, WriterOption::CompressionMethod, shape)?; + } + // A filter policy routes the member through the RAR 2.9 engine, so the + // formats without one have to be turned away here. This used to be + // computed into the shape and then never asked about, which let RAR 1.5 + // accept a policy and write an archive that failed its own checksum. + if shape.filtered { + crate::write_plan::validate_option(options.target, WriterOption::Filter, shape)?; + } + let _ = dictionary_flags_for_options(options)?; + if has_archive_comment { + crate::write_plan::validate_option(options.target, WriterOption::ArchiveComment, shape)?; + } + if has_file_comment { + crate::write_plan::validate_option(options.target, WriterOption::FileComment, shape)?; + } + Ok(()) +} + +/// Cross-flag rules: relations between options rather than per-option +/// capability, so they are checked after the capability table has had its say. +fn validate_header_encrypted_archive_options( + target: ArchiveVersion, + has_password: bool, +) -> Result<()> { + if !has_password { + return Err(Error::UnsupportedWriterOption { + target, + option: WriterOption::Feature(crate::Feature::HeaderEncryption), + because: Some("without a password"), + }); + } + Ok(()) +} + +fn rar29_encode_options_for_level(level: Option) -> Result { + let level = level.unwrap_or(5); + let candidates = match level { + 0 => 0, + 1 => 8, + 2 => 32, + 3 => 64, + 4 => 96, + 5 => 128, + _ => { + return Err(Error::InvalidArgument( + "RAR compression level must be in the range 0..5", + )) + } + }; + Ok(Rar29EncodeOptions::new(candidates) + .with_lazy_matching(level >= 4) + .with_lazy_lookahead(1) + .with_block_size(RAR29_LZ_BLOCK_SIZE)) +} + +fn rar29_encode_options_for_options(options: WriterOptions) -> Result { + Ok(rar29_encode_options_for_level(options.compression_level)? + .with_max_match_distance(dictionary_size_for_options(options)?)) +} + +/// RAR 2.0 levels, as candidates searched per position. +/// +/// The ladder used to run 16, 64, 256, 96, 128, so the top two levels searched +/// less than the middle one and asking for more compression got less of it: on +/// 4 MiB of man pages level 3 packed 848,854 bytes, level 5 packed 861,371 and +/// level 4 packed 867,857, which is the candidate order exactly. +/// +/// Lazy matching was off at every level, which cost more than the ladder did. +/// Measured on that member, packed bytes and seconds: +/// +/// ```text +/// candidates 16 64 256 512 1024 +/// lazy off 937,906 878,958 848,790 840,496 835,622 +/// lazy on 886,854 837,531 813,252 806,728 803,006 +/// seconds 2.37 4.41 8.67 12.78 17.43 +/// ``` +/// +/// It is worth 4% on text and 3% on a stripped binary, at every count, for +/// about half again the time. Candidates cost more and give less: the last +/// doubling buys 0.5%. So lazy matching is on wherever anything is compressed, +/// and the level chooses how far to search. +fn rar20_encode_options_for_level(level: Option) -> Result { + let level = level.unwrap_or(RAR20_DEFAULT_LEVEL); + let candidates = match level { + 0 => return Ok(Rar20EncodeOptions::new(0)), + 1 => 16, + 2 => 64, + 3 => 256, + 4 => 512, + 5 => 1024, + _ => { + return Err(Error::InvalidArgument( + "RAR compression level must be in the range 0..5", + )) + } + }; + Ok(Rar20EncodeOptions::new(candidates) + .with_lazy_matching(true) + // Look two positions ahead before committing to a match, not one. The + // class this moves is downloads: docx, jpeg, png, gif, a ZX Spectrum + // snapshot. High-entropy bytes with occasional short matches, where a + // three byte match often costs more than the literal it replaces and + // the better match starts two bytes later. Depth 1 cannot see that far. + // Measured on the small corpus, packed bytes: + // + // ```text + // depth 1 2 3 4 + // total 657,072 654,162 656,242 659,161 + // ``` + // + // Worth 0.44% at every level for about a third more encode time. Depth + // 3 and 4 give it back: on text, deferring that long skips matches + // worth taking. + .with_lazy_lookahead(2) + // The shortest-path parse is worth another 1.5% and costs four times + // the encode time, so it goes where the ladder already means "spend + // whatever it takes". rar29 gates its lazy matching at the same rung. + .with_optimal_parse(level >= 4) + // The audio trial is a second encode of the member, which is the one + // thing level 1 is trying not to pay for. + .with_try_audio(level > 1)) +} + +fn rar20_encode_options_for_options(options: WriterOptions) -> Result { + Ok(rar20_encode_options_for_level(options.compression_level)? + .with_max_match_distance(dictionary_size_for_options(options)?)) +} + +fn rar15_encode_options_for_level(level: Option) -> Result { + let level = level.unwrap_or(5); + match level { + 0 => Ok(Rar15EncodeOptions::new() + .with_old_distance_tokens(false) + .with_lazy_matching(false) + .with_stmode_literal_runs(false) + .with_max_long_match_distance(0)), + 1 => Ok(Rar15EncodeOptions::new() + .with_old_distance_tokens(false) + .with_lazy_matching(false) + .with_stmode_literal_runs(false) + .with_max_long_match_distance(4 * 1024)), + 2 => Ok(Rar15EncodeOptions::new() + .with_lazy_matching(false) + .with_stmode_literal_runs(false) + .with_max_long_match_distance(8 * 1024)), + 3 => Ok(Rar15EncodeOptions::new() + .with_lazy_matching(false) + .with_max_long_match_distance(16 * 1024)), + 4 => Ok(Rar15EncodeOptions::new() + .with_lazy_matching(false) + .with_max_long_match_distance(24 * 1024)), + 5 => Ok(Rar15EncodeOptions::new().with_lazy_matching(false)), + _ => Err(Error::InvalidArgument( + "RAR compression level must be in the range 0..5", + )), + } +} + +/// The smallest and largest dictionary worth declaring for a target. +/// +/// RAR 1.5 and older ignore the field: their decoders have a fixed window, and +/// measuring confirms the packed size does not move with it, so those stay +/// pinned. WinRAR 1.54 writes 64K in every archive we have from it. +fn dictionary_range(target: ArchiveVersion) -> (usize, usize) { + match target { + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => { + (128 * 1024, RAR29_MAX_DICTIONARY_SIZE) + } + ArchiveVersion::Rar20 => (64 * 1024, RAR29_MAX_DICTIONARY_SIZE), + _ => (64 * 1024, 64 * 1024), + } +} + +/// The smallest dictionary the format encodes that reaches past `content`, so a +/// match can span everything the window is meant to cover. +/// +/// Picking one number for every archive is the wrong shape: too small loses +/// half the ratio on content whose repeats sit far apart, and too large costs a +/// decoder memory it never needs for a thirty byte file. WinRAR sizes it to the +/// data, and reading the dictionary bits out of its own archives against their +/// largest member shows exactly this rule: +/// +/// ```text +/// content 130048 196608 262144 705644 1048576 +/// declared 128K 256K 512K 1024K 2048K +/// ``` +fn fitted_dictionary_size(target: ArchiveVersion, content: u64) -> usize { + let (floor, cap) = dictionary_range(target); + let mut size = floor; + while size < cap && size as u64 <= content { + size *= 2; + } + size +} + +fn rar29_default_dictionary_size(target: ArchiveVersion) -> usize { + match target { + ArchiveVersion::Rar29 => 1024 * 1024, + ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => 128 * 1024, + _ => 64 * 1024, + } +} + +fn dictionary_size_for_options(options: WriterOptions) -> Result { + options + .dictionary_size + .map(Ok) + .unwrap_or_else(|| Ok(rar29_default_dictionary_size(options.target))) +} + +fn dictionary_flags_for_options(options: WriterOptions) -> Result { + dictionary_flags_for_size(dictionary_size_for_options(options)?) +} + +fn dictionary_flags_for_size(size: usize) -> Result { + let bits = + match size { + 0x1_0000 => 0, + 0x2_0000 => 1, + 0x4_0000 => 2, + 0x8_0000 => 3, + 0x10_0000 => 4, + 0x20_0000 => 5, + 0x40_0000 => 6, + _ => return Err(Error::InvalidArgument( + "RAR 1.5-4.x dictionary size must be one of 64K, 128K, 256K, 512K, 1M, 2M, or 4M", + )), + }; + Ok((bits as u16) << 5) +} + +// Callers have passed `validate_plan`, including compression-level validation. +fn compression_method_for_level(options: WriterOptions) -> u8 { + let Some(level) = options.compression_level else { + return 0x33; + }; + 0x30 + level +} + +enum SolidEncoder { + Rar15(Box), + Rar20(Unpack20Encoder), + Rar29(Box), +} + +impl SolidEncoder { + fn for_target(options: WriterOptions) -> Result { + let encoder = match options.target { + ArchiveVersion::Rar15 => Self::Rar15(Box::new(Unpack15Encoder::with_options( + rar15_encode_options_for_level(options.compression_level)?, + ))), + ArchiveVersion::Rar20 => Self::Rar20(Unpack20Encoder::with_options( + rar20_encode_options_for_options(options)?, + )), + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => { + Self::Rar29(Box::new(Unpack29Encoder::with_options( + rar29_encode_options_for_options(options)?, + ))) + } + _ => return Err(Error::UnsupportedVersion(options.target)), + }; + Ok(encoder) + } +} + +struct EncodedPayload { + data: Vec, + method: u8, +} + +/// Codes a filtered member, continuing the solid chain when there is one. +/// +/// A filtered member used to be coded on its own whatever the archive said, +/// while its header still claimed to continue the chain. That cost the whole +/// benefit of `--solid`: three 400 KB members went from 550 KB to 1.2 MB, and +/// the flag on the members was a plain lie about how they had been coded. +fn encode_filtered_payload( + data: &[u8], + policy: &FilterPolicy, + options: WriterOptions, + solid_encoder: &mut Option, + progress: Option<&WorkTracker<'_>>, +) -> Result { + let lz_method = compression_method_for_level(options); + // A named filter under forced PPMd is the one request the chain cannot + // take: its PPMd side codes no filters, and coding the member LZ instead + // would quietly overrule a flag the caller set. + let forced_ppmd_filter = + options.method == Rar29Method::Ppmd && matches!(policy, FilterPolicy::Explicit(_)); + let encoder = match ( + lz_method != 0x30 && !forced_ppmd_filter, + solid_encoder.as_mut(), + ) { + (true, Some(SolidEncoder::Rar29(encoder))) => encoder, + _ => { + return encode_rar29_policy_filtered_payload( + data, + policy, + options.method, + rar29_encode_options_for_options(options)?, + lz_method, + ppmd_trial_pays(lz_method.saturating_sub(0x30)), + progress, + ) + } + }; + + // An empty member has no range to filter, and `--no-filter` asked for none, + // but both still go through the chain's encoder like any other member. + // Coding either one on its own would leave the encoder's history in place + // while the headers said the chain had ended, so the member after it would + // be coded against a dictionary its own flags told the decoder to discard. + let mut last = 0usize; + let mut advance = |position: usize| { + let delta = position.saturating_sub(last); + last = last.max(position); + progress.is_none_or(|work| work.advance(delta as u64)) + }; + let packed = match policy { + FilterPolicy::Explicit(filter) if !data.is_empty() => encoder + .encode_member_with_filters_and_progress( + data, + std::slice::from_ref(filter), + Some(&mut advance), + ) + .map_err(map_codec_cancel)?, + // Naming a filter, or none, says nothing about which engine should code + // the member. `--no-filter` used to answer that question too, and answer + // it LZ, so asking a solid archive not to filter its binaries also took + // PPMd away from its text. + FilterPolicy::Explicit(_) | FilterPolicy::None => { + encode_rar29_chain_member(data, options, encoder, false, &mut advance)? + } + FilterPolicy::Auto => { + encode_rar29_chain_member(data, options, encoder, true, &mut advance)? + } + }; + + // A member the encoder could not shrink is stored, exactly as an unfiltered + // one is, which rebuilds the encoder and ends the chain here. + if should_store_fallback(options.target, true, data.len(), packed.len()) { + *solid_encoder = Some(SolidEncoder::for_target(options)?); + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + Ok(EncodedPayload { + data: packed, + method: lz_method, + }) +} + +fn encode_or_store_payload( + data: &[u8], + options: WriterOptions, + solid_encoder: &mut Option, + progress: Option<&WorkTracker<'_>>, +) -> Result { + let target = options.target; + if options.compression_level == Some(0) { + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + let solid = solid_encoder.is_some(); + if !solid + && matches!( + target, + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + ) + { + let encode_options = rar29_encode_options_for_options(options)?; + let lz_method = compression_method_for_level(options); + // Forcing PPMd leaves nothing for a filter search to measure against. + let policy = if options.method == Rar29Method::Ppmd { + FilterPolicy::None + } else { + FilterPolicy::Auto + }; + return encode_rar29_policy_filtered_payload( + data, + &policy, + options.method, + encode_options, + lz_method, + ppmd_trial_pays(lz_method.saturating_sub(0x30)), + progress, + ); + } + let compressed = encode_compressed_payload(data, options, solid_encoder.as_mut(), progress)?; + if should_store_fallback(target, solid, data.len(), compressed.len()) { + if solid { + *solid_encoder = Some(SolidEncoder::for_target(options)?); + } + return Ok(EncodedPayload { + data: data.to_vec(), + method: 0x30, + }); + } + Ok(EncodedPayload { + data: compressed, + method: compression_method_for_level(options), + }) +} + +/// Codes one member into a RAR 2.9 solid chain, choosing both the engine and, +/// on the LZ side, the filter. +/// +/// The engine question and the filter question meet here because they are +/// asked of the same member and only one answer gets written. In practice they +/// barely overlap: the filter search declines text and the PPMd trial only +/// wants text, so a member that reaches one usually walks past the other. That +/// is a fact about the two screens rather than a rule, so the trials are +/// measured against each other rather than sequenced on the assumption. +/// +/// `search` is off for a caller who named a filter or asked for none, and for +/// PPMd, which leaves nothing for a filter to be measured through. +fn encode_rar29_chain_member( + data: &[u8], + options: WriterOptions, + encoder: &mut Unpack29Encoder, + search: bool, + progress: &mut dyn FnMut(usize) -> bool, +) -> Result> { + // A chain used to be LZ and nothing else, so a solid archive got no PPMd at + // all and an explicit --method ppmd was quietly ignored. It is the same + // content question here as in a non-solid archive, so it gets the same + // answer and the same gate: a level willing to encode the member twice, and + // content that looks like PPMd will win on it. + let level = compression_method_for_level(options).saturating_sub(0x30); + let engine = match options.method { + Rar29Method::Lz => ChainEngine::Lz, + Rar29Method::Ppmd => ChainEngine::Ppmd, + Rar29Method::Auto if ppmd_trial_pays(level) && is_text_ppmd_candidate(data) => { + ChainEngine::Smaller + } + Rar29Method::Auto => ChainEngine::Lz, + }; + let candidates = + if search && engine != ChainEngine::Ppmd && crate::filter_search::search_applies(data) { + crate::filter_search::filter_candidates( + &Rar29Search, + data, + rar29_encode_options_for_options(options)?, + )? + } else { + Vec::new() + }; + encoder + .encode_member_with_engine(data, engine, &candidates, progress) + .map_err(map_codec_cancel) +} + +fn encode_compressed_payload( + data: &[u8], + options: WriterOptions, + solid_encoder: Option<&mut SolidEncoder>, + progress: Option<&WorkTracker<'_>>, +) -> Result> { + let target = options.target; + let mut last = 0usize; + let mut advance = |position: usize| { + if position < last { + last = 0; + } + let delta = position.saturating_sub(last); + last = position; + progress.is_none_or(|progress| progress.advance(delta as u64)) + }; + // Non-solid RAR 2.9 members take the policy path in + // encode_or_store_payload before reaching this solid-chain encoder. + match (target, solid_encoder) { + (ArchiveVersion::Rar15, Some(SolidEncoder::Rar15(encoder))) => encoder + .encode_member_with_progress(data, &mut advance) + .map_err(map_codec_cancel), + (ArchiveVersion::Rar15, None) => unpack15_encode_with_options_and_progress( + data, + rar15_encode_options_for_level(options.compression_level)?, + &mut advance, + ) + .map_err(map_codec_cancel), + (ArchiveVersion::Rar20, None) => unpack20_encode_auto_with_options_and_progress( + data, + rar20_encode_options_for_options(options)?, + &mut advance, + ) + .map_err(map_codec_cancel), + (ArchiveVersion::Rar20, Some(SolidEncoder::Rar20(encoder))) => encoder + .encode_member_with_progress(data, &mut advance) + .map_err(map_codec_cancel), + ( + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40, + Some(SolidEncoder::Rar29(encoder)), + ) => encode_rar29_chain_member(data, options, encoder, true, &mut advance), + _ => Err(Error::UnsupportedVersion(target)), + } +} + +fn map_codec_cancel(error: crate::codec::Error) -> Error { + if error == crate::codec::Error::Cancelled { + Error::Cancelled + } else { + Error::from(error) + } +} + +fn with_codec_progress( + progress: Option<&WorkTracker<'_>>, + encode: impl FnOnce(&mut dyn FnMut(usize) -> bool) -> crate::codec::Result>, +) -> Result> { + if let Some(work) = progress { + work.check()?; + } + let mut last = 0usize; + let result = encode(&mut |position| { + if position < last { + last = 0; + } + let delta = position.saturating_sub(last); + last = position; + progress.is_none_or(|work| work.advance(delta as u64)) + }) + .map_err(map_codec_cancel)?; + if let Some(work) = progress { + work.check()?; + } + Ok(result) +} + +fn should_store_fallback( + target: ArchiveVersion, + solid: bool, + unpacked_len: usize, + packed_len: usize, +) -> bool { + // RAR 2.0 onwards store any member compression did not help. RAR 1.5 pays + // more header for a stored member, so a small one stays compressed. + let stores_any_size = !solid + && matches!( + target, + ArchiveVersion::Rar20 + | ArchiveVersion::Rar29 + | ArchiveVersion::Rar30 + | ArchiveVersion::Rar40 + ); + // Storing a member part way through a solid run rebuilds the encoder, so + // the member after it has to say it starts a fresh chain. Only RAR 2.0 + // onwards can: RAR 1.5 file headers have no solid bit, and readers take + // every member of a solid RAR 1.5 archive as a continuation whatever the + // header says. Breaking the chain there writes an archive nothing can read. + crate::write_plan::StoreFallback::new() + .allow_solid(target != ArchiveVersion::Rar15) + .min_size(if stores_any_size { + 0 + } else { + MIN_STORE_FALLBACK_SIZE + }) + .applies(solid, unpacked_len, packed_len) +} + +fn validate_volume_writer_inputs( + name: &[u8], + data: &[u8], + file_comment: Option<&[u8]>, + options: WriterOptions, +) -> Result<()> { + validate_file_entry(name, data).map_err(|error| { + crate::write_stream::member_error(error, name, "preparing volume member") + })?; + if file_comment.is_some() { + return Err(Error::UnsupportedFeature { + version: options.target, + feature: "volume_file_comment", + }); + } + Ok(()) +} + +fn writer_file_flags( + password: Option<&[u8]>, + file_comment: Option<&[u8]>, + solid_continuation: bool, +) -> u16 { + let mut flags = 0; + if password.is_some() { + flags |= FHD_PASSWORD; + } + if file_comment.is_some() { + flags |= FHD_COMMENT; + } + if solid_continuation { + flags |= FHD_SOLID; + } + flags +} + +/// Builds the comment block that goes inside a file header. +/// +/// RAR 1.3 and 1.4 wrote a bare size and the text, and this writer used to copy +/// that. From 1.5 on it is the same comment block the archive comment uses, +/// covered by the file header's size but not by its CRC. +fn encode_file_comment(comment: Option<&[u8]>) -> Result> { + let mut out = Vec::new(); + write_comment_header(&mut out, comment)?; + Ok(out) +} + +fn encrypt_split_packed_data( + data: &mut Vec, + target: ArchiveVersion, + password: &[u8], +) -> Result> { + #[cfg(not(feature = "encryption"))] + { + let _ = (data, target, password); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + match target { + ArchiveVersion::Rar15 => { + Rar15Cipher::new(password).crypt_in_place(data); + Ok(None) + } + ArchiveVersion::Rar20 => { + let padded_len = checked_align16(data.len(), RAR15_ALIGN_OVERFLOW) + .expect("byte vector length plus padding fits usize"); + data.resize(padded_len, 0); + Rar20Cipher::new(password) + .encrypt_in_place(data) + .expect("padded legacy ciphertext is block aligned"); + Ok(None) + } + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => { + let salt = random_rar30_salt()?; + let padded_len = checked_align16(data.len(), RAR15_ALIGN_OVERFLOW) + .expect("byte vector length plus padding fits usize"); + data.resize(padded_len, 0); + Rar30Cipher::new(password, Some(salt)) + .map_err(super::map_rar30_crypto_error)? + .encrypt_in_place(data) + .expect("padded legacy ciphertext is block aligned"); + Ok(Some(salt)) + } + _ => Err(Error::UnsupportedVersion(target)), + } + } +} + +fn header_encryption_password<'a>( + mut passwords: impl Iterator>, +) -> Result<&'a [u8]> { + let first = passwords.next().flatten().ok_or(Error::NeedPassword)?; + for password in passwords { + if password != Some(first) { + return Err(Error::InvalidArgument( + "RAR 3.x header-encrypted writer needs one shared password", + )); + } + } + Ok(first) +} + +fn encrypt_packed_data_for_writer( + data: &mut Vec, + target: ArchiveVersion, + password: Option<&[u8]>, +) -> Result> { + encrypt_packed_data_with_progress(data, target, password, None) +} + +fn encrypt_packed_data_with_progress( + data: &mut Vec, + target: ArchiveVersion, + password: Option<&[u8]>, + progress: Option>, +) -> Result> { + #[cfg(not(feature = "encryption"))] + { + let _ = (data, target); + crate::write_progress::check_cancelled(progress)?; + if password.is_none() { + Ok(None) + } else { + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + } + #[cfg(feature = "encryption")] + { + crate::write_progress::check_cancelled(progress)?; + let Some(password) = password else { + return Ok(None); + }; + match target { + ArchiveVersion::Rar15 => { + let mut cipher = Rar15Cipher::new(password); + for chunk in data.chunks_mut(64 * 1024) { + crate::write_progress::check_cancelled(progress)?; + cipher.crypt_in_place(chunk); + } + Ok(None) + } + ArchiveVersion::Rar20 => { + let padded_len = checked_align16(data.len(), RAR15_ALIGN_OVERFLOW) + .expect("byte vector length plus padding fits usize"); + data.resize(padded_len, 0); + let mut cipher = Rar20Cipher::new(password); + for chunk in data.chunks_mut(64 * 1024) { + crate::write_progress::check_cancelled(progress)?; + cipher + .encrypt_in_place(chunk) + .expect("padded ciphertext and 64 KiB chunks are block aligned"); + } + Ok(None) + } + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => { + let salt = random_rar30_salt()?; + // Byte vectors are bounded by isize::MAX, so adding 15 fits usize. + let padded_len = checked_align16(data.len(), RAR15_ALIGN_OVERFLOW) + .expect("byte vector length plus padding fits usize"); + data.resize(padded_len, 0); + let mut cipher = Rar30Cipher::new(password, Some(salt)) + .map_err(super::map_rar30_crypto_error)?; + for chunk in data.chunks_mut(64 * 1024) { + crate::write_progress::check_cancelled(progress)?; + cipher + .encrypt_in_place(chunk) + .expect("padded ciphertext and 64 KiB chunks are block aligned"); + } + Ok(Some(salt)) + } + _ => Err(Error::UnsupportedFeature { + version: target, + feature: "RAR writer file encryption", + }), + } + } +} + +#[cfg(feature = "encryption")] +fn random_rar30_salt() -> Result<[u8; 8]> { + let mut salt = [0; 8]; + crate::write_stream::fill_entropy( + &mut salt, + "RAR 3.x writer could not generate encryption salt", + )?; + Ok(salt) +} + +/// What WinRAR writes on an end-of-archive block. The bit marks the block as +/// one a reader may skip without understanding it. +const ENDARC_FLAGS: u16 = 0x4000; +const END_HEADER_SIZE: usize = 7; + +fn write_main_header(out: &mut Vec, flags: u16) { + let start = out.len(); + out.extend_from_slice(&0u16.to_le_bytes()); + out.push(MAIN_HEAD); + out.extend_from_slice(&flags.to_le_bytes()); + out.extend_from_slice(&13u16.to_le_bytes()); + out.extend_from_slice(&0u16.to_le_bytes()); + out.extend_from_slice(&0u32.to_le_bytes()); + write_header_crc(out, start); +} + +fn write_comment_header(out: &mut Vec, comment: Option<&[u8]>) -> Result<()> { + let Some(comment) = comment else { + return Ok(()); + }; + let unp_size = u16::try_from(comment.len()) + .map_err(|_| Error::InvalidArgument("RAR 1.5 comment is longer than 65535 bytes"))?; + let head_size = 13usize + .checked_add(comment.len()) + .ok_or(Error::InvalidArgument( + "RAR 1.5 comment header size overflows", + ))?; + let head_size = u16::try_from(head_size) + .map_err(|_| Error::InvalidArgument("RAR 1.5 comment header size overflows"))?; + + let start = out.len(); + out.extend_from_slice(&0u16.to_le_bytes()); + out.push(COMM_HEAD); + out.extend_from_slice(&0u16.to_le_bytes()); + out.extend_from_slice(&head_size.to_le_bytes()); + out.extend_from_slice(&unp_size.to_le_bytes()); + out.push(15); + out.push(0x30); + out.extend_from_slice(&((crc32(comment) & 0xffff) as u16).to_le_bytes()); + out.extend_from_slice(comment); + write_comment_header_crc(out, start); + Ok(()) +} + +fn uses_old_style_archive_comment(target: ArchiveVersion) -> bool { + matches!( + target, + ArchiveVersion::Rar15 | ArchiveVersion::Rar20 | ArchiveVersion::Rar29 + ) +} + +fn write_archive_comment( + out: &mut dyn Write, + comment: Option<&[u8]>, + options: WriterOptions, + header_password: Option<&[u8]>, + password: Option<&[u8]>, +) -> Result<()> { + let Some(comment) = comment else { + return Ok(()); + }; + if uses_old_style_archive_comment(options.target) { + let mut block = Vec::new(); + write_comment_header(&mut block, Some(comment))?; + out.write_all(&block)?; + return Ok(()); + } + let mut packed = unpack29_encode_literals(comment)?; + let salt = encrypt_packed_data_for_writer(&mut packed, options.target, password)?; + let metadata = options.archive_comment_metadata; + let mut header = Vec::new(); + write_file_header( + &mut header, + &FileRecord { + head_type: NEWSUB_HEAD, + name: b"CMT", + unpacked_size: comment.len(), + file_crc: crc32(comment), + packed_size: packed.len(), + file_time: metadata.map_or(0, |metadata| metadata.0), + file_attr: 0, + host_os: metadata.map_or(3, |metadata| metadata.1), + target: ArchiveVersion::Rar30, + method: 0x33, + dictionary_flags: dictionary_flags_for_target(ArchiveVersion::Rar30), + flags: if password.is_some() { + FHD_PASSWORD | FHD_SALT + } else { + 0 + }, + salt, + extra: &[], + }, + )?; + if let Some(password) = header_password { + write_encrypted_header(out, &header, password)?; + } else { + out.write_all(&header)?; + } + out.write_all(&packed)?; + Ok(()) +} + +/// Closes a header-encrypted archive with an end-of-archive block in a group of +/// its own. +/// +/// Every encrypted header carries its own salt, so a reader that reaches the end +/// of the last member's payload reads eight more bytes looking for the next +/// group's salt. With nothing there it stops on a short read rather than on a +/// clean end, and 7-Zip treats that as a decryption failure and refuses to open +/// the archive at all. WinRAR closes the same way. unrar stops at the last +/// member and never looks, which is why nothing caught this. +fn write_encrypted_end_block(out: &mut dyn Write, password: &[u8]) -> Result<()> { + let mut header = Vec::new(); + let start = header.len(); + header.extend_from_slice(&0u16.to_le_bytes()); + header.push(ENDARC_HEAD); + header.extend_from_slice(&ENDARC_FLAGS.to_le_bytes()); + header.extend_from_slice(&(END_HEADER_SIZE as u16).to_le_bytes()); + write_header_crc(&mut header, start); + debug_assert_eq!(header.len(), END_HEADER_SIZE); + write_encrypted_header(out, &header, password) +} + +fn write_encrypted_header(out: &mut dyn Write, header: &[u8], password: &[u8]) -> Result<()> { + #[cfg(not(feature = "encryption"))] + { + let _ = (out, header, password); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + let salt = random_rar30_salt()?; + let encrypted_size = checked_align16(header.len(), RAR15_ALIGN_OVERFLOW)?; + let mut encrypted_header = Vec::with_capacity(encrypted_size); + encrypted_header.extend_from_slice(header); + encrypted_header.resize(encrypted_size, 0); + Rar30Cipher::new(password, Some(salt)) + .map_err(super::map_rar30_crypto_error)? + .encrypt_in_place(&mut encrypted_header) + .map_err(super::map_rar30_crypto_error)?; + out.write_all(&salt)?; + out.write_all(&encrypted_header)?; + Ok(()) + } +} + +fn validate_member(name: &[u8], unpacked_size: usize) -> Result<()> { + if name.is_empty() { + return Err(Error::InvalidArgument("RAR 1.5 file name is empty")); + } + if name.len() > u16::MAX as usize { + return Err(Error::InvalidArgument("RAR 1.5 file name is too long")); + } + if unpacked_size > u32::MAX as usize { + return Err(Error::InvalidArgument( + "RAR 1.5 writer does not support large files", + )); + } + Ok(()) +} + +fn validate_file_entry(name: &[u8], data: &[u8]) -> Result<()> { + validate_member(name, data.len()) +} + +struct FileRecord<'a> { + head_type: u8, + name: &'a [u8], + unpacked_size: usize, + file_crc: u32, + packed_size: usize, + file_time: u32, + file_attr: u32, + host_os: u8, + target: ArchiveVersion, + method: u8, + dictionary_flags: u16, + flags: u16, + salt: Option<[u8; 8]>, + extra: &'a [u8], +} + +fn write_file_header_and_data( + out: &mut Vec, + record: FileRecord<'_>, + packed: &[u8], +) -> Result<()> { + write_file_header(out, &record)?; + out.extend_from_slice(packed); + Ok(()) +} + +fn write_file_header(out: &mut Vec, record: &FileRecord<'_>) -> Result<()> { + let start = out.len(); + let flags = record.flags | record.dictionary_flags; + let (host_os, file_attr) = + rar15_compatible_metadata(record.target, record.host_os, record.file_attr); + let packed_size = u32::try_from(record.packed_size) + .map_err(|_| Error::InvalidArgument("RAR 1.5 packed size overflows u32"))?; + let unpacked_size = u32::try_from(record.unpacked_size) + .map_err(|_| Error::InvalidArgument("RAR 1.5 unpacked size overflows u32"))?; + let head_size = 32usize + .checked_add(record.name.len()) + .and_then(|size| size.checked_add(if record.salt.is_some() { 8 } else { 0 })) + .and_then(|size| size.checked_add(record.extra.len())) + .ok_or(Error::InvalidArgument("RAR 1.5 file header size overflows"))?; + let head_size = u16::try_from(head_size) + .map_err(|_| Error::InvalidArgument("RAR 1.5 file header size overflows"))?; + let unp_ver = match record.target { + ArchiveVersion::Rar15 => 15, + ArchiveVersion::Rar20 => 20, + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 => 29, + _ => return Err(Error::UnsupportedVersion(record.target)), + }; + out.extend_from_slice(&0u16.to_le_bytes()); + out.push(record.head_type); + out.extend_from_slice(&(LONG_BLOCK | flags).to_le_bytes()); + out.extend_from_slice(&head_size.to_le_bytes()); + out.extend_from_slice(&packed_size.to_le_bytes()); + out.extend_from_slice(&unpacked_size.to_le_bytes()); + out.push(host_os); + out.extend_from_slice(&record.file_crc.to_le_bytes()); + out.extend_from_slice(&record.file_time.to_le_bytes()); + out.push(unp_ver); + out.push(record.method); + out.extend_from_slice(&(record.name.len() as u16).to_le_bytes()); + out.extend_from_slice(&file_attr.to_le_bytes()); + out.extend_from_slice(record.name); + if let Some(salt) = record.salt { + out.extend_from_slice(&salt); + } + out.extend_from_slice(record.extra); + write_file_header_crc(out, start, record.name.len(), flags); + Ok(()) +} + +fn rar15_compatible_metadata(target: ArchiveVersion, host_os: u8, file_attr: u32) -> (u8, u32) { + const HOST_DOS: u8 = 0; + const HOST_UNIX: u8 = 3; + const DOS_ARCHIVE: u32 = 0x20; + const DOS_DIRECTORY: u32 = 0x10; + const UNIX_FILE_TYPE_MASK: u32 = 0o170000; + const UNIX_DIRECTORY: u32 = 0o040000; + + if target == ArchiveVersion::Rar15 && host_os == HOST_UNIX { + let dos_attr = if file_attr & UNIX_FILE_TYPE_MASK == UNIX_DIRECTORY { + DOS_DIRECTORY + } else { + DOS_ARCHIVE + }; + return (HOST_DOS, dos_attr); + } + (host_os, file_attr) +} + +fn dictionary_flags_for_target(target: ArchiveVersion) -> u16 { + ((rar29_default_dictionary_size(target).trailing_zeros() - 16) as u16) << 5 +} + +struct SplitVolumeRecord<'a> { + progress: ProgressReporter<'a>, + name: &'a [u8], + unpacked: &'a [u8], + packed: &'a [u8], + file_time: u32, + file_attr: u32, + host_os: u8, + target: ArchiveVersion, + method: u8, + dictionary_flags: u16, + base_flags: u16, + main_flags: u16, + password: Option<&'a [u8]>, + max_packed_per_volume: usize, +} + +fn report_volume( + progress: ProgressReporter<'_>, + index: usize, + total: usize, + bytes: usize, +) -> Result<()> { + progress.report(WriteProgressEvent::VolumeFinished { + volume_number: index + 1, + total_volumes: Some(total), + bytes: bytes as u64, + }); + crate::write_progress::check_cancelled(Some(progress)) +} + +fn write_split_volumes(entry: SplitVolumeRecord<'_>) -> Result>> { + crate::write_progress::check_cancelled(Some(entry.progress))?; + if entry.max_packed_per_volume == 0 { + return Err(Error::InvalidArgument( + "RAR 1.5 volume payload size must be non-zero", + )); + } + if entry.packed.is_empty() { + return Err(Error::InvalidArgument( + "RAR 1.5 volume writer needs a non-empty packed payload", + ) + .at_entry(entry.name.to_vec(), "preparing volume member")); + } + + let mut packed = entry.packed.to_vec(); + let split_salt = if let Some(password) = entry.password { + encrypt_split_packed_data(&mut packed, entry.target, password).map_err(|error| { + crate::write_stream::member_error(error, entry.name, "encrypting volume member") + })? + } else { + None + }; + let base_flags = entry.base_flags | if split_salt.is_some() { FHD_SALT } else { 0 }; + + // Packing well enough to need only one volume is not an error. The loop + // below already writes that set correctly: with one chunk neither split + // flag is set, so the member is an ordinary unsplit file inside a volume + // set of one, which is what WinRAR writes and what RAR 5 here already did. + // Refusing it meant a fixed `--volume-size` in a script could start failing + // because compression improved, which is how it was found. + let chunks: Vec<&[u8]> = packed.chunks(entry.max_packed_per_volume).collect(); + + let mut volumes = Vec::with_capacity(chunks.len()); + let unpacked_crc = crc32(entry.unpacked); + for (index, chunk) in chunks.iter().enumerate() { + crate::write_progress::check_cancelled(Some(entry.progress))?; + let split_before = index > 0; + let split_after = index + 1 < chunks.len(); + let mut file_flags = base_flags; + if split_before { + file_flags |= FHD_SPLIT_BEFORE; + } + if split_after { + file_flags |= FHD_SPLIT_AFTER; + } + + let mut main_flags = MHD_VOLUME | entry.main_flags; + if index == 0 { + main_flags |= MHD_FIRSTVOLUME; + } + + let mut out = Vec::new(); + out.extend_from_slice(RAR15_SIGNATURE); + write_main_header(&mut out, main_flags); + write_file_header_and_data( + &mut out, + FileRecord { + head_type: FILE_HEAD, + name: entry.name, + unpacked_size: entry.unpacked.len(), + file_crc: if split_after { + crc32(chunk) + } else { + unpacked_crc + }, + packed_size: chunk.len(), + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: entry.target, + method: entry.method, + dictionary_flags: entry.dictionary_flags, + flags: file_flags, + salt: split_salt, + extra: &[], + }, + chunk, + ) + .map_err(|error| { + crate::write_stream::member_error(error, entry.name, "writing volume member") + })?; + report_volume(entry.progress, index, chunks.len(), out.len())?; + volumes.push(out); + } + + Ok(volumes) +} + +fn write_header_encrypted_split_volumes(entry: SplitVolumeRecord<'_>) -> Result>> { + crate::write_progress::check_cancelled(Some(entry.progress))?; + validate_header_encrypted_archive_options(entry.target, entry.password.is_some())?; + let password = entry.password.ok_or(Error::NeedPassword)?; + if entry.max_packed_per_volume == 0 { + return Err(Error::InvalidArgument( + "RAR 1.5 volume payload size must be non-zero", + )); + } + if entry.packed.is_empty() { + return Err(Error::InvalidArgument( + "RAR 1.5 volume writer needs a non-empty packed payload", + ) + .at_entry(entry.name.to_vec(), "preparing volume member")); + } + + let mut packed = entry.packed.to_vec(); + let split_salt = + encrypt_split_packed_data(&mut packed, entry.target, password).map_err(|error| { + crate::write_stream::member_error(error, entry.name, "encrypting volume member") + })?; + let base_flags = entry.base_flags | FHD_SALT; + // Packing well enough to need only one volume is not an error. The loop + // below already writes that set correctly: with one chunk neither split + // flag is set, so the member is an ordinary unsplit file inside a volume + // set of one, which is what WinRAR writes and what RAR 5 here already did. + // Refusing it meant a fixed `--volume-size` in a script could start failing + // because compression improved, which is how it was found. + let chunks: Vec<&[u8]> = packed.chunks(entry.max_packed_per_volume).collect(); + + let mut volumes = Vec::with_capacity(chunks.len()); + let unpacked_crc = crc32(entry.unpacked); + for (index, chunk) in chunks.iter().enumerate() { + crate::write_progress::check_cancelled(Some(entry.progress))?; + let split_before = index > 0; + let split_after = index + 1 < chunks.len(); + let mut file_flags = base_flags; + if split_before { + file_flags |= FHD_SPLIT_BEFORE; + } + if split_after { + file_flags |= FHD_SPLIT_AFTER; + } + + let mut main_flags = MHD_VOLUME | MHD_PASSWORD | entry.main_flags; + if index == 0 { + main_flags |= MHD_FIRSTVOLUME; + } + + let mut out = Vec::new(); + out.extend_from_slice(RAR15_SIGNATURE); + write_main_header(&mut out, main_flags); + let mut header = Vec::new(); + write_file_header( + &mut header, + &FileRecord { + head_type: FILE_HEAD, + name: entry.name, + unpacked_size: entry.unpacked.len(), + file_crc: if split_after { + crc32(chunk) + } else { + unpacked_crc + }, + packed_size: chunk.len(), + file_time: entry.file_time, + file_attr: entry.file_attr, + host_os: entry.host_os, + target: entry.target, + method: entry.method, + dictionary_flags: entry.dictionary_flags, + flags: file_flags, + salt: split_salt, + extra: &[], + }, + ) + .map_err(|error| { + crate::write_stream::member_error(error, entry.name, "writing volume member") + })?; + write_encrypted_header(&mut out, &header, password).map_err(|error| { + crate::write_stream::member_error(error, entry.name, "writing volume member") + })?; + out.extend_from_slice(chunk); + report_volume(entry.progress, index, chunks.len(), out.len())?; + volumes.push(out); + } + + Ok(volumes) +} + +fn write_header_crc(out: &mut [u8], start: usize) { + let crc = (crc32(&out[start + 2..]) & 0xffff) as u16; + out[start..start + 2].copy_from_slice(&crc.to_le_bytes()); +} + +fn write_file_header_crc(out: &mut [u8], start: usize, name_len: usize, flags: u16) { + let end = if flags & FHD_COMMENT != 0 { + // Readers stop the CRC where the fields they parse stop, which leaves + // out the comment block. Miss the salt out of the range and an + // encrypted member with a comment gets a CRC nothing agrees with. + let salt_len = if flags & FHD_SALT != 0 { 8 } else { 0 }; + start + 32 + name_len + salt_len + } else { + out.len() + }; + let crc = (crc32(&out[start + 2..end]) & 0xffff) as u16; + out[start..start + 2].copy_from_slice(&crc.to_le_bytes()); +} + +fn write_comment_header_crc(out: &mut [u8], start: usize) { + let end = start + 13; + let crc = (crc32(&out[start + 2..end]) & 0xffff) as u16; + out[start..start + 2].copy_from_slice(&crc.to_le_bytes()); +} + +#[cfg(test)] +mod tests { + #[test] + fn streaming_directory_sources_cannot_discard_payloads() { + for (host_os, attributes) in [(3, 0o040750), (2, 0x10)] { + let entry = super::StreamingEntry::new( + b"directory".to_vec(), + crate::EntrySource::from_bytes(b"must not be discarded".to_vec()), + ) + .with_host_os(host_os) + .with_file_attr(attributes); + let error = super::write_streaming_archive_to( + &[entry], + super::WriterOptions::new( + crate::ArchiveVersion::Rar30, + crate::FeatureSet::store_only(), + ), + crate::MemberCoding::Stored, + None, + &crate::WriterResources::default(), + None, + &mut Vec::new(), + ) + .unwrap_err(); + assert!(error.to_string().contains("directory source must be empty")); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_payload_padding_preserves_cipher_state_across_chunks() { + for target in [crate::ArchiveVersion::Rar20, crate::ArchiveVersion::Rar30] { + for length in [0usize, 1, 15, 16, 17, 65535, 65536, 65537] { + let plaintext: Vec = (0..length) + .map(|index| (index as u8).wrapping_mul(37)) + .collect(); + for split in [false, true] { + let mut data = plaintext.clone(); + let salt = if split { + super::encrypt_split_packed_data(&mut data, target, b"pw") + } else { + super::encrypt_packed_data_for_writer(&mut data, target, Some(b"pw")) + } + .unwrap(); + let padded = length.div_ceil(16) * 16; + assert_eq!(data.len(), padded); + match target { + crate::ArchiveVersion::Rar20 => { + assert_eq!(salt, None); + super::Rar20Cipher::new(b"pw") + .decrypt_in_place(&mut data) + .unwrap(); + } + crate::ArchiveVersion::Rar30 => { + assert!(salt.is_some()); + super::Rar30Cipher::new(b"pw", salt) + .unwrap() + .decrypt_in_place(&mut data) + .unwrap(); + } + _ => unreachable!(), + } + assert_eq!(&data[..length], plaintext); + assert!(data[length..].iter().all(|&byte| byte == 0)); + } + } + } + } + + #[test] + fn member_cancellation_during_workspace_admission_is_preserved() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + struct CancelOnSecondPoll(AtomicUsize); + impl crate::WriteProgress for CancelOnSecondPoll { + fn report(&self, _: crate::WriteProgressEvent<'_>) {} + + fn is_cancelled(&self) -> bool { + self.0.fetch_add(1, Ordering::Relaxed) != 0 + } + } + + let entry = super::FileEntry { + name: b"file", + data: b"payload", + file_time: 0, + file_attr: 0x20, + host_os: 3, + password: None, + file_comment: None, + }; + let callback = CancelOnSecondPoll(AtomicUsize::new(0)); + let work = super::WorkTracker::new( + Some(super::ProgressReporter(&callback)), + crate::WriteOperation::Compression, + 7, + ); + let resources = crate::WriterResources::new(1); + assert!(matches!( + super::encode_member( + &super::Member::from_file(&entry), + super::WriterOptions::new( + crate::ArchiveVersion::Rar29, + crate::FeatureSet::store_only(), + ), + &crate::MemberCoding::Stored, + &mut None, + &resources, + &work, + ), + Err(crate::Error::Cancelled) + )); + assert_eq!(callback.0.load(Ordering::Relaxed), 2); + assert_eq!(resources.workspace_in_use(), 0); + } + + #[test] + fn retained_archive_comment_metadata_requires_rar3_or_4_comment() { + let mut options = super::WriterOptions::new( + crate::ArchiveVersion::Rar30, + crate::FeatureSet::store_only(), + ); + options.archive_comment_metadata = Some((123, 0)); + let shape = crate::write_plan::PlanShape::new(); + assert_eq!( + super::validate_plan(options, shape, false, false).unwrap_err(), + crate::Error::InvalidArgument( + "retained archive comment metadata requires a RAR3/4 archive comment" + ) + ); + options.target = crate::ArchiveVersion::Rar20; + assert_eq!( + super::validate_plan(options, shape, true, false).unwrap_err(), + crate::Error::InvalidArgument( + "retained archive comment metadata requires a RAR3/4 archive comment" + ) + ); + options.target = crate::ArchiveVersion::Rar30; + assert!(super::validate_plan(options, shape, true, false).is_ok()); + } + + #[test] + fn writer_limits_and_invalid_options_are_not_archive_corruption() { + for error in [ + super::validate_member(b"", 0).unwrap_err(), + super::validate_member(&vec![b'a'; 65536], 0).unwrap_err(), + super::checked_align16(usize::MAX, "padding overflow").unwrap_err(), + super::write_comment_header(&mut Vec::new(), Some(&vec![0; 65536])).unwrap_err(), + super::header_encryption_password([Some(&b"one"[..]), Some(&b"two"[..])].into_iter()) + .unwrap_err(), + super::validate_rar29_filter_policy( + &super::FilterPolicy::Auto, + super::Rar29Method::Ppmd, + ) + .unwrap_err(), + super::rar29_encode_options_for_level(Some(6)).unwrap_err(), + super::rar20_encode_options_for_level(Some(6)).unwrap_err(), + super::rar15_encode_options_for_level(Some(6)).unwrap_err(), + ] { + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument, "{error}"); + } + assert_eq!(super::checked_align16(17, "padding overflow").unwrap(), 32); + assert_eq!( + super::header_encryption_password([None].into_iter()).unwrap_err(), + crate::Error::NeedPassword + ); + #[cfg(target_pointer_width = "64")] + assert_eq!( + super::validate_member(b"large", u32::MAX as usize + 1) + .unwrap_err() + .kind(), + crate::ErrorKind::InvalidArgument + ); + } + + use super::{ + encode_rar29_auto_filtered_member, encode_rar29_filtered_member, + encode_rar29_filtered_members, is_audio_filter_candidate, rar20_encode_options_for_level, + rar20_encode_options_for_options, rar29_encode_options_for_options, FilterKind, FilterSpec, + }; + use crate::codec::rar29::{unpack29_decode, EncodeOptions}; + + /// A member comfortably past the 1 MiB ceiling the PPMd trial used to have. + /// Text this size kept the LZ bytes without PPMd ever being encoded to + /// compare against, all the way up to 16 MiB. + const OVER_THE_OLD_TRIAL_LIMIT: usize = 1024 * 1024 + 4096; + use crate::filter_search::{ + auto_delta_filter_range, disjoint_filter_ranges, AUTO_DELTA_EDGE_SKIP, + }; + use crate::x86_filter_scan::auto_x86_filter_ranges; + use crate::{ArchiveVersion, FeatureSet}; + + #[test] + fn auto_x86_filter_ranges_select_dense_opcode_clusters() { + let mut data = vec![0x41; 20_000]; + for pos in [1024, 1050, 1090, 1130] { + data[pos] = 0xe8; + } + for pos in [12_000, 12_040, 12_080] { + data[pos] = 0xe9; + } + + let e8_ranges = auto_x86_filter_ranges(&data, false); + assert_eq!(e8_ranges.len(), 1); + assert!(e8_ranges[0].contains(&1024)); + assert!(e8_ranges[0].contains(&(1130 + 4))); + assert!(!e8_ranges[0].contains(&12_000)); + + let e8e9_ranges = auto_x86_filter_ranges(&data, true); + assert_eq!(e8e9_ranges.len(), 3); + assert!(e8e9_ranges[0].contains(&1024)); + assert!(e8e9_ranges[0].contains(&12_000)); + assert!(e8e9_ranges.iter().any(|range| range.contains(&1024))); + assert!(e8e9_ranges.iter().any(|range| range.contains(&12_000))); + } + + #[test] + fn large_text_ppmd_candidate_accepts_html_like_payloads() { + let mut data = vec![b'a'; OVER_THE_OLD_TRIAL_LIMIT]; + for index in (0..data.len()).step_by(79) { + data[index] = b'\n'; + } + data[..32].copy_from_slice(b"RAR PPMd text sample"); + + assert!(super::is_text_ppmd_candidate(&data)); + } + + /// Reading past padding leaves the question of a member that is nothing + /// else. There is no evidence either way in it, and PPMd is not the answer + /// to a member the store rule is about to take anyway. + #[test] + fn a_member_of_nothing_but_padding_is_not_text() { + let data = vec![0u8; OVER_THE_OLD_TRIAL_LIMIT]; + + assert!(!super::is_text_ppmd_candidate(&data)); + } + + /// Scattered NULs are not padding and still count against the member: a + /// run has to be long enough to be structure before it is discounted. + #[test] + fn scattered_nuls_still_read_as_binary() { + let mut data = vec![b'A'; OVER_THE_OLD_TRIAL_LIMIT]; + for index in (0..data.len()).step_by(3) { + data[index] = 0; + } + + assert!(!super::is_text_ppmd_candidate(&data)); + } + + /// The bench corpus is man pages in several languages, and counting only + /// ASCII scored the sample 77% against an 85% bar and sent it to LZ. + #[test] + fn the_text_screen_reads_multibyte_utf8_as_text() { + let line = "Überprüfen Sie die Größe der Datei — ändern Sie sie nicht. \ + 日本語ã�®ãƒžãƒ‹ãƒ¥ã‚¢ãƒ«ãƒšãƒ¼ã‚¸ã‚‚テキストã�§ã�™ã€‚\n"; + let data = line.repeat(4096).into_bytes(); + + let high = data.iter().filter(|&&byte| byte >= 0x80).count(); + assert!( + high * 100 / data.len() > 15, + "sample must be multibyte enough to have failed the ASCII-only test" + ); + assert!(super::is_text_ppmd_candidate(&data)); + } + + /// Accepting multibyte sequences must not accept binary that happens to + /// contain a few: a lead byte followed by a continuation byte turns up at + /// random often enough to notice, nowhere near often enough to pass. + #[test] + fn the_text_screen_still_rejects_high_entropy_binary() { + let mut state = 0x1234_5678u32; + let data: Vec<_> = (0..64_000) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + + assert!(!super::is_text_ppmd_candidate(&data)); + } + + /// A tar pads every member to a 512 byte block and closes with a block of + /// nothing, which is 27% NUL in front of a 1% bar. The source tree in the + /// bench corpus was read as binary and packed 22% behind WinRAR 3.00 for it. + #[test] + fn the_text_screen_reads_past_tar_padding() { + let mut data = Vec::new(); + for index in 0..512 { + let mut header = vec![0u8; 512]; + let name = format!("src/module{index}.rs"); + header[..name.len()].copy_from_slice(name.as_bytes()); + data.extend_from_slice(&header); + let body = format!( + "pub fn thing{index}(value: usize) -> usize {{\n value.wrapping_mul({index})\n}}\n" + ); + data.extend_from_slice(body.as_bytes()); + // Every member is padded out to the next block boundary. + data.resize(data.len().next_multiple_of(512), 0); + } + data.extend_from_slice(&[0u8; 1024]); + + let nul = data.iter().filter(|&&byte| byte == 0).count(); + assert!( + nul * 100 / data.len() > 15, + "the padding has to be heavy enough to have failed the old rule" + ); + assert!(super::is_text_ppmd_candidate(&data)); + } + + /// The other side of that: an object file is full of NUL runs too, and + /// reading past them must not turn its code into text. A member wrongly + /// called text skips the x86 filter search, so this one costs bytes. + #[test] + fn reading_past_padding_does_not_make_an_object_file_text() { + let mut state = 0x8badf00du32; + let mut data = Vec::new(); + for section in 0..64 { + // Alignment padding, the way a linker leaves it. + data.resize(data.len() + 64, 0); + data.extend_from_slice(format!("_ZN4rars{section}E\0").as_bytes()); + for _ in 0..1024 { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + data.push(state as u8); + } + } + + assert!(!super::is_text_ppmd_candidate(&data)); + } + + /// Naming the level you were already getting must not change the archive. + /// The default resolves to method 0x33, the same as `--level 3`, but the + /// trial decision read the option rather than the level and the two came + /// out 24% apart on the same text. + #[test] + fn the_default_level_and_level_three_agree_about_the_ppmd_trial() { + let options = crate::rar15_40::WriterOptions { + target: crate::ArchiveVersion::Rar30, + ..Default::default() + }; + let default_level = super::compression_method_for_level(options); + let named_level = super::compression_method_for_level(crate::rar15_40::WriterOptions { + compression_level: Some(3), + ..options + }); + + assert_eq!(default_level, named_level); + assert_eq!( + super::ppmd_trial_pays(default_level - 0x30), + super::ppmd_trial_pays(named_level - 0x30), + ); + assert!(super::ppmd_trial_pays(3)); + assert!(!super::ppmd_trial_pays(2)); + } + + #[test] + fn auto_ppmd_candidate_rejects_binary_audio_shaped_payloads() { + let mut data = Vec::new(); + for sample in 0..8192i16 { + let left = sample.wrapping_mul(5).wrapping_add(200); + let right = sample.wrapping_mul(7).wrapping_sub(200); + data.extend_from_slice(&left.to_le_bytes()); + data.extend_from_slice(&right.to_le_bytes()); + } + + assert!(!super::is_text_ppmd_candidate(&data)); + } + + #[test] + fn auto_ppmd_candidate_accepts_text_payloads() { + let data = b"fn main() {\n println!(\"rar ppmd text candidate\");\n}\n".repeat(256); + + assert!(super::is_text_ppmd_candidate(&data)); + } + + #[test] + fn audio_filter_candidate_accepts_interleaved_pcm_like_payloads() { + let mut data = Vec::new(); + for sample in 0..4096i16 { + let left = sample.wrapping_mul(3).wrapping_add(200); + let right = sample.wrapping_mul(3).wrapping_sub(200); + data.extend_from_slice(&left.to_le_bytes()); + data.extend_from_slice(&right.to_le_bytes()); + } + + assert!(is_audio_filter_candidate(&data, 4)); + assert!(!is_audio_filter_candidate(&data, 3)); + assert!(!is_audio_filter_candidate(&data, 0)); + assert!(!is_audio_filter_candidate(&data, 5)); + } + + #[test] + fn audio_filter_candidate_checks_the_smallest_admitted_window() { + for channels in 1..=4 { + assert!(!is_audio_filter_candidate( + &vec![0; channels * 64 - 1], + channels + )); + assert!(is_audio_filter_candidate(&vec![0; channels * 64], channels)); + } + } + + #[test] + fn rar15_unix_directory_and_file_modes_become_dos_attributes() { + use crate::ArchiveVersion; + + assert_eq!( + super::rar15_compatible_metadata(ArchiveVersion::Rar15, 3, 0o040755), + (0, 0x10) + ); + assert_eq!( + super::rar15_compatible_metadata(ArchiveVersion::Rar15, 3, 0o100644), + (0, 0x20) + ); + assert_eq!( + super::rar15_compatible_metadata(ArchiveVersion::Rar20, 3, 0o040755), + (3, 0o040755) + ); + } + + #[test] + fn codec_progress_restart_counts_new_work_and_preserves_codec_errors() { + use crate::write_progress::{ProgressReporter, WorkTracker}; + use crate::{WriteOperation, WriteProgressEvent}; + use std::sync::Mutex; + + let advanced = Mutex::new(Vec::new()); + let reporter = |event: WriteProgressEvent<'_>| { + if let WriteProgressEvent::Advanced { + completed_bytes, .. + } = event + { + advanced.lock().unwrap().push(completed_bytes); + } + }; + let work = WorkTracker::new( + Some(ProgressReporter(&reporter)), + WriteOperation::Compression, + 30, + ); + let encoded = super::with_codec_progress(Some(&work), |progress| { + assert!(progress(10)); + assert!(progress(3)); + assert!(progress(5)); + Ok(b"packed".to_vec()) + }) + .unwrap(); + assert_eq!(encoded, b"packed"); + assert_eq!(*advanced.lock().unwrap(), [10, 13, 15]); + + let error = super::with_codec_progress(None, |_| { + Err(crate::codec::Error::InvalidData("injected codec failure")) + }) + .unwrap_err(); + assert!(matches!(error, crate::Error::Codec(_))); + } + + #[test] + fn audio_filter_candidate_rejects_high_entropy_binary_payloads() { + let mut state = 0xfeed_faceu32; + let data: Vec<_> = (0..16_384) + .map(|_| { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + state as u8 + }) + .collect(); + + for channels in 1..=4 { + assert!(!is_audio_filter_candidate(&data, channels)); + } + } + + /// Prose with no long repeats: PPMd's model has plenty to work with and LZ + /// has little to match, which is the shape the engine choice exists for. + fn prose_like_text(len: usize) -> Vec { + const WORDS: [&str; 24] = [ + "archive", + "compression", + "dictionary", + "encoder", + "filter", + "header", + "member", + "method", + "offset", + "payload", + "reader", + "solid", + "stream", + "volume", + "window", + "writer", + "the", + "of", + "a", + "and", + "to", + "in", + "that", + "with", + ]; + let mut state = 0x9e37_79b9u32; + let mut out = Vec::with_capacity(len + 16); + while out.len() < len { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + out.extend_from_slice(WORDS[state as usize % WORDS.len()].as_bytes()); + out.push(if state.is_multiple_of(13) { + b'\n' + } else { + b' ' + }); + } + out.truncate(len); + out + } + + /// Text past the trial limit used to keep the LZ bytes without ever + /// encoding PPMd to compare, which cost 24% on 2 MiB of man pages and 12% + /// on 4 MiB. The method byte cannot tell the two engines apart (PPMd and + /// `-m5` LZ both write 0x35), so ask for the member both ways instead. + #[test] + fn text_over_the_trial_limit_is_measured_against_ppmd() { + let data = prose_like_text(OVER_THE_OLD_TRIAL_LIMIT); + assert!(super::is_text_ppmd_candidate(&data)); + + let offered = + encode_rar29_auto_filtered_member(&data, EncodeOptions::default(), 0x35, true).unwrap(); + let lz_only = + encode_rar29_auto_filtered_member(&data, EncodeOptions::default(), 0x35, false) + .unwrap(); + + assert!( + offered.data.len() < lz_only.data.len(), + "PPMd should have won this member: offered {} bytes, LZ alone {}", + offered.data.len(), + lz_only.data.len() + ); + } + + /// The other half of the same rule: winning is measured, not assumed. Text + /// that is one phrase repeating is all match and belongs to LZ, and the + /// member has to come back no larger than LZ alone would have made it. + #[test] + fn text_ppmd_cannot_lose_to_the_engine_it_replaced() { + let data = b"the quick brown fox jumps over the lazy dog. " + .repeat(OVER_THE_OLD_TRIAL_LIMIT / 45 + 64); + assert!(super::is_text_ppmd_candidate(&data)); + + let offered = + encode_rar29_auto_filtered_member(&data, EncodeOptions::default(), 0x35, true).unwrap(); + let lz_only = + encode_rar29_auto_filtered_member(&data, EncodeOptions::default(), 0x35, false) + .unwrap(); + + assert!( + offered.data.len() <= lz_only.data.len(), + "offering PPMd made the member bigger: {} bytes against {}", + offered.data.len(), + lz_only.data.len() + ); + + let plain_auto = super::encode_rar29_policy_filtered_payload( + &data, + &super::FilterPolicy::None, + super::Rar29Method::Auto, + EncodeOptions::default(), + 0x35, + true, + None, + ) + .unwrap(); + let forced_ppmd = super::encode_rar29_policy_filtered_payload( + &data, + &super::FilterPolicy::None, + super::Rar29Method::Ppmd, + EncodeOptions::default(), + 0x35, + false, + None, + ) + .unwrap(); + assert_eq!(plain_auto.data, forced_ppmd.data); + } + + #[test] + fn repeated_high_entropy_text_keeps_lz_when_ppmd_loses() { + let mut state = 0x9e37_79b9u32; + let mut block = Vec::with_capacity(64 * 1024); + for _ in 0..64 * 1024 { + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + block.push(b' ' + (state % 95) as u8); + } + let mut data = block.clone(); + data.extend_from_slice(&block); + assert!(super::is_text_ppmd_candidate(&data)); + let options = EncodeOptions::default(); + let offered = encode_rar29_auto_filtered_member(&data, options, 0x35, true).unwrap(); + let lz_only = encode_rar29_auto_filtered_member(&data, options, 0x35, false).unwrap(); + assert_eq!(offered.data, lz_only.data); + + let plain_offered = super::encode_rar29_policy_filtered_payload( + &data, + &super::FilterPolicy::None, + super::Rar29Method::Auto, + options, + 0x35, + true, + None, + ) + .unwrap(); + let plain_lz = super::encode_rar29_policy_filtered_payload( + &data, + &super::FilterPolicy::None, + super::Rar29Method::Auto, + options, + 0x35, + false, + None, + ) + .unwrap(); + assert_eq!(plain_offered.data, plain_lz.data); + } + + #[test] + fn auto_x86_filter_ranges_include_code_section_spans() { + let mut data = vec![0x41; 32_000]; + for pos in [4096, 4128, 4160] { + data[pos] = 0xe8; + } + for pos in [14_000, 14_032, 14_064] { + data[pos] = 0xe8; + } + + let ranges = auto_x86_filter_ranges(&data, false); + + assert!(ranges[0].contains(&4096)); + assert!(ranges[0].contains(&14_064)); + assert!(ranges.iter().any(|range| range.contains(&4096))); + assert!(ranges.iter().any(|range| range.contains(&14_064))); + } + + #[test] + fn auto_x86_policy_can_encode_multiple_disjoint_ranges() { + let mut data = vec![0x41u8; 80_000]; + for cluster_start in [8_000, 60_000] { + for index in 0..8 { + let pos = cluster_start + index * 64; + data[pos] = 0xe8; + data[pos + 1..pos + 5].copy_from_slice(&(0x2000u32 + index as u32).to_le_bytes()); + } + } + let filters: Vec<_> = disjoint_filter_ranges(auto_x86_filter_ranges(&data, false)) + .into_iter() + .map(|range| FilterSpec::range(FilterKind::E8, range)) + .collect(); + + let packed = encode_rar29_filtered_members(&data, &filters, EncodeOptions::default()) + .expect("multi-filter RAR29 member should encode"); + let decoded = unpack29_decode(&packed, data.len()).unwrap(); + + assert_eq!(filters.len(), 2); + assert!( + decoded == data, + "RAR 2.9 auto multi-filter E8 round-trip failed" + ); + } + + #[test] + fn auto_x86_policy_considers_tight_ranges_inside_sparse_spans() { + let mut data = Vec::new(); + data.extend((0..1024).map(|index| (index * 37 + 11) as u8)); + let first_cluster_start = data.len(); + for index in 0..16usize { + data.extend_from_slice(&[0x55, 0x8b, 0xec, 0x83, 0xec, (index & 0x7f) as u8]); + let call_pos = data.len(); + data.push(0xe8); + let target = first_cluster_start + 0x500; + let relative = (target as i64 - (call_pos + 5) as i64) as i32; + data.extend_from_slice(&relative.to_le_bytes()); + data.extend_from_slice(&[0x83, 0xc4, 0x04, 0x5d, 0xc3]); + } + data.extend((0..3200).map(|index| (index * 251 + 17) as u8)); + let second_cluster_start = data.len(); + for index in 0..16usize { + data.extend_from_slice(&[0x56, 0x8b, 0xf1, 0x83, 0xec, (index & 0x7f) as u8]); + let call_pos = data.len(); + data.push(0xe8); + let target = second_cluster_start + 0x500; + let relative = (target as i64 - (call_pos + 5) as i64) as i32; + data.extend_from_slice(&relative.to_le_bytes()); + data.extend_from_slice(&[0x83, 0xc4, 0x04, 0x5e, 0xc3]); + } + data.extend((0..1024).map(|index| (index * 53 + 7) as u8)); + + let ranges = disjoint_filter_ranges(auto_x86_filter_ranges(&data, false)); + let filters: Vec<_> = ranges + .iter() + .cloned() + .map(|range| FilterSpec::range(FilterKind::E8, range)) + .collect(); + let broad_range = first_cluster_start..second_cluster_start + 16 * 16; + let broad = encode_rar29_filtered_member( + &data, + FilterSpec::range(FilterKind::E8, broad_range), + EncodeOptions::default(), + ) + .unwrap(); + let tight = encode_rar29_filtered_members(&data, &filters, EncodeOptions::default()) + .expect("tight sparse x86 filters should encode"); + let auto = encode_rar29_auto_filtered_member(&data, EncodeOptions::default(), 0x35, false) + .unwrap(); + + assert!( + tight.len() < broad.len(), + "tight x86 ranges should avoid filtering sparse data gaps" + ); + assert!(auto.data.len() <= tight.len()); + assert_eq!(unpack29_decode(&auto.data, data.len()).unwrap(), data); + } + + #[test] + fn auto_delta_filter_range_skips_container_edges_and_aligns_channels() { + let data = vec![0u8; 512]; + + let range = auto_delta_filter_range(&data, 3).unwrap(); + + assert!(range.start >= AUTO_DELTA_EDGE_SKIP); + assert!(range.end <= data.len() - AUTO_DELTA_EDGE_SKIP); + assert_eq!(range.start % 3, 0); + assert_eq!((range.end - range.start) % 3, 0); + assert!(auto_delta_filter_range(&data[..80], 3).is_none()); + } + + #[test] + fn auto_filter_policy_considers_ranged_delta_candidates() { + let mut data = vec![0x55u8; AUTO_DELTA_EDGE_SKIP]; + for sample in 0..256u16 { + let left = sample as u8; + let right = left.wrapping_add(1); + data.extend_from_slice(&[left, right]); + } + data.extend(std::iter::repeat_n(0xaa, AUTO_DELTA_EDGE_SKIP)); + let options = EncodeOptions::default(); + + let plain = + crate::codec::rar29::unpack29_encode_literals_with_options(&data, options).unwrap(); + let ranged = encode_rar29_filtered_member( + &data, + FilterSpec::range( + FilterKind::Delta { channels: 2 }, + auto_delta_filter_range(&data, 2).unwrap(), + ), + options, + ) + .unwrap(); + let auto = encode_rar29_auto_filtered_member(&data, options, 0x35, true).unwrap(); + + assert!(ranged.len() < plain.len()); + assert!(auto.data.len() <= ranged.len()); + } + + #[test] + fn rar29_options_cap_match_distance_to_target_dictionary() { + assert_eq!( + rar29_encode_options_for_options( + super::WriterOptions::new(ArchiveVersion::Rar29, FeatureSet::store_only()) + .with_compression_level(5) + ) + .unwrap() + .max_match_distance, + 1024 * 1024 + ); + assert_eq!( + rar29_encode_options_for_options( + super::WriterOptions::new(ArchiveVersion::Rar40, FeatureSet::store_only()) + .with_compression_level(5) + ) + .unwrap() + .max_match_distance, + 128 * 1024 + ); + assert_eq!( + rar29_encode_options_for_options( + super::WriterOptions::new(ArchiveVersion::Rar40, FeatureSet::store_only()) + .with_compression_level(5) + .with_dictionary_size(4 * 1024 * 1024) + ) + .unwrap() + .max_match_distance, + 4 * 1024 * 1024 + ); + } + + #[test] + fn rar20_options_cap_match_distance_to_header_dictionary() { + assert_eq!( + rar20_encode_options_for_options(super::WriterOptions::new( + ArchiveVersion::Rar20, + FeatureSet::store_only(), + )) + .unwrap() + .max_match_distance, + 64 * 1024 + ); + assert_eq!( + rar20_encode_options_for_options( + super::WriterOptions::new(ArchiveVersion::Rar20, FeatureSet::store_only()) + .with_dictionary_size(1024 * 1024), + ) + .unwrap() + .max_match_distance, + 1024 * 1024 + ); + } + #[test] + fn only_the_top_two_levels_pay_for_the_rar20_optimal_parse() { + for level in 0..=3u8 { + let options = rar20_encode_options_for_level(Some(level)).unwrap(); + assert!(!options.optimal_parse, "level {level} priced every path"); + } + for level in 4..=5u8 { + let options = rar20_encode_options_for_level(Some(level)).unwrap(); + assert!(options.optimal_parse, "level {level} settled for greedy"); + } + assert!( + !rar20_encode_options_for_level(None).unwrap().optimal_parse, + "an absent level is the default level, which is not the top of the ladder", + ); + } + + #[test] + fn every_rar20_level_looks_two_positions_ahead() { + for level in 1..=5u8 { + let options = rar20_encode_options_for_level(Some(level)).unwrap(); + assert!(options.lazy_matching, "level {level} stopped being lazy"); + assert_eq!(options.lazy_lookahead, 2, "level {level}"); + } + } +} diff --git a/arca-rar/vendor/rars/src/rar50.rs b/arca-rar/vendor/rars/src/rar50.rs new file mode 100644 index 00000000..2b56f817 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50.rs @@ -0,0 +1,4677 @@ +use crate::crc32::crc32; +#[cfg(feature = "encryption")] +use crate::crypto::rar50::Rar50Cipher; +use crate::crypto::rar50::Rar50Keys; +use crate::detect::{find_archive_start, ArchiveSignature, RAR50_SIGNATURE, SFX_SCAN_LIMIT}; +use crate::error::{Error, Result}; +#[cfg(feature = "encryption")] +use crate::io_util::align16 as checked_align16; +use crate::io_util::read_exact_at; +pub(crate) use crate::source::ArchiveSource; +use crate::version::ArchiveFamily; +use std::fs::File; +use std::io::{Read, Write}; +use std::ops::Range; +use std::path::Path; +use std::sync::Arc; + +pub use crate::filter::{FilterKind, FilterPolicy, FilterSpec}; + +mod blake2sp; +mod extract; +#[cfg(any(feature = "write", feature = "recovery"))] +mod framing; +#[cfg(feature = "write")] +pub(crate) mod write; + +pub(crate) use extract::test_volumes_to; +pub use extract::{extract_volumes_to, extract_volumes_to_with_redirections}; +#[cfg(feature = "write")] +pub use write::{ + write_streaming_archive_to, write_streaming_archive_with_progress, write_streaming_volumes_to, + write_streaming_volumes_with_progress, ArchiveEntry, ArchiveExtras, ArchiveMetadataEntry, + CollectedVolumes, Rar50Writer, ServiceEntry, VolumeSink, WriterOptions, +}; + +const HEAD_MAIN: u64 = 1; +const HEAD_FILE: u64 = 2; +const HEAD_SERVICE: u64 = 3; +const HEAD_CRYPT: u64 = 4; +const HEAD_END: u64 = 5; +const REV5_SIGNATURE: &[u8] = b"Rar!\x1aRev"; + +const HFL_EXTRA: u64 = 0x0001; +const HFL_DATA: u64 = 0x0002; +const HFL_SPLIT_BEFORE: u64 = 0x0008; +const HFL_SPLIT_AFTER: u64 = 0x0010; + +/// Set on the end-of-archive block of every volume that is not the last, so a +/// reader knows to look for the next one rather than stopping where the file +/// does. +const EFL_NEXT_VOLUME: u64 = 0x0001; + +const MHFL_VOLUME: u64 = 0x0001; +const MHFL_VOLUME_NUMBER: u64 = 0x0002; +const MHFL_SOLID: u64 = 0x0004; +const MHFL_RECOVERY: u64 = 0x0008; +const MHFL_LOCKED: u64 = 0x0010; + +const FHFL_DIRECTORY: u64 = 0x0001; +const FHFL_MTIME: u64 = 0x0002; +const FHFL_CRC32: u64 = 0x0004; +const FHFL_UNP_SIZE_UNKNOWN: u64 = 0x0008; + +const MHEXTRA_LOCATOR: u64 = 0x01; +const MHEXTRA_LOCATOR_QUICK_OPEN: u64 = 0x0001; +const MHEXTRA_LOCATOR_RECOVERY: u64 = 0x0002; + +const FHEXTRA_CRYPT: u64 = 0x01; +const FHEXTRA_HASH: u64 = 0x02; +const FHEXTRA_HTIME: u64 = 0x03; +const FHEXTRA_REDIR: u64 = 0x05; +const FHEXTRA_SUBDATA: u64 = 0x07; +const MHEXTRA_ARCHIVE_METADATA: u64 = 0x02; +const MHEXTRA_ARCHIVE_METADATA_NAME: u64 = 0x0001; +const MHEXTRA_ARCHIVE_METADATA_TIME: u64 = 0x0002; + +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct Archive { + pub sfx_offset: usize, + pub main: MainHeader, + pub blocks: Vec, + source: ArchiveSource, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct MainHeader { + pub block: BlockHeader, + pub archive_flags: u64, + pub volume_number: Option, + pub extras: Vec, + /// Whether the archive uses encrypted headers. + pub encrypted_headers: bool, + pub(crate) rewrite_metadata_complete: bool, +} + +impl MainHeader { + pub fn is_volume(&self) -> bool { + self.archive_flags & MHFL_VOLUME != 0 + } + + pub fn is_solid(&self) -> bool { + self.archive_flags & MHFL_SOLID != 0 + } + + pub fn has_recovery_record(&self) -> bool { + self.archive_flags & MHFL_RECOVERY != 0 + } + + pub fn is_locked(&self) -> bool { + self.archive_flags & MHFL_LOCKED != 0 + } + + pub fn locator(&self) -> Option<&LocatorRecord> { + self.extras.iter().find_map(|record| match record { + MainExtraRecord::Locator(locator) => Some(locator), + _ => None, + }) + } + + pub fn archive_metadata(&self) -> Option<&ArchiveMetadataRecord> { + self.extras.iter().find_map(|record| match record { + MainExtraRecord::ArchiveMetadata(metadata) => Some(metadata), + _ => None, + }) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum MainExtraRecord { + Locator(LocatorRecord), + ArchiveMetadata(ArchiveMetadataRecord), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct LocatorRecord { + pub flags: u64, + pub quick_open_offset: Option, + pub recovery_record_offset: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct ArchiveMetadataRecord { + pub flags: u64, + /// Encoded name buffer, including any reserved zero padding. A leading + /// zero means no original name was stored, even with a nonzero length. + pub name: Option>, + pub creation_time: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Block { + File(FileHeader), + Service(FileHeader), + End(EndHeader), + Unknown(BlockHeader), +} + +/// The block that closes an archive. Its one field says whether the set carries +/// on into another volume, which a reader has to honour: a volume set is not +/// over because the file is. +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct EndHeader { + pub block: BlockHeader, + pub flags: u64, +} + +impl EndHeader { + pub fn has_next_volume(&self) -> bool { + self.flags & EFL_NEXT_VOLUME != 0 + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct BlockHeader { + pub header_crc: u32, + pub header_size: u64, + pub header_type: u64, + pub flags: u64, + pub extra_area_size: Option, + pub data_size: Option, + pub offset: usize, + // Type-specific header bytes are archive-relative. Payload bytes are + // source-absolute so SFX-prefixed archives can be read directly. + pub header_range: Range, + pub data_range: Range, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileHeader { + pub block: BlockHeader, + pub file_flags: u64, + pub(crate) rewrite_metadata_complete: bool, + pub unpacked_size: u64, + pub attributes: u64, + pub mtime: Option, + /// Modification time from the `FHEXTRA_HTIME` record, in Unix seconds. + /// + /// Separate from `mtime`, which is the optional base-header field. Modern + /// WinRAR writes the time here and leaves that field out: 39 of the 40 + /// RAR 5 fixtures in this tree carry `FHEXTRA_HTIME` and one carries the + /// header field, so a reader that only looks at `mtime` restores nothing + /// on almost every real archive. + pub htime_mtime: Option, + /// Fractional detail belonging to the extended modification time. + pub htime_mtime_refinement: Option, + /// Complete supported time record, retaining FILETIME ticks without narrowing. + pub file_times: Option, + pub data_crc32: Option, + pub compression_info: u64, + pub host_os: u64, + pub name: Vec, + pub hash: Option, + pub redirection: Option, + pub service_data: Option>, + pub encrypted: bool, + pub encryption: Option, + crypto: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileRedirection { + pub redirection_type: u64, + pub flags: u64, + pub target_name: Vec, +} + +impl FileRedirection { + /// Validates the redirection kinds whose metadata the writer can retain. + pub fn is_supported(&self) -> bool { + (1..=5).contains(&self.redirection_type) + && self.flags & !1 == 0 + && (self.redirection_type < 4 || self.flags == 0) + && !self.target_name.is_empty() + && !self.target_name.contains(&0) + && std::str::from_utf8(&self.target_name).is_ok() + } + + #[cfg(feature = "write")] + pub(crate) fn supports_header(&self, host: u64, attr: u64, directory: bool) -> bool { + if !self.is_supported() { + return false; + } + if self.redirection_type == 1 { + host == 1 && attr & !0o7777 == 0o120000 && !directory + } else if self.redirection_type <= 3 { + host == 0 + && attr & 0x400 != 0 + && (attr & 0x10 != 0) == directory + && (self.redirection_type != 3 || self.flags == 1) + && directory == (self.flags & 1 != 0) + } else { + // is_supported admitted only kinds 1..=5 above. + !directory + && match host { + 0 => attr & (0x400 | 0x10) == 0, + 1 => attr & !0o7777 == 0o100000, + _ => false, + } + } + } + + /// Whether this target can be emitted by the Unix symbolic link writer. + /// Targets use RAR5 wire bytes and are never resolved against the filesystem. + pub fn is_supported_unix_symlink(&self) -> bool { + self.redirection_type == 1 + && self.flags & !1 == 0 + && !self.target_name.is_empty() + && !self.target_name.contains(&0) + && std::str::from_utf8(&self.target_name).is_ok() + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileHash { + pub hash_type: u64, + pub data: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct RecoveryRecord { + pub percent: u64, + pub payload_size: u64, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct FileEncryption { + pub version: u64, + pub flags: u64, + pub kdf_count: u8, + pub salt: [u8; 16], + pub iv: [u8; 16], + pub check_value: Option<[u8; 12]>, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct FileCryptoState { + keys: Rar50Keys, + iv: [u8; 16], +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct Rev5Volume { + pub version: u8, + pub data_count: u16, + pub recovery_count: u16, + pub recovery_number: u16, + pub payload_crc32: u32, + pub payload_size: u64, + pub payload: Vec, + pub data_volumes: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct Rev5VolumeMeta { + pub version: u8, + pub data_count: u16, + pub recovery_count: u16, + pub recovery_number: u16, + pub payload_crc32: u32, + pub payload_size: u64, + pub data_volumes: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct Rev5DataVolume { + pub file_size: u64, + pub crc32: u32, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct CompressionInfo { + pub algorithm_version: u8, + pub solid: bool, + pub method: u8, + pub dictionary_power: u8, + pub dictionary_fraction: u8, + pub rar5_compat: bool, + pub dictionary_size: u64, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub struct ExtractedEntryMeta { + pub name: Vec, + /// Unix modification time in seconds; absence is distinct from epoch. + pub file_time: Option, + pub mtime_refinement: Option, + pub attr: u64, + pub host_os: u64, + pub is_directory: bool, +} + +impl FileHeader { + /// Declared logical output size, unless the format marks it unknown. + /// Early split fragments can have unknown sizes while the final one is known. + /// This does not imply that the decoder supports unknown-size streams. + pub fn known_unpacked_size(&self) -> Option { + (self.file_flags & FHFL_UNP_SIZE_UNKNOWN == 0).then_some(self.unpacked_size) + } + + pub fn name_bytes(&self) -> &[u8] { + &self.name + } + + /// Returns the file name with invalid UTF-8 replaced for display only. + /// + /// Use [`Self::name_bytes`] when exact archive bytes matter. + pub fn name_lossy(&self) -> String { + String::from_utf8_lossy(&self.name).into_owned() + } + + pub fn is_split_before(&self) -> bool { + self.block.flags & HFL_SPLIT_BEFORE != 0 + } + + pub fn is_split_after(&self) -> bool { + self.block.flags & HFL_SPLIT_AFTER != 0 + } + + pub fn is_directory(&self) -> bool { + self.file_flags & FHFL_DIRECTORY != 0 + } + + pub fn is_stored(&self) -> bool { + compression_method(self.compression_info) == 0 + } + + pub fn is_redirection(&self) -> bool { + self.redirection.is_some() + } + + pub fn decoded_compression_info(&self) -> Result { + decode_compression_info(self.compression_info) + } + + pub fn packed_size(&self) -> u64 { + self.block.data_size.unwrap_or(0) + } + + pub fn packed_data(&self, archive: &Archive) -> Result> { + archive.read_range(self.block.data_range.clone()) + } + + pub fn verify_crc32(&self, data: &[u8]) -> Result<()> { + let Some(expected) = self.data_crc32 else { + return Ok(()); + }; + if self.uses_hash_mac() { + return Err(Error::InvalidHeader( + "RAR 5 encrypted CRC32 verification needs encryption keys", + )); + } + let actual = crc32(data); + if actual == expected { + Ok(()) + } else { + Err(Error::Crc32Mismatch { expected, actual }) + } + } + + pub fn verify_hash(&self, data: &[u8]) -> Result<()> { + let Some(hash) = &self.hash else { + return Ok(()); + }; + if self.uses_hash_mac() { + return Err(Error::InvalidHeader( + "RAR 5 encrypted hash verification needs encryption keys", + )); + } + match hash.hash_type { + 0 if hash.data.len() == 32 => { + let actual = blake2sp::hash(data); + if hash.data == actual { + Ok(()) + } else { + Err(Error::HashMismatch { hash_type: 0 }) + } + } + 0 => Err(Error::InvalidHeader( + "RAR 5 BLAKE2sp hash record has invalid length", + )), + _ => Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 unknown file hash type", + }), + } + } + + /// Checks the authoritative payload checksum, as extraction does. + pub fn verify_integrity(&self, data: &[u8]) -> Result<()> { + self.verify_integrity_with_keys(data, None) + } + + fn uses_hash_mac(&self) -> bool { + self.encryption + .as_ref() + .is_some_and(|encryption| encryption.flags & 0x0002 != 0) + } + + pub fn recovery_record(&self) -> Result> { + if self.name != b"RR" { + return Ok(None); + } + let Some(data) = &self.service_data else { + return Err(Error::InvalidHeader( + "RAR 5 recovery service is missing service data", + )); + }; + let (percent, len) = read_vint_at(data, 0, data.len())?; + if len != data.len() { + return Err(Error::InvalidHeader( + "RAR 5 recovery service data has trailing bytes", + )); + } + Ok(Some(RecoveryRecord { + percent, + payload_size: self.packed_size(), + })) + } +} + +impl Archive { + pub fn parse(input: &[u8]) -> Result { + Self::parse_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_owned(input: Vec) -> Result { + Self::parse_owned_with_options(input, crate::ArchiveReadOptions::default()) + } + + pub fn parse_with_options( + input: &[u8], + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let data: Arc<[u8]> = Arc::from(input.to_vec().into_boxed_slice()); + Self::parse_shared(data, options) + } + + pub fn parse_owned_with_options( + input: Vec, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + Self::parse_shared(Arc::from(input.into_boxed_slice()), options) + } + + pub fn parse_with_password(input: &[u8], password: Option<&[u8]>) -> Result { + Self::parse_with_options( + input, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_owned_with_password(input: Vec, password: Option<&[u8]>) -> Result { + Self::parse_owned_with_options( + input, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path(path: impl AsRef) -> Result { + Self::parse_path_with_options(path, crate::ArchiveReadOptions::default()) + } + + pub fn parse_path_with_password( + path: impl AsRef, + password: Option<&[u8]>, + ) -> Result { + Self::parse_path_with_options( + path, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path_with_options( + path: impl AsRef, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let path = Arc::new(path.as_ref().to_path_buf()); + let mut file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + let scan_len = len.min(SFX_SCAN_LIMIT as u64) as usize; + let mut scan = vec![0; scan_len]; + file.read_exact(&mut scan)?; + options.check_cancelled()?; + let sig = find_archive_start(&scan, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedSignature); + } + // The detector found sig.offset inside the scanned prefix of this file. + let archive_len = usize::try_from(len) + .map_err(|_| Error::InvalidHeader("RAR 5 archive size overflows usize"))? + - sig.offset; + Self::parse_file_backed( + &mut file, + archive_len, + sig.offset, + ArchiveSource::File(path), + options, + ) + } + + pub fn parse_path_with_signature_and_password( + path: impl AsRef, + signature: ArchiveSignature, + password: Option<&[u8]>, + ) -> Result { + Self::parse_path_with_signature( + path, + signature, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + pub fn parse_path_with_signature( + path: impl AsRef, + signature: ArchiveSignature, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + if signature.family != ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedSignature); + } + let path = Arc::new(path.as_ref().to_path_buf()); + let mut file = File::open(path.as_ref())?; + let len = file.metadata()?.len(); + let archive_len = usize::try_from(len) + .map_err(|_| Error::InvalidHeader("RAR 5 archive size overflows usize"))? + .checked_sub(signature.offset) + .ok_or(Error::TooShort)?; + Self::parse_file_backed( + &mut file, + archive_len, + signature.offset, + ArchiveSource::File(path), + options, + ) + } + + fn parse_shared(input: Arc<[u8]>, options: crate::ArchiveReadOptions<'_>) -> Result { + options.check_cancelled()?; + let sig = find_archive_start(&input, SFX_SCAN_LIMIT).ok_or(Error::UnsupportedSignature)?; + if sig.family != ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedSignature); + } + // Signature detection admitted this offset within the immutable input. + let archive = &input[sig.offset..]; + let mut parsed = Self::parse_seekable( + archive, + sig.offset, + ArchiveSource::Memory(Arc::clone(&input)), + options, + )?; + parsed.sfx_offset = sig.offset; + Ok(parsed) + } + + fn parse_seekable( + input: &[u8], + sfx_offset: usize, + source: ArchiveSource, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + // parse_shared supplies the exact signature found in this buffer. + let archive_len = input.len(); + let (main, blocks) = parse_archive_blocks( + archive_len, + options, + |offset, budget| { + parse_block_header_bytes(input, offset, archive_len, sfx_offset, budget) + }, + |offset, keys, budget| { + parse_encrypted_block_header_bytes( + input, + offset, + archive_len, + sfx_offset, + keys, + budget, + ) + }, + )?; + + options.check_cancelled()?; + Ok(Self { + sfx_offset, + main, + blocks, + source, + }) + } + + pub(crate) fn parse_file_backed( + file: &mut (impl Read + std::io::Seek), + archive_len: usize, + sfx_offset: usize, + source: ArchiveSource, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + options.check_cancelled()?; + let signature = read_exact_at(file, sfx_offset, RAR50_SIGNATURE.len())?; + if signature != RAR50_SIGNATURE { + return Err(Error::UnsupportedSignature); + } + + let control = crate::read_control::ReadControl::new(options.cancellation); + let file_cell = std::cell::RefCell::new(control.reader(file)); + let (main, blocks) = parse_archive_blocks( + archive_len, + options, + |offset, budget| { + read_block_header_at( + &mut *file_cell.borrow_mut(), + offset, + archive_len, + sfx_offset, + budget, + ) + }, + |offset, keys, budget| { + read_encrypted_block_header_at( + &mut *file_cell.borrow_mut(), + offset, + archive_len, + sfx_offset, + keys, + budget, + ) + }, + )?; + + options.check_cancelled()?; + Ok(Self { + sfx_offset, + main, + blocks, + source, + }) + } + + fn read_range(&self, range: Range) -> Result> { + self.source.read_range(range) + } + + fn source_len(&self) -> Result { + self.source.len() + } + + fn range_reader(&self, range: Range) -> Result> { + self.source.range_reader(range) + } + + fn copy_range_to(&self, range: Range, writer: &mut dyn Write) -> Result<()> { + let source_len = self.source_len()?; + if range.start > range.end || range.end > source_len { + return Err(Error::InvalidHeader("RAR 5 repair range is out of bounds")); + } + let mut reader = self.range_reader(range)?; + std::io::copy(&mut reader, writer)?; + Ok(()) + } + + pub fn files(&self) -> impl Iterator { + self.blocks.iter().filter_map(|block| match block { + Block::File(file) => Some(file), + _ => None, + }) + } + + pub fn services(&self) -> impl Iterator { + self.blocks.iter().filter_map(|block| match block { + Block::Service(service) => Some(service), + _ => None, + }) + } + + /// Decodes the archive-level `CMT` service payload, if any. + /// + /// RAR 5 stores comments as `Service` blocks named `CMT`. Archive-level + /// comments appear before any `File` block; service blocks attached to a + /// specific file follow that file. This returns only the former. + pub fn archive_comment(&self) -> Result>> { + self.archive_comment_with_password(None) + } + + /// Same as [`Self::archive_comment`] but supplies a password for + /// individually-encrypted comment services. + pub fn archive_comment_with_password( + &self, + password: Option<&[u8]>, + ) -> Result>> { + self.archive_comment_with_options(crate::ArchiveReadOptions::with_optional_password( + password, + )) + } + + /// Decodes the archive comment under the same policy as [`crate::Archive::comment_with_options`]. + pub fn archive_comment_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + ) -> Result>> { + options.check_cancelled()?; + for block in &self.blocks { + match block { + Block::File(_) => return Ok(None), + Block::Service(service) if service.name == b"CMT" => { + return service + .decoded_comment_with_options(self, options) + .map(Some); + } + _ => {} + } + } + Ok(None) + } + + pub fn repair_recovery(&self) -> Result> { + Ok(self.repair_recovery_with_report(None)?.data) + } + + pub fn repair_recovery_with_report( + &self, + password: Option<&[u8]>, + ) -> Result { + self.repair_recovery_with_options(crate::ArchiveReadOptions::with_optional_password( + password, + )) + } + + /// Repairs embedded recovery data using password and cancellation only. + pub fn repair_recovery_with_options( + &self, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + let mut data = Vec::new(); + let report = self.repair_recovery_to_with_options(&mut data, options)?; + Ok(crate::RecoveryRepairResult { data, report }) + } + + pub fn repair_recovery_to(&self, writer: &mut dyn Write) -> Result<()> { + self.repair_recovery_to_with_report(writer, None) + .map(|_| ()) + } + + pub fn repair_recovery_to_with_report( + &self, + writer: &mut dyn Write, + password: Option<&[u8]>, + ) -> Result { + self.repair_recovery_to_with_options( + writer, + crate::ArchiveReadOptions::with_optional_password(password), + ) + } + + /// Streams repaired bytes with cooperative cancellation; partial output can remain. + /// Only password and cancellation apply from the read options. + pub fn repair_recovery_to_with_options( + &self, + writer: &mut dyn Write, + options: crate::ArchiveReadOptions<'_>, + ) -> Result { + #[cfg(not(feature = "recovery"))] + { + let _ = (self, writer, options); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + options.check_cancelled()?; + let password = options.password; + let control = crate::read_control::ReadControl::new(options.cancellation); + let recovery = self.recovery_service()?; + let recovery_data = recovery.decoded_recovery_data(self, password, &control)?; + let (available, expected) = + crate::recovery::rar5::inline_recovery_chunk_counts_with_control( + &recovery_data, + &control, + )?; + if available == expected || self.sfx_offset != 0 { + return self.repair_recovery_to_legacy( + writer, + &recovery_data, + available, + expected, + &control, + ); + } + let bytes = self.read_range(0..self.source_len()?)?; + let options = crate::recovery::rar5::InlineRepairOptions { + password, + control: control.clone(), + record_range: Some(recovery.block.data_range.clone()), + }; + let (data, report) = crate::recovery::rar5::repair_inline_recovery_archive_with_report( + &bytes, &options, + )?; + control.finish(control.write_all(writer, &data).map_err(Error::from))?; + control.check()?; + Ok(report) + } + } + + #[cfg(feature = "recovery")] + fn recovery_service(&self) -> Result<&FileHeader> { + self.services() + .find(|service| matches!(service.recovery_record(), Ok(Some(_)))) + .ok_or(Error::InvalidHeader( + "RAR 5 archive does not contain an inline recovery record", + )) + } + + #[cfg(feature = "recovery")] + fn repair_recovery_to_legacy( + &self, + writer: &mut dyn Write, + recovery_data: &[u8], + available: u64, + expected: u64, + control: &crate::read_control::ReadControl, + ) -> Result { + control.check()?; + let recovery = self.recovery_service()?; + let prefix_start = self.sfx_offset; + let prefix_end = recovery.block.offset; + let prefix_len = prefix_end + .checked_sub(prefix_start) + .ok_or(Error::InvalidHeader( + "RAR 5 recovery prefix range overflows archive bounds", + ))?; + let source_len = self.source_len()?; + if prefix_end > source_len { + return Err(Error::InvalidHeader( + "RAR 5 recovery prefix is out of bounds", + )); + } + let repaired_shards = + crate::recovery::rar5::repair_inline_recovery_prefix_shards_with_control( + prefix_len, + recovery_data, + |range| { + // The repair helper bounds every range by prefix_len, and + // prefix_start + prefix_len equals admitted prefix_end. + let start = prefix_start + range.start; + let end = prefix_start + range.end; + self.read_range(start..end) + .map_err(|_| crate::recovery::rar5::Error::BadRecoveryChunk) + }, + control, + )?; + + self.copy_repair_range(0..prefix_start, writer, control)?; + let mut cursor = 0usize; + let data_repaired = !repaired_shards.is_empty(); + for (range, data) in repaired_shards { + control.check()?; + self.copy_repair_range( + prefix_start + cursor..prefix_start + range.start, + writer, + control, + )?; + control.finish(control.write_all(writer, &data).map_err(Error::from))?; + cursor = range.end; + } + self.copy_repair_range(prefix_start + cursor..prefix_end, writer, control)?; + self.copy_repair_range(prefix_end..source_len, writer, control)?; + control.check()?; + Ok(crate::RecoveryRepairReport { + changed: data_repaired, + data_repaired, + recovery_record_rebuilt: false, + end_record_rebuilt: false, + available_recovery_shards: Some(available), + expected_recovery_shards: Some(expected), + }) + } + #[cfg(feature = "recovery")] + fn copy_repair_range( + &self, + range: Range, + writer: &mut dyn Write, + control: &crate::read_control::ReadControl, + ) -> Result<()> { + for start in (range.start..range.end).step_by(64 * 1024) { + control.check()?; + let data = self.read_range(start..(start.saturating_add(64 * 1024)).min(range.end))?; + control.finish(control.write_all(writer, &data).map_err(Error::from))?; + } + control.check() + } +} + +impl Rev5Volume { + pub fn parse(input: &[u8]) -> Result { + let (meta, payload_range) = Rev5VolumeMeta::parse_with_payload_range(input)?; + let payload = &input[payload_range]; + let actual_payload_crc = crc32(payload); + if actual_payload_crc != meta.payload_crc32 { + return Err(Error::Crc32Mismatch { + expected: meta.payload_crc32, + actual: actual_payload_crc, + }); + } + + Ok(Self { + version: meta.version, + data_count: meta.data_count, + recovery_count: meta.recovery_count, + recovery_number: meta.recovery_number, + payload_crc32: meta.payload_crc32, + payload_size: meta.payload_size, + payload: payload.to_vec(), + data_volumes: meta.data_volumes, + }) + } +} + +impl Rev5VolumeMeta { + pub fn parse(input: &[u8]) -> Result { + Self::parse_with_payload_range(input).map(|(meta, _)| meta) + } + + fn parse_with_payload_range(input: &[u8]) -> Result<(Self, Range)> { + if !input.starts_with(REV5_SIGNATURE) { + return Err(Error::UnsupportedSignature); + } + if input.len() < 16 { + return Err(Error::TooShort); + } + // The complete 16-byte REV prefix was admitted above. + let header_crc = u32::from_le_bytes([input[8], input[9], input[10], input[11]]); + let header_size = u32::from_le_bytes([input[12], input[13], input[14], input[15]]) as usize; + if header_size <= 5 || header_size > 0x100000 { + return Err(Error::InvalidHeader("RAR 5 REV header size is invalid")); + } + // The header-size limit above keeps this sum within usize even on 32-bit hosts. + let header_end = 16 + header_size; + if header_end > input.len() { + return Err(Error::TooShort); + } + let actual_header_crc = crc32(&input[12..header_end]); + if actual_header_crc != header_crc { + return Err(Error::Crc32Mismatch { + expected: header_crc, + actual: actual_header_crc, + }); + } + + let body = &input[16..header_end]; + if body.len() < 11 { + return Err(Error::TooShort); + } + // The complete fixed 11-byte REV prefix was admitted above. + let version = body[0]; + if version != 1 { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 REV version", + }); + } + let data_count = u16::from_le_bytes([body[1], body[2]]); + let recovery_count = u16::from_le_bytes([body[3], body[4]]); + let recovery_number = u16::from_le_bytes([body[5], body[6]]); + let payload_crc32 = u32::from_le_bytes([body[7], body[8], body[9], body[10]]); + let first_recovery_number = u32::from(data_count); + let recovery_end = first_recovery_number + u32::from(recovery_count); + let recovery_number = u32::from(recovery_number); + if recovery_count == 0 + || recovery_number < first_recovery_number + || recovery_number >= recovery_end + { + return Err(Error::InvalidHeader("RAR 5 REV volume number is invalid")); + } + + // data_count is u16, so the complete table fits in usize on 32-bit hosts. + let expected_table_end = 11 + data_count as usize * 12; + if body.len() < expected_table_end { + return Err(Error::InvalidHeader( + "RAR 5 REV metadata table size is invalid", + )); + } + let mut data_volumes = Vec::with_capacity(data_count as usize); + for index in 0..usize::from(data_count) { + // The whole 12-byte metadata table was admitted above. + let entry = &body[11 + index * 12..11 + (index + 1) * 12]; + let file_size = u64::from_le_bytes([ + entry[0], entry[1], entry[2], entry[3], entry[4], entry[5], entry[6], entry[7], + ]); + let crc = u32::from_le_bytes([entry[8], entry[9], entry[10], entry[11]]); + data_volumes.push(Rev5DataVolume { + file_size, + crc32: crc, + }); + } + + Ok(( + Self { + version, + data_count, + recovery_count, + recovery_number: recovery_number as u16, + payload_crc32, + payload_size: (input.len() - header_end) as u64, + data_volumes, + }, + header_end..input.len(), + )) + } +} + +impl From<&Rev5Volume> for Rev5VolumeMeta { + fn from(volume: &Rev5Volume) -> Self { + Self { + version: volume.version, + data_count: volume.data_count, + recovery_count: volume.recovery_count, + recovery_number: volume.recovery_number, + payload_crc32: volume.payload_crc32, + payload_size: volume.payload_size, + data_volumes: volume.data_volumes.clone(), + } + } +} + +impl From for Rev5VolumeMeta { + fn from(volume: Rev5Volume) -> Self { + Self { + version: volume.version, + data_count: volume.data_count, + recovery_count: volume.recovery_count, + recovery_number: volume.recovery_number, + payload_crc32: volume.payload_crc32, + payload_size: volume.payload_size, + data_volumes: volume.data_volumes, + } + } +} + +pub fn repair_rev5_volumes_to( + data_volumes: &[Option<&[u8]>], + recovery_volumes: &[Rev5Volume], + mut write: F, +) -> Result<()> +where + F: FnMut(usize, &[u8]) -> Result<()>, +{ + #[cfg(not(feature = "recovery"))] + { + let _ = (data_volumes, recovery_volumes, &mut write); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + let first = recovery_volumes.first().ok_or(Error::InvalidHeader( + "RAR 5 REV recovery volume set is empty", + ))?; + let data_count = usize::from(first.data_count); + if data_volumes.len() != data_count { + return Err(Error::InvalidHeader( + "RAR 5 REV data volume count does not match metadata", + )); + } + if recovery_volumes.iter().any(|rev| { + rev.version != first.version + || rev.data_count != first.data_count + || rev.recovery_count != first.recovery_count + || rev.data_volumes != first.data_volumes + || rev.payload.len() != first.payload.len() + }) { + return Err(Error::InvalidHeader( + "RAR 5 REV recovery volume metadata differs across files", + )); + } + + let mut shards = Vec::with_capacity(data_count); + for (index, data) in data_volumes.iter().enumerate() { + let Some(data) = data else { + shards.push(None); + continue; + }; + let meta = &first.data_volumes[index]; + if data.len() as u64 != meta.file_size || crc32(data) != meta.crc32 { + shards.push(None); + } else { + shards.push(Some(*data)); + } + } + + let recovery_rows: Vec<_> = recovery_volumes + .iter() + .map(|rev| { + let row = usize::from(rev.recovery_number) + .checked_sub(data_count) + .ok_or(Error::InvalidHeader("RAR 5 REV recovery number is invalid"))?; + Ok((row, rev.payload.as_slice())) + }) + .collect::>()?; + let mut seen_recovery_rows = std::collections::HashSet::with_capacity(recovery_rows.len()); + if recovery_rows + .iter() + .any(|(row, _)| !seen_recovery_rows.insert(*row)) + { + return Err(Error::InvalidHeader( + "RAR 5 REV recovery volume set contains duplicate recovery rows", + )); + } + let repaired = crate::recovery::rar5::reconstruct_data_shards(&shards, &recovery_rows)?; + + for (index, (mut shard, meta)) in repaired.into_iter().zip(&first.data_volumes).enumerate() + { + let file_size = usize::try_from(meta.file_size) + .map_err(|_| Error::InvalidHeader("RAR 5 REV data volume size overflows usize"))?; + if shard.len() < file_size { + return Err(Error::InvalidHeader( + "RAR 5 REV repaired shard is shorter than data volume size", + )); + } + shard.truncate(file_size); + let actual = crc32(&shard); + if actual != meta.crc32 { + return Err(Error::Crc32Mismatch { + expected: meta.crc32, + actual, + }); + } + write(index, &shard)?; + } + Ok(()) + } +} + +pub fn repair_inline_recovery_bytes(input: &[u8]) -> Result> { + Ok(repair_inline_recovery_bytes_with_report(input)?.data) +} + +pub fn repair_inline_recovery_bytes_with_report( + input: &[u8], +) -> Result { + repair_inline_recovery_bytes_with_options(input, crate::ArchiveReadOptions::new()) +} + +pub fn repair_inline_recovery_bytes_with_options( + input: &[u8], + options: crate::ArchiveReadOptions<'_>, +) -> Result { + #[cfg(not(feature = "recovery"))] + { + let _ = (input, options); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + options.check_cancelled()?; + if !input.starts_with(RAR50_SIGNATURE) { + return Err(Error::UnsupportedSignature); + } + let repair_options = crate::recovery::rar5::InlineRepairOptions { + password: options.password, + control: crate::read_control::ReadControl::new(options.cancellation), + ..Default::default() + }; + let (repaired, report) = crate::recovery::rar5::repair_inline_recovery_archive_with_report( + input, + &repair_options, + ) + .map_err(Error::from)?; + let parse_target = if repaired == input { input } else { &repaired }; + let _ = Archive::parse_with_options(parse_target, options)?; + Ok(crate::RecoveryRepairResult { + data: repaired, + report, + }) + } +} + +/// Frames a replacement end-of-archive header for an archive that lost its +/// own. +/// +/// A volume whose last entry runs into the next part has to keep saying so, +/// and only the parsed blocks show that, so `input` is read back here. It is +/// the repaired archive rather than the damaged one, so the blocks it walks +/// are the ones the caller is about to write. A volume that splits cleanly on +/// an entry boundary is indistinguishable from a final one and loses the flag; +/// unrar and WinRAR both walk such a set from the main header anyway. +#[cfg(feature = "recovery")] +pub(crate) fn recovery_end_header( + input: &[u8], + options: crate::ArchiveReadOptions<'_>, +) -> Result> { + options.check_cancelled()?; + let password = options.password; + let end_flags = match Archive::parse_with_options(input, options) { + Ok(archive) + if archive + .files() + .last() + .is_some_and(|file| file.is_split_after()) => + { + EFL_NEXT_VOLUME + } + Err(error) => recovery_end_parse_error(error)?, + _ => 0, + }; + let first = parse_block_header_bytes( + input, + RAR50_SIGNATURE.len(), + input.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(options), + )?; + let keys = if first.block.header_type == HEAD_CRYPT { + Some(parse_archive_encryption_header(&first, password)?.0) + } else { + None + }; + let mut specific = framing::HeaderScratch::<10>::new(); + specific.vint(end_flags); + let image = framing::HeaderImage::new(HEAD_END, 0, None, &specific, &[])?; + let mut end = vec![0; image.image_len(keys.is_some(), 0)?]; + image.render_into(keys.as_ref(), &[], &mut end)?; + Ok(end) +} + +#[cfg(feature = "recovery")] +fn recovery_end_parse_error(error: Error) -> Result { + if error.kind() == crate::ErrorKind::Cancelled { + Err(error) + } else { + Ok(0) + } +} + +fn parse_main_header_bytes(parsed: &ParsedBlockHeader) -> Result { + let mut reader = HeaderReader::new(&parsed.header, parsed.type_specific_range.clone()); + let archive_flags = reader.read_vint()?; + let volume_number = if archive_flags & MHFL_VOLUME_NUMBER != 0 { + Some(reader.read_vint()?) + } else { + None + }; + let (extras, complete) = + parse_main_extra_area(&parsed.header, parsed.extra_range.clone(), &parsed.control)?; + Ok(MainHeader { + block: parsed.block.clone(), + archive_flags, + volume_number, + extras, + encrypted_headers: false, + rewrite_metadata_complete: complete && reader.pos == reader.range.end, + }) +} + +fn parse_main_extra_area( + input: &[u8], + range: Range, + control: &crate::read_control::ReadControl, +) -> Result<(Vec, bool)> { + let mut records = Vec::new(); + let mut complete = true; + let mut seen = std::collections::HashSet::new(); + let parsed_complete = + parse_extra_records(input, range, false, control, |record_type, data| { + complete &= seen.insert(record_type); + match record_type { + MHEXTRA_LOCATOR => { + let mut reader = SliceReader::new(input, data.start, data.end); + let flags = reader.read_vint()?; + let quick_open_offset = if flags & MHEXTRA_LOCATOR_QUICK_OPEN != 0 { + Some(reader.read_vint()?) + } else { + None + }; + let recovery_record_offset = if flags & MHEXTRA_LOCATOR_RECOVERY != 0 { + Some(reader.read_vint()?) + } else { + None + }; + complete &= flags & !3 == 0 && reader.pos == reader.end; + // LOCATOR records are intentionally forward-compatible: known + // offsets are parsed and any trailing bytes remain reserved for + // future flags. + records.push(MainExtraRecord::Locator(LocatorRecord { + flags, + quick_open_offset, + recovery_record_offset, + })); + Ok(()) + } + MHEXTRA_ARCHIVE_METADATA => { + let mut reader = SliceReader::new(input, data.start, data.end); + let flags = reader.read_vint()?; + let name = if flags & MHEXTRA_ARCHIVE_METADATA_NAME != 0 { + let name_len = usize_from_u64( + reader.read_vint()?, + "RAR 5 archive metadata name length overflows usize", + )?; + Some(reader.read_bytes(name_len)?.to_vec()) + } else { + None + }; + let creation_time = if flags & MHEXTRA_ARCHIVE_METADATA_TIME != 0 { + Some(if flags & 4 != 0 && flags & 8 == 0 { + u64::from(reader.read_u32()?) + } else { + reader.read_u64()? + }) + } else { + None + }; + if reader.pos != reader.end { + return Err(Error::InvalidHeader( + "RAR 5 archive metadata record has trailing bytes", + )); + } + complete &= flags & !15 == 0 && (flags & 8 == 0 || flags & 4 != 0); + records.push(MainExtraRecord::ArchiveMetadata(ArchiveMetadataRecord { + flags, + name, + creation_time, + })); + Ok(()) + } + _ => { + complete = false; + Ok(()) + } + } + })?; + Ok((records, complete && parsed_complete)) +} + +fn parse_file_header_bytes(parsed: &ParsedBlockHeader) -> Result { + let mut reader = HeaderReader::new(&parsed.header, parsed.type_specific_range.clone()); + let file_flags = reader.read_vint()?; + let unpacked_size = reader.read_vint()?; + let attributes = reader.read_vint()?; + let mtime = if file_flags & FHFL_MTIME != 0 { + Some(reader.read_u32()?) + } else { + None + }; + let data_crc32 = if file_flags & FHFL_CRC32 != 0 { + Some(reader.read_u32()?) + } else { + None + }; + let compression_info = reader.read_vint()?; + let host_os = reader.read_vint()?; + let name_len = usize_from_u64( + reader.read_vint()?, + "RAR 5 file name length overflows usize", + )?; + let name = reader.read_bytes(name_len)?.to_vec(); + let mut file = FileHeader { + block: parsed.block.clone(), + file_flags, + rewrite_metadata_complete: reader.pos == reader.range.end, + unpacked_size, + attributes, + mtime, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32, + compression_info, + host_os, + name, + hash: None, + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + }; + parse_file_extra_area( + &parsed.header, + parsed.extra_range.clone(), + parsed.block.header_type == HEAD_SERVICE, + &mut file, + &parsed.control, + )?; + Ok(file) +} + +fn parse_file_extra_area( + input: &[u8], + range: Range, + is_service: bool, + file: &mut FileHeader, + control: &crate::read_control::ReadControl, +) -> Result<()> { + if file.block.extra_area_size.is_none() { + return Ok(()); + } + let mut seen = 0u64; + let complete = parse_extra_records(input, range, is_service, control, |record_type, data| { + let bit = 1u64 + .checked_shl(record_type as u32) + .filter(|_| record_type < 64) + .unwrap_or(0); + if bit == 0 || seen & bit != 0 { + file.rewrite_metadata_complete = false; + } + seen |= bit; + match record_type { + FHEXTRA_CRYPT => { + let encryption = parse_file_encryption_record(input, data)?; + file.rewrite_metadata_complete &= + encryption.version == 0 && encryption.flags & !3 == 0; + file.encrypted = true; + file.encryption = Some(encryption); + } + FHEXTRA_HASH => { + let (hash_type, hash_type_len) = read_vint_at(input, data.start, data.end)?; + file.rewrite_metadata_complete &= + hash_type == 0 && data.len() == hash_type_len + 32; + file.hash = Some(FileHash { + hash_type, + data: input[data.start + hash_type_len..data.end].to_vec(), + }); + } + FHEXTRA_REDIR => { + let link = parse_file_redirection_record(input, data)?; + file.rewrite_metadata_complete &= !is_service && link.is_supported(); + file.redirection = Some(link); + } + FHEXTRA_HTIME => { + let flags = read_vint_at(input, data.start, data.end).ok(); + let times = flags.and_then(|(flags, len)| { + crate::FileTimes::parse(flags, &input[data.start + len..data.end]) + }); + let parsed = parse_htime_mtime(input, data); + file.rewrite_metadata_complete &= times.is_some() + && !(file.mtime.is_some() + && times.is_some_and(|times| times.modified.is_some())); + file.file_times = times; + file.htime_mtime = parsed.map(|(seconds, _)| seconds); + file.htime_mtime_refinement = parsed.and_then(|(_, detail)| detail); + } + FHEXTRA_SUBDATA => { + file.rewrite_metadata_complete &= + is_service && (data.is_empty() || file.name == b"RR"); + file.service_data = Some(input[data].to_vec()); + } + _ => { + file.rewrite_metadata_complete = false; + } + } + Ok(()) + })?; + file.rewrite_metadata_complete &= complete; + Ok(()) +} + +/// Reads the modification time out of an `FHEXTRA_HTIME` record. +/// +/// Layout is flags, then the present times in the order mtime, ctime, atime, +/// then, when flag `0x0010` is set, one sub-second remainder per time in that +/// same order. Under flag `0x0001` a time is `uint32` Unix seconds; without it +/// a time is a `uint64` Windows FILETIME. Unix modification-time fractions follow +/// all the present whole-second values; FILETIME embeds its fraction in the ticks. +/// +/// A malformed whole-second value yields `None`; malformed fractional detail is +/// ignored while retaining valid seconds. The reference +/// readers do not fail an archive over a time they cannot read, and neither +/// should we lose the file over it. +fn parse_htime_mtime( + input: &[u8], + range: Range, +) -> Option<(u32, Option)> { + // Slice to the record first: malformed time fields must not borrow bytes + // from a following extra record or the file payload. + let data = &input[range]; + let (flags, at) = read_vint_at(data, 0, data.len()).ok()?; + if flags & 2 == 0 { + return None; + } + let (seconds, nanos) = if flags & 1 != 0 { + let seconds = + u32::from_le_bytes(data.get(at..at + 4)?.try_into().expect("four-byte slice")); + // Unix fractions follow ALL present whole-second values, not each value. + let count = (flags & 0x0e).count_ones() as usize; + // A vint occupies at most ten bytes; at most three u32 times follow. + let fraction_at = at + count * 4; + let nanos = if flags & 0x10 != 0 { + data.get(fraction_at..fraction_at + 4) + .map(|bytes| u32::from_le_bytes(bytes.try_into().expect("four-byte slice"))) + .filter(|nanos| *nanos < 1_000_000_000) + } else { + None + }; + (seconds, nanos) + } else { + let ticks = u64::from_le_bytes(data.get(at..at + 8)?.try_into().expect("eight-byte slice")); + let seconds = u32::try_from((ticks / 10_000_000).checked_sub(11_644_473_600)?).ok()?; + (seconds, Some(((ticks % 10_000_000) * 100) as u32)) + }; + Some(( + seconds, + nanos.map(|nanoseconds| crate::TimeRefinement { + add_second: false, + nanoseconds, + }), + )) +} + +fn parse_file_redirection_record(input: &[u8], range: Range) -> Result { + let (redirection_type, type_len) = read_vint_at(input, range.start, range.end)?; + let flags_start = range.start + type_len; + let (flags, flags_len) = read_vint_at(input, flags_start, range.end)?; + let name_len_start = flags_start + flags_len; + let (name_len, name_len_len) = read_vint_at(input, name_len_start, range.end)?; + let name_start = name_len_start + name_len_len; + let name_len = usize::try_from(name_len).map_err(|_| { + Error::InvalidHeader("RAR 5 file redirection target length overflows host address size") + })?; + let name_end = name_start + .checked_add(name_len) + .ok_or(Error::InvalidHeader( + "RAR 5 file redirection target length overflows", + ))?; + if name_end != range.end { + return Err(Error::InvalidHeader( + "RAR 5 file redirection record has trailing bytes", + )); + } + Ok(FileRedirection { + redirection_type, + flags, + target_name: input[name_start..name_end].to_vec(), + }) +} + +fn parse_file_encryption_record(input: &[u8], range: Range) -> Result { + let (version, version_len) = read_vint_at(input, range.start, range.end)?; + let flags_pos = range.start + version_len; + let (flags, flags_len) = read_vint_at(input, flags_pos, range.end)?; + let mut pos = flags_pos + flags_len; + if pos >= range.end { + return Err(Error::TooShort); + } + let kdf_count = input[pos]; + pos += 1; + let salt = read_array_at::<16>(input, &mut pos, range.end)?; + let iv = read_array_at::<16>(input, &mut pos, range.end)?; + let check_value = if flags & 0x0001 != 0 { + Some(read_array_at::<12>(input, &mut pos, range.end)?) + } else { + None + }; + if pos != range.end { + return Err(Error::InvalidHeader( + "RAR 5 file encryption record has trailing bytes", + )); + } + Ok(FileEncryption { + version, + flags, + kdf_count, + salt, + iv, + check_value, + }) +} + +fn parse_archive_encryption_header( + parsed: &ParsedBlockHeader, + password: Option<&[u8]>, +) -> Result<(Rar50Keys, bool)> { + #[cfg(not(feature = "encryption"))] + { + let _ = (parsed, password); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + crate::crypto::require_encryption()?; + + let mut reader = HeaderReader::new(&parsed.header, parsed.type_specific_range.clone()); + let version = reader.read_vint()?; + let flags = reader.read_vint()?; + // The first encrypted-header fields are decoded before password refusal. + let password = password.ok_or(Error::NeedPassword)?; + if version != 0 { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 unknown header encryption version", + }); + } + let kdf_count = reader.read_byte()?; + let salt = reader.read_array::<16>()?; + let check_value = if flags & 0x0001 != 0 { + Some(reader.read_array::<12>()?) + } else { + None + }; + if reader.pos != reader.range.end { + return Err(Error::InvalidHeader( + "RAR 5 archive encryption header has trailing bytes", + )); + } + let keys = Rar50Keys::derive(password, salt, kdf_count).map_err(map_rar50_crypto_error)?; + if let Some(check_value) = check_value { + keys.check_password(&check_value) + .map_err(map_rar50_crypto_error)?; + } + Ok((keys, flags & !1 == 0)) + } +} + +fn attach_file_crypto(file: &mut FileHeader, password: Option<&[u8]>) -> Result<()> { + #[cfg(not(feature = "encryption"))] + { + let _ = (file, password); + Ok(()) + } + #[cfg(feature = "encryption")] + { + if !cfg!(feature = "encryption") { + return Ok(()); + } + + // Called once for each freshly parsed file or service header. + if !file.encrypted { + return Ok(()); + } + let Some(password) = password else { + return Ok(()); + }; + let encryption = file.encryption.as_ref().ok_or(Error::InvalidHeader( + "RAR 5 encrypted file is missing encryption record", + ))?; + if encryption.version != 0 { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 unknown file encryption version", + }); + } + let keys = Rar50Keys::derive(password, encryption.salt, encryption.kdf_count) + .map_err(map_rar50_crypto_error)?; + if let Some(check_value) = encryption.check_value { + keys.check_password(&check_value) + .map_err(map_rar50_crypto_error)?; + } + file.crypto = Some(FileCryptoState { + keys, + iv: encryption.iv, + }); + Ok(()) + } +} + +fn attach_service_crypto(service: &mut FileHeader, password: Option<&[u8]>) -> Result<()> { + // WinRAR can emit encrypted QO metadata whose service-local password + // check does not validate with the archive password. QuickOpen is an + // optional cache, so keep archive parsing and file extraction independent + // from that service. + if service.name == b"QO" { + return Ok(()); + } + attach_file_crypto(service, password) +} + +#[cfg(feature = "encryption")] +fn map_rar50_crypto_error(error: crate::crypto::rar50::Error) -> Error { + match error { + crate::crypto::rar50::Error::FeatureDisabled => Error::FeatureDisabled { + feature: "encryption", + }, + crate::crypto::rar50::Error::KdfCountTooLarge => Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 KDF count", + }, + crate::crypto::rar50::Error::BadPassword => Error::WrongPasswordOrCorruptData, + crate::crypto::rar50::Error::UnalignedInput => { + Error::InvalidHeader("RAR 5 AES input is not block aligned") + } + } +} + +fn read_array_at(input: &[u8], pos: &mut usize, end: usize) -> Result<[u8; N]> { + if pos.checked_add(N).is_none_or(|next| next > end) { + return Err(Error::TooShort); + } + let mut out = [0; N]; + out.copy_from_slice(&input[*pos..*pos + N]); + *pos += N; + Ok(out) +} + +fn parse_archive_blocks( + archive_len: usize, + options: crate::ArchiveReadOptions<'_>, + mut read_block: F, + mut read_encrypted_block: G, +) -> Result<(MainHeader, Vec)> +where + F: FnMut(usize, &mut crate::parse_budget::ParseBudget) -> Result, + G: FnMut(usize, &Rar50Keys, &mut crate::parse_budget::ParseBudget) -> Result, +{ + options.check_cancelled()?; + // Budget refusals already identify the header; do not duplicate its context. + let at_offset = |error: Error, offset| match error { + Error::AtArchiveOffset { .. } => error, + error => error.at_archive_offset(offset), + }; + let password = options.password; + let mut budget = crate::parse_budget::ParseBudget::new(options); + let mut pos = RAR50_SIGNATURE.len(); + let first = read_block(pos, &mut budget).map_err(|error| at_offset(error, pos))?; + let (header_keys, header_metadata_complete) = if first.block.header_type == HEAD_CRYPT { + pos = first.next_offset; + let (keys, complete) = parse_archive_encryption_header(&first, password)?; + (Some(keys), complete) + } else { + (None, true) + }; + + let main_pos = pos; + let main_block; + let first = if let Some(keys) = &header_keys { + main_block = + read_encrypted_block(pos, keys, &mut budget).map_err(|error| at_offset(error, pos))?; + &main_block + } else { + &first + }; + if first.block.header_type != HEAD_MAIN { + return Err(Error::InvalidHeader("RAR 5 main header is missing")); + } + let mut main = parse_main_header_bytes(first).map_err(|error| at_offset(error, main_pos))?; + main.encrypted_headers = header_keys.is_some(); + main.rewrite_metadata_complete &= header_metadata_complete; + pos = first.next_offset; + + let mut blocks = Vec::new(); + while pos < archive_len { + let parsed = if let Some(keys) = &header_keys { + read_encrypted_block(pos, keys, &mut budget).map_err(|error| at_offset(error, pos))? + } else { + read_block(pos, &mut budget).map_err(|error| at_offset(error, pos))? + }; + let next = parsed.next_offset; + match parsed.block.header_type { + HEAD_FILE => { + let mut file = + parse_file_header_bytes(&parsed).map_err(|error| at_offset(error, pos))?; + attach_file_crypto(&mut file, password).map_err(|error| at_offset(error, pos))?; + blocks.push(Block::File(file)); + } + HEAD_SERVICE => { + let mut service = + parse_file_header_bytes(&parsed).map_err(|error| at_offset(error, pos))?; + attach_service_crypto(&mut service, password) + .map_err(|error| at_offset(error, pos))?; + blocks.push(Block::Service(service)); + } + HEAD_CRYPT => { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 encrypted headers", + }); + } + HEAD_END => { + main.rewrite_metadata_complete &= next == archive_len; + // A block with no room for the vint reads as no flags rather + // than as a broken archive. Hand-built and truncated archives + // do turn up with an empty end block, and the field only says + // whether to look for another volume. + let flags = read_vint_at( + &parsed.header, + parsed.type_specific_range.start, + parsed.type_specific_range.end, + ) + .map(|(flags, _)| flags) + .unwrap_or(0); + blocks.push(Block::End(EndHeader { + block: parsed.block, + flags, + })); + break; + } + _ => blocks.push(Block::Unknown(parsed.block)), + } + pos = next; + } + + main.rewrite_metadata_complete &= matches!(blocks.last(), Some(Block::End(_))); + Ok((main, blocks)) +} + +/// Walks the records of a RAR 5 extra area, handing each one to `handle`. +/// +/// A record that does not fit the area ends the walk instead of failing the +/// archive. RAR 7.12 and unrar 7.20 both extract normally from headers whose +/// extra area ends in a record claiming more bytes than are left, a size vint +/// cut off by the end of the area, or a record too small to hold its own type +/// vint. Rejecting the archive would throw away file data that is intact. +/// +/// On a service header, a single byte left over after a `SUBDATA` record is +/// folded into that record. WinRAR 5.21 and earlier stored the `SUBDATA` size +/// one less than the payload they wrote, and `SUBDATA` is the last record in +/// those headers, so the shortfall surfaces as exactly one dangling byte. +/// Without this, `RR` loses its recovery percent and `STM` loses the last +/// character of the stream name. Note that the reference readers give no way +/// to see the recovered byte from the outside: they accept the short shape, +/// but neither prints the recovery percent, so the byte itself is unverified. +fn parse_extra_records( + input: &[u8], + range: Range, + is_service: bool, + control: &crate::read_control::ReadControl, + mut handle: F, +) -> Result +where + F: FnMut(u64, Range) -> Result<()>, +{ + let mut pos = range.start; + let mut poller = control.poller(); + while pos < range.end { + poller.check(pos)?; + let Ok((record_size, size_len)) = read_vint_at(input, pos, range.end) else { + break; + }; + let payload_start = pos + size_len; + let Ok(record_payload_len) = usize::try_from(record_size) else { + break; + }; + let Some(mut record_end) = payload_start.checked_add(record_payload_len) else { + break; + }; + if record_end > range.end || record_end <= payload_start { + break; + } + let Ok((record_type, type_len)) = read_vint_at(input, payload_start, record_end) else { + break; + }; + if is_service && record_type == FHEXTRA_SUBDATA && range.end - record_end == 1 { + record_end = range.end; + } + handle(record_type, payload_start + type_len..record_end)?; + pos = record_end; + } + Ok(pos == range.end) +} + +struct ParsedBlockHeader { + control: crate::read_control::ReadControl, + block: BlockHeader, + header: Vec, + type_specific_range: Range, + extra_range: Range, + next_offset: usize, +} + +struct HeaderPrefix { + crc: u32, + size: u64, + size_len: usize, +} + +fn parse_block_header_bytes( + input: &[u8], + offset: usize, + archive_len: usize, + sfx_offset: usize, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + let remaining = archive_len.saturating_sub(offset); + if remaining < 5 { + return Err(Error::TooShort); + } + // The physical archive slice contains this complete five-byte prefix. + let header_crc = u32::from_le_bytes([ + input[offset], + input[offset + 1], + input[offset + 2], + input[offset + 3], + ]); + let after_crc = offset + 4; + let (header_size, header_size_len) = read_vint_at(input, after_crc, archive_len)?; + let header_body_len = usize_from_u64(header_size, "RAR 5 header size overflows usize")?; + let header_total = 4usize + .checked_add(header_size_len) + .and_then(|size| size.checked_add(header_body_len)) + .ok_or(Error::InvalidHeader("RAR 5 header size overflows usize"))?; + if header_total > remaining { + return Err(Error::TooShort); + } + budget.admit(header_total, offset)?; + // header_total <= archive_len-offset and archive_len == input.len(). + let header_end = offset + header_total; + let header = input[offset..header_end].to_vec(); + parse_block_header_image( + header, + offset, + archive_len, + sfx_offset, + HeaderPrefix { + crc: header_crc, + size: header_size, + size_len: header_size_len, + }, + header_total, + &budget.control, + ) +} + +fn parse_encrypted_block_header_bytes( + input: &[u8], + offset: usize, + archive_len: usize, + sfx_offset: usize, + keys: &Rar50Keys, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + #[cfg(not(feature = "encryption"))] + { + let _ = (input, offset, archive_len, sfx_offset, keys, budget); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + let remaining = archive_len.saturating_sub(offset); + if remaining < 32 { + return Err(Error::TooShort); + } + budget.check_count(offset)?; + // archive_len is this physical slice's length; remaining admitted 32 bytes. + let first = &input[offset..offset + 32]; + let mut iv = [0; 16]; + iv.copy_from_slice(&first[..16]); + let mut first_plain = [0; 16]; + first_plain.copy_from_slice(&first[16..32]); + Rar50Cipher::new(keys.key, iv).decrypt_block(&mut first_plain); + let header_crc = u32::from_le_bytes([ + first_plain[0], + first_plain[1], + first_plain[2], + first_plain[3], + ]); + let (header_size, header_size_len) = read_vint_at(&first_plain, 4, first_plain.len())?; + let header_body_len = usize_from_u64(header_size, "RAR 5 header size overflows usize")?; + let header_total = 4usize + .checked_add(header_size_len) + .and_then(|size| size.checked_add(header_body_len)) + .ok_or(Error::InvalidHeader("RAR 5 header size overflows usize"))?; + let encrypted_len = checked_align16(header_total, "RAR 5 encrypted header size overflows")?; + let disk_header_len = 16usize + .checked_add(encrypted_len) + .ok_or(Error::InvalidHeader( + "RAR 5 encrypted header size overflows", + ))?; + if disk_header_len > remaining { + return Err(Error::TooShort); + } + budget.admit(header_total, offset)?; + // The complete IV plus ciphertext length was admitted above. + let encrypted = &input[offset + 16..offset + disk_header_len]; + let mut header = encrypted.to_vec(); + Rar50Cipher::new(keys.key, iv) + .decrypt_in_place(&mut header) + .map_err(map_rar50_crypto_error)?; + header.truncate(header_total); + + parse_block_header_image( + header, + offset, + archive_len, + sfx_offset, + HeaderPrefix { + crc: header_crc, + size: header_size, + size_len: header_size_len, + }, + disk_header_len, + &budget.control, + ) + } +} + +fn read_block_header_at( + file: &mut (impl Read + std::io::Seek), + offset: usize, + archive_len: usize, + sfx_offset: usize, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + let remaining = archive_len.saturating_sub(offset); + if remaining < 5 { + return Err(Error::TooShort); + } + let prefix_len = remaining.min(14); + let prefix = read_exact_at(file, sfx_offset + offset, prefix_len)?; + // An exact prefix read returned at least five bytes above. + let header_crc = u32::from_le_bytes([prefix[0], prefix[1], prefix[2], prefix[3]]); + let (header_size, header_size_len) = read_vint_at(&prefix, 4, prefix.len())?; + let header_body_len = usize_from_u64(header_size, "RAR 5 header size overflows usize")?; + let header_total = 4usize + .checked_add(header_size_len) + .and_then(|size| size.checked_add(header_body_len)) + .ok_or(Error::InvalidHeader("RAR 5 header size overflows usize"))?; + if header_total > remaining { + return Err(Error::TooShort); + } + + budget.admit(header_total, offset)?; + let header = read_exact_at(file, sfx_offset + offset, header_total)?; + parse_block_header_image( + header, + offset, + archive_len, + sfx_offset, + HeaderPrefix { + crc: header_crc, + size: header_size, + size_len: header_size_len, + }, + header_total, + &budget.control, + ) +} + +fn read_encrypted_block_header_at( + file: &mut (impl Read + std::io::Seek), + offset: usize, + archive_len: usize, + sfx_offset: usize, + keys: &Rar50Keys, + budget: &mut crate::parse_budget::ParseBudget, +) -> Result { + #[cfg(not(feature = "encryption"))] + { + let _ = (file, offset, archive_len, sfx_offset, keys, budget); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + let remaining = archive_len.saturating_sub(offset); + if remaining < 32 { + return Err(Error::TooShort); + } + budget.check_count(offset)?; + let first = read_exact_at(file, sfx_offset + offset, 32)?; + let mut iv = [0; 16]; + iv.copy_from_slice(&first[..16]); + let mut first_plain = [0; 16]; + first_plain.copy_from_slice(&first[16..32]); + Rar50Cipher::new(keys.key, iv).decrypt_block(&mut first_plain); + let header_crc = u32::from_le_bytes([ + first_plain[0], + first_plain[1], + first_plain[2], + first_plain[3], + ]); + let (header_size, header_size_len) = read_vint_at(&first_plain, 4, first_plain.len())?; + let header_body_len = usize_from_u64(header_size, "RAR 5 header size overflows usize")?; + let header_total = 4usize + .checked_add(header_size_len) + .and_then(|size| size.checked_add(header_body_len)) + .ok_or(Error::InvalidHeader("RAR 5 header size overflows usize"))?; + let encrypted_len = checked_align16(header_total, "RAR 5 encrypted header size overflows")?; + let disk_header_len = 16usize + .checked_add(encrypted_len) + .ok_or(Error::InvalidHeader( + "RAR 5 encrypted header size overflows", + ))?; + if disk_header_len > remaining { + return Err(Error::TooShort); + } + budget.admit(header_total, offset)?; + let encrypted = read_exact_at(file, sfx_offset + offset + 16, encrypted_len)?; + let mut header = encrypted; + Rar50Cipher::new(keys.key, iv) + .decrypt_in_place(&mut header) + .map_err(map_rar50_crypto_error)?; + header.truncate(header_total); + + parse_block_header_image( + header, + offset, + archive_len, + sfx_offset, + HeaderPrefix { + crc: header_crc, + size: header_size, + size_len: header_size_len, + }, + disk_header_len, + &budget.control, + ) + } +} + +fn parse_block_header_image( + header: Vec, + offset: usize, + archive_len: usize, + sfx_offset: usize, + prefix: HeaderPrefix, + disk_header_len: usize, + control: &crate::read_control::ReadControl, +) -> Result { + control.check()?; + let header_total = header.len(); + // All four callers decoded this same immutable size prefix before reading + // or decrypting the complete header image. + validate_block_header_crc(&header, prefix.crc)?; + let type_start = 4 + prefix.size_len; + let mut reader = SliceReader::new(&header, type_start, header_total); + let header_type = reader.read_vint()?; + let flags = reader.read_vint()?; + let extra_area_size = if flags & HFL_EXTRA != 0 { + Some(reader.read_vint()?) + } else { + None + }; + let data_size = if flags & HFL_DATA != 0 { + Some(reader.read_vint()?) + } else { + None + }; + let extra_len = extra_area_size + .map(|size| usize_from_u64(size, "RAR 5 extra area size overflows usize")) + .transpose()? + .unwrap_or(0); + if extra_len > header_total.saturating_sub(reader.pos) { + return Err(Error::TooShort); + } + let type_specific_end = header_total - extra_len; + let data_len = data_size + .map(|size| usize_from_u64(size, "RAR 5 data size overflows usize")) + .transpose()? + .unwrap_or(0); + let next_offset = offset + .checked_add(disk_header_len) + .and_then(|pos| pos.checked_add(data_len)) + .ok_or(Error::InvalidHeader("RAR 5 data size overflows usize"))?; + if next_offset > archive_len { + return Err(Error::TooShort); + } + let type_specific_start = reader.pos; + // Both source adapters set archive_len = source_len-sfx_offset. Since + // next_offset <= archive_len, these absolute positions fit the source. + let data_start = sfx_offset + offset + disk_header_len; + let data_end = data_start + data_len; + + Ok(ParsedBlockHeader { + control: control.clone(), + block: BlockHeader { + header_crc: prefix.crc, + header_size: prefix.size, + header_type, + flags, + extra_area_size, + data_size, + offset: sfx_offset + offset, + header_range: (offset + type_specific_start)..(offset + type_specific_end), + data_range: data_start..data_end, + }, + header, + type_specific_range: type_specific_start..type_specific_end, + extra_range: type_specific_end..header_total, + next_offset, + }) +} + +fn validate_block_header_crc(header: &[u8], expected: u32) -> Result<()> { + // Every admitted header has a four-byte CRC and at least one size byte. + let actual = crc32(&header[4..]); + if actual != expected { + return Err(Error::Crc32Mismatch { expected, actual }); + } + Ok(()) +} + +struct HeaderReader<'a> { + input: &'a [u8], + range: Range, + pos: usize, +} + +impl<'a> HeaderReader<'a> { + fn new(input: &'a [u8], range: Range) -> Self { + // parse_block_header_image bounds this range within the header image. + Self { + input, + pos: range.start, + range, + } + } + + fn read_vint(&mut self) -> Result { + let (value, len) = read_vint_at(self.input, self.pos, self.range.end)?; + self.pos += len; + Ok(value) + } + + fn read_u32(&mut self) -> Result { + self.read_array::<4>().map(u32::from_le_bytes) + } + + #[cfg(feature = "encryption")] + fn read_byte(&mut self) -> Result { + if self.pos >= self.range.end { + return Err(Error::TooShort); + } + let value = self.input[self.pos]; + self.pos += 1; + Ok(value) + } + + fn read_array(&mut self) -> Result<[u8; N]> { + read_array_at::(self.input, &mut self.pos, self.range.end) + } + + fn read_bytes(&mut self, len: usize) -> Result<&'a [u8]> { + let end = self + .pos + .checked_add(len) + .ok_or(Error::InvalidHeader("RAR 5 field size overflows usize"))?; + if end > self.range.end { + return Err(Error::TooShort); + } + let bytes = &self.input[self.pos..end]; + self.pos = end; + Ok(bytes) + } +} + +struct SliceReader<'a> { + input: &'a [u8], + end: usize, + pos: usize, +} + +impl<'a> SliceReader<'a> { + fn new(input: &'a [u8], pos: usize, end: usize) -> Self { + Self { input, pos, end } + } + + fn read_vint(&mut self) -> Result { + let (value, len) = read_vint_at(self.input, self.pos, self.end)?; + self.pos += len; + Ok(value) + } + + fn read_u32(&mut self) -> Result { + let bytes = self.read_bytes(4)?; + Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])) + } + + fn read_u64(&mut self) -> Result { + let bytes = self.read_bytes(8)?; + Ok(u64::from_le_bytes([ + bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], + ])) + } + + fn read_bytes(&mut self, len: usize) -> Result<&'a [u8]> { + let end = self + .pos + .checked_add(len) + .ok_or(Error::InvalidHeader("RAR 5 field size overflows usize"))?; + if end > self.end { + return Err(Error::TooShort); + } + let bytes = &self.input[self.pos..end]; + self.pos = end; + Ok(bytes) + } +} + +fn read_vint_at(input: &[u8], offset: usize, end: usize) -> Result<(u64, usize)> { + let mut value = 0u64; + let mut shift = 0u32; + for i in 0..10 { + // Each previous byte was strictly before `end`, so this addition + // cannot overflow even when a caller supplies an extreme offset. + let pos = offset + i; + if pos >= end { + return Err(Error::TooShort); + } + let byte = *input.get(pos).ok_or(Error::TooShort)?; + if shift == 63 && byte & 0x7e != 0 { + return Err(Error::InvalidHeader("RAR 5 vint overflows u64")); + } + // Each group occupies disjoint bits; the final group's range was + // checked above, so combining groups cannot overflow. + value |= ((byte & 0x7f) as u64) << shift; + if byte & 0x80 == 0 { + return Ok((value, i + 1)); + } + shift += 7; + } + Err(Error::InvalidHeader("RAR 5 vint is too long")) +} + +fn usize_from_u64(value: u64, message: &'static str) -> Result { + usize::try_from(value).map_err(|_| Error::InvalidHeader(message)) +} + +fn compression_method(compression_info: u64) -> u64 { + (compression_info >> 7) & 0x07 +} + +fn decode_compression_info(raw: u64) -> Result { + let algorithm_version = (raw & 0x3f) as u8; + if algorithm_version > 1 { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 unknown compression algorithm version", + }); + } + + let dictionary_power = ((raw >> 10) & 0x1f) as u8; + let dictionary_fraction = ((raw >> 15) & 0x1f) as u8; + let rar5_compat = raw & 0x100000 != 0; + if algorithm_version == 0 && (dictionary_fraction != 0 || rar5_compat) { + return Err(Error::InvalidHeader( + "RAR 5 v0 compression info uses v1 dictionary fields", + )); + } + if algorithm_version == 0 && dictionary_power > 15 { + return Err(Error::InvalidHeader( + "RAR 5 v0 dictionary power exceeds 4 GiB limit", + )); + } + + // The wire fields are five bits each: v1 shifts by at most 43 and + // multiplies by at most 63. V0 is restricted above to a shift of 15. + let dictionary_size = if algorithm_version == 1 { + u64::from(dictionary_fraction + 32) << (u32::from(dictionary_power) + 12) + } else { + (128 * 1024_u64) << u32::from(dictionary_power) + }; + + Ok(CompressionInfo { + algorithm_version, + solid: raw & 0x40 != 0, + method: ((raw >> 7) & 0x07) as u8, + dictionary_power, + dictionary_fraction, + rar5_compat, + dictionary_size, + }) +} + +#[cfg(all(test, feature = "write"))] +mod tests { + #[test] + fn file_encryption_record_accepts_optional_check_and_rejects_truncation() { + let mut without_check = vec![0, 0, 0]; // Version, flags, KDF count. + without_check.extend_from_slice(&[7; 16]); // Salt. + without_check.extend_from_slice(&[9; 16]); // IV. + let plain = parse_file_encryption_record(&without_check, 0..without_check.len()).unwrap(); + assert_eq!(plain.check_value, None); + assert_eq!(plain.salt, [7; 16]); + assert_eq!(plain.iv, [9; 16]); + + let mut with_check = without_check.clone(); + with_check[1] = 1; + with_check.extend_from_slice(&[3; 12]); + let checked = parse_file_encryption_record(&with_check, 0..with_check.len()).unwrap(); + assert_eq!(checked.check_value, Some([3; 12])); + + assert!(matches!( + parse_file_encryption_record(&[0, 0], 0..2), + Err(Error::TooShort) + )); + assert!(matches!( + parse_file_encryption_record( + &without_check[..without_check.len() - 1], + 0..without_check.len() - 1 + ), + Err(Error::TooShort) + )); + let mut trailing = without_check; + trailing.push(0); + assert!(matches!( + parse_file_encryption_record(&trailing, 0..trailing.len()), + Err(Error::InvalidHeader( + "RAR 5 file encryption record has trailing bytes" + )) + )); + + #[cfg(feature = "encryption")] + { + let archive = build_archive_with_optional_comment(None); + let mut file = archive.files().next().unwrap().clone(); + file.encrypted = true; + file.encryption = Some(plain.clone()); + attach_file_crypto(&mut file, Some(b"password")).unwrap(); + assert!(file.crypto.is_some()); + + let mut unsupported = archive.files().next().unwrap().clone(); + unsupported.encrypted = true; + unsupported.encryption = Some(FileEncryption { + version: 1, + ..plain + }); + assert!(matches!( + attach_file_crypto(&mut unsupported, Some(b"password")), + Err(Error::UnsupportedFeature { + feature: "RAR 5 unknown file encryption version", + .. + }) + )); + } + } + + #[test] + fn duplicate_and_unknown_file_extras_disable_rewrite_preservation() { + let archive = build_archive_with_optional_comment(None); + let original = archive.files().next().unwrap(); + let control = crate::read_control::ReadControl::default(); + let mut hash_record = vec![34, FHEXTRA_HASH as u8, 0]; + hash_record.extend_from_slice(&[7; 32]); + + let mut single = original.clone(); + single.block.extra_area_size = Some(hash_record.len() as u64); + parse_file_extra_area( + &hash_record, + 0..hash_record.len(), + false, + &mut single, + &control, + ) + .unwrap(); + assert!(single.rewrite_metadata_complete); + assert!(single.hash.is_some()); + + let duplicate = [hash_record.as_slice(), hash_record.as_slice()].concat(); + let mut repeated = original.clone(); + repeated.block.extra_area_size = Some(duplicate.len() as u64); + parse_file_extra_area( + &duplicate, + 0..duplicate.len(), + false, + &mut repeated, + &control, + ) + .unwrap(); + assert!(!repeated.rewrite_metadata_complete); + assert!(repeated.hash.is_some()); + + let unknown = [1, 64]; + let mut future = original.clone(); + future.block.extra_area_size = Some(unknown.len() as u64); + parse_file_extra_area(&unknown, 0..unknown.len(), false, &mut future, &control).unwrap(); + assert!(!future.rewrite_metadata_complete); + } + + #[test] + fn preservation_preflight_rejects_unknown_parsed_file_and_comment_extras() { + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50) + .store(true) + .comment(Some(b"archive note".to_vec())); + builder + .add_bytes( + b"payload.txt".to_vec(), + b"payload bytes".to_vec(), + None, + None, + ) + .unwrap(); + let crate::Archive::Rar50Plus(seed) = + crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap() + else { + panic!("expected RAR5 archive") + }; + let baseline = crate::Archive::Rar50Plus(seed.clone()).rewrite_preservation_issues(); + assert!(baseline.is_empty(), "{baseline:?}"); + + // An extra byte in a CRC-valid main header is readable, but cannot + // be claimed to survive a rewrite. + let mut header = vec![4, HEAD_MAIN as u8, 0, 0, 0]; + let mut malformed = RAR50_SIGNATURE.to_vec(); + malformed.extend_from_slice(&crc32(&header).to_le_bytes()); + malformed.append(&mut header); + let parsed = Archive::parse(&malformed).unwrap(); + assert!(!parsed.main.rewrite_metadata_complete); + assert!(crate::Archive::Rar50Plus(parsed) + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("main header metadata"))); + + let unknown = [1, 64]; + let control = crate::read_control::ReadControl::default(); + for service in [false, true] { + let mut candidate = seed.clone(); + let file = candidate + .blocks + .iter_mut() + .find_map(|block| match block { + Block::File(file) if !service => Some(file), + Block::Service(file) if service && file.name == b"CMT" => Some(file), + _ => None, + }) + .unwrap(); + file.block.extra_area_size = Some(unknown.len() as u64); + parse_file_extra_area(&unknown, 0..unknown.len(), service, file, &control).unwrap(); + assert!(!file.rewrite_metadata_complete); + + let issues = crate::Archive::Rar50Plus(candidate).rewrite_preservation_issues(); + let expected = if service { + "service record" + } else { + "member 0" + }; + assert!( + issues.iter().any(|issue| issue.contains(expected)), + "{issues:?}" + ); + } + + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50) + .store(true) + .archive_metadata(None, false, true) + .unwrap(); + builder + .add_bytes( + b"payload.txt".to_vec(), + b"payload bytes".to_vec(), + None, + None, + ) + .unwrap(); + let crate::Archive::Rar50Plus(mut indexed) = + crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap() + else { + panic!("expected RAR5 archive") + }; + assert!(crate::Archive::Rar50Plus(indexed.clone()) + .rewrite_preservation_issues() + .is_empty()); + let quick_open = indexed + .blocks + .iter_mut() + .find_map(|block| match block { + Block::Service(service) if service.name == b"QO" => Some(service), + _ => None, + }) + .unwrap(); + quick_open.block.extra_area_size = Some(unknown.len() as u64); + parse_file_extra_area(&unknown, 0..unknown.len(), true, quick_open, &control).unwrap(); + assert!(!quick_open.rewrite_metadata_complete); + assert!(crate::Archive::Rar50Plus(indexed) + .rewrite_preservation_issues() + .iter() + .any(|issue| issue.contains("unsupported derived service"))); + } + + #[test] + fn file_extra_records_preserve_readable_metadata_and_limit_rewrites() { + let archive = build_archive_with_optional_comment(None); + let original = archive.files().next().unwrap(); + let control = crate::read_control::ReadControl::default(); + let parse = |kind: u8, payload: &[u8], service: bool, name: &[u8], mtime| { + let mut record = vec![(payload.len() + 1) as u8, kind]; + record.extend_from_slice(payload); + let mut file = original.clone(); + file.name = name.to_vec(); + file.mtime = mtime; + file.block.extra_area_size = Some(record.len() as u64); + parse_file_extra_area(&record, 0..record.len(), service, &mut file, &control).unwrap(); + file + }; + for (kind, size, complete) in [ + (0, 32, true), + (1, 32, false), + (0, 31, false), + (0, 33, false), + ] { + let mut payload = vec![kind]; + payload.extend(vec![7; size]); + let file = parse(FHEXTRA_HASH as u8, &payload, false, b"file", None); + assert_eq!(file.rewrite_metadata_complete, complete); + assert_eq!(file.hash.unwrap().data, vec![7; size]); + } + for (version, flags, complete) in [(0, 0, true), (0, 2, true), (0, 4, false), (1, 0, false)] + { + let mut payload = vec![version, flags, 0]; + payload.extend_from_slice(&[3; 16]); + payload.extend_from_slice(&[4; 16]); + let file = parse(FHEXTRA_CRYPT as u8, &payload, false, b"file", None); + assert!(file.encrypted); + assert_eq!(file.encryption.unwrap().flags, u64::from(flags)); + assert_eq!(file.rewrite_metadata_complete, complete); + } + for (service, kind, complete) in [(false, 1, true), (true, 1, false), (false, 6, false)] { + let file = parse( + FHEXTRA_REDIR as u8, + &[kind, 0, 1, b'x'], + service, + b"file", + None, + ); + assert_eq!(file.redirection.unwrap().target_name, b"x"); + assert_eq!(file.rewrite_metadata_complete, complete); + } + for (service, name, payload, complete) in [ + (false, b"file".as_slice(), b"".as_slice(), false), + (true, b"CMT".as_slice(), b"".as_slice(), true), + (true, b"CMT".as_slice(), b"x".as_slice(), false), + (true, b"RR".as_slice(), b"x".as_slice(), true), + ] { + let file = parse(FHEXTRA_SUBDATA as u8, payload, service, name, None); + assert_eq!(file.service_data.unwrap(), payload); + assert_eq!(file.rewrite_metadata_complete, complete); + } + for (flags, mtime, complete) in [(3, None, true), (3, Some(9), false), (5, Some(9), true)] { + let mut payload = vec![flags]; + payload.extend_from_slice(&123u32.to_le_bytes()); + let file = parse(FHEXTRA_HTIME as u8, &payload, false, b"file", mtime); + assert!(file.file_times.is_some()); + assert_eq!(file.htime_mtime, (flags == 3).then_some(123)); + assert_eq!(file.rewrite_metadata_complete, complete); + } + for payload in [vec![], vec![0x80], vec![3, 1], vec![0x23, 1, 0, 0, 0]] { + let file = parse(FHEXTRA_HTIME as u8, &payload, false, b"file", None); + assert!(file.file_times.is_none()); + assert!(!file.rewrite_metadata_complete); + } + let mut no_extras = original.clone(); + no_extras.block.extra_area_size = None; + parse_file_extra_area(&[0x80], 0..1, false, &mut no_extras, &control).unwrap(); + assert!(no_extras.rewrite_metadata_complete); + } + + #[test] + fn htime_mtime_retains_valid_seconds_at_format_boundaries() { + for bytes in [vec![], vec![0x80], vec![1], vec![5, 1, 0, 0, 0], vec![3, 1]] { + assert_eq!(parse_htime_mtime(&bytes, 0..bytes.len()), None); + } + for flags in [0x13u8, 0x17, 0x1b, 0x1f] { + for nanos in [0u32, 999_999_999] { + let mut bytes = vec![flags]; + for _ in 0..(flags & 0x0e).count_ones() { + bytes.extend_from_slice(&u32::MAX.to_le_bytes()); + } + bytes.extend_from_slice(&nanos.to_le_bytes()); + let (seconds, detail) = parse_htime_mtime(&bytes, 0..bytes.len()).unwrap(); + assert_eq!(seconds, u32::MAX); + assert_eq!(detail.unwrap().nanoseconds, nanos); + } + } + let epoch = 116_444_736_000_000_000u64; + for ticks in [epoch - 1, epoch + (u64::from(u32::MAX) + 1) * 10_000_000] { + let mut bytes = vec![2]; + bytes.extend_from_slice(&ticks.to_le_bytes()); + assert_eq!(parse_htime_mtime(&bytes, 0..bytes.len()), None); + // The lossless metadata representation still preserves FILETIME + // when the convenient u32 Unix-seconds view cannot represent it. + let archive = build_archive_with_optional_comment(None); + let mut file = archive.files().next().unwrap().clone(); + let mut record = vec![(bytes.len() + 1) as u8, FHEXTRA_HTIME as u8]; + record.extend_from_slice(&bytes); + file.block.extra_area_size = Some(record.len() as u64); + parse_file_extra_area( + &record, + 0..record.len(), + false, + &mut file, + &crate::read_control::ReadControl::default(), + ) + .unwrap(); + assert!(file.rewrite_metadata_complete); + assert_eq!( + file.file_times.unwrap().modified, + Some(crate::FileTimestamp::WindowsFiletime(ticks)) + ); + } + } + + #[test] + fn compression_dictionary_fields_obey_version_and_wire_limits() { + for raw in [2, 63] { + assert!(matches!( + decode_compression_info(raw), + Err(Error::UnsupportedFeature { .. }) + )); + } + for raw in [1 << 15, 0x100000, 31 << 10] { + assert!(matches!( + decode_compression_info(raw), + Err(Error::InvalidHeader(_)) + )); + } + for power in 0..=31u64 { + for fraction in 0..=31u64 { + let raw = 1 | (power << 10) | (fraction << 15); + assert_eq!( + decode_compression_info(raw).unwrap().dictionary_size, + (fraction + 32) * (1u64 << (power + 12)) + ); + } + if power <= 15 { + assert_eq!( + decode_compression_info(power << 10) + .unwrap() + .dictionary_size, + 131_072 * (1u64 << power) + ); + } + } + } + + #[test] + fn audit_redirection_identity_and_volume_metadata() { + for (kind, flags, name, supported) in [ + (1, 0, b"target".as_slice(), true), + (1, 2, b"target", false), + (4, 1, b"target", false), + (4, 0, b"target", true), + (1, 0, b"", false), + (1, 0, b"a\0b", false), + (1, 0, b"\xff", false), + (6, 0, b"target", false), + ] { + assert_eq!( + FileRedirection { + redirection_type: kind, + flags, + target_name: name.to_vec() + } + .is_supported(), + supported + ); + } + for (kind, flags, host, attr, directory, expected) in [ + (1, 0, 1, 0o120777, false, true), + (2, 0, 0, 0x400, false, true), + (3, 1, 0, 0x410, true, true), + (4, 0, 0, 0, false, true), + (5, 0, 1, 0o100644, false, true), + (6, 0, 1, 0o120777, false, false), + ] { + let link = FileRedirection { + redirection_type: kind, + flags, + target_name: b"target".to_vec(), + }; + assert_eq!(link.supports_header(host, attr, directory), expected); + } + let mut archive = build_archive_with_optional_comment(None); + assert!(!archive.main.is_locked()); + archive.main.archive_flags |= MHFL_LOCKED; + assert!(archive.main.is_locked()); + archive.main.extras = vec![MainExtraRecord::ArchiveMetadata(ArchiveMetadataRecord { + flags: 0, + name: None, + creation_time: None, + })]; + assert!(archive.main.locator().is_none()); + archive.main.extras = vec![MainExtraRecord::Locator(LocatorRecord { + flags: 0, + quick_open_offset: None, + recovery_record_offset: None, + })]; + assert!(archive.main.locator().is_some()); + for block in &mut archive.blocks { + if let Block::End(end) = block { + assert!(!end.has_next_volume()); + end.flags |= EFL_NEXT_VOLUME; + assert!(end.has_next_volume()); + } + } + } + + #[test] + fn explicit_integrity_checks_cover_absent_invalid_and_encrypted_records() { + let archive = build_archive_with_optional_comment(None); + let mut file = archive.files().next().unwrap().clone(); + let data = b"payload bytes"; + file.verify_integrity(data).unwrap(); + file.verify_crc32(data).unwrap(); + assert!(matches!( + file.verify_crc32(b"damaged"), + Err(Error::Crc32Mismatch { .. }) + )); + file.data_crc32 = None; + file.verify_crc32(b"anything").unwrap(); + file.hash = None; + file.verify_hash(b"anything").unwrap(); + file.hash = Some(FileHash { + hash_type: 0, + data: blake2sp::hash(data).to_vec(), + }); + file.verify_hash(data).unwrap(); + assert!(matches!( + file.verify_hash(b"damaged"), + Err(Error::HashMismatch { hash_type: 0 }) + )); + file.hash.as_mut().unwrap().data.pop(); + assert!(matches!( + file.verify_hash(data), + Err(Error::InvalidHeader(_)) + )); + file.hash.as_mut().unwrap().hash_type = 1; + assert!(matches!( + file.verify_hash(data), + Err(Error::UnsupportedFeature { .. }) + )); + file.encryption = Some(FileEncryption { + version: 0, + flags: 2, + kdf_count: 0, + salt: [0; 16], + iv: [0; 16], + check_value: None, + }); + assert!(matches!( + file.verify_hash(data), + Err(Error::InvalidHeader(_)) + )); + file.data_crc32 = Some(crc32(data)); + assert!(matches!( + file.verify_crc32(data), + Err(Error::InvalidHeader(_)) + )); + } + + #[test] + fn combined_integrity_check_uses_authoritative_blake2sp_record() { + // The fixture is independently accepted by RAR and UnRAR despite its + // deliberately wrong CRC32 beside the valid BLAKE2sp record. + let archive = Archive::parse(include_bytes!( + "../tests/fixtures/rar50/crc32_wrong_beside_blake2sp.rar" + )) + .unwrap(); + let file = archive.files().next().unwrap(); + let data = file.packed_data(&archive).unwrap(); + assert!(matches!( + file.verify_crc32(&data), + Err(Error::Crc32Mismatch { .. }) + )); + file.verify_hash(&data).unwrap(); + file.verify_integrity(&data).unwrap(); + } + + #[test] + fn recovery_record_distinguishes_other_services_and_rejects_missing_or_extra_data() { + let archive = build_archive_with_optional_comment(None); + let mut file = archive.files().next().unwrap().clone(); + assert_eq!(file.recovery_record().unwrap(), None); + + file.name = b"RR".to_vec(); + assert!(matches!( + file.recovery_record(), + Err(Error::InvalidHeader( + "RAR 5 recovery service is missing service data" + )) + )); + file.service_data = Some(Vec::new()); + assert_eq!(file.recovery_record(), Err(Error::TooShort)); + file.service_data = Some(vec![5, 0]); + assert!(matches!( + file.recovery_record(), + Err(Error::InvalidHeader( + "RAR 5 recovery service data has trailing bytes" + )) + )); + file.service_data = Some(vec![5]); + let record = file.recovery_record().unwrap().unwrap(); + assert_eq!(record.percent, 5); + assert_eq!(record.payload_size, file.packed_size()); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_entry_points_preserve_missing_record_and_precancellation() { + let archive = build_archive_with_optional_comment(None); + assert!(matches!( + archive.repair_recovery_to(&mut Vec::new()), + Err(Error::InvalidHeader( + "RAR 5 archive does not contain an inline recovery record" + )) + )); + let cancelled = crate::ReadCancellation::new(); + cancelled.cancel(); + let options = crate::ArchiveReadOptions::new().with_cancellation(&cancelled); + let mut output = Vec::new(); + assert!(matches!( + archive.repair_recovery_to_with_options(&mut output, options), + Err(Error::Cancelled) + )); + assert!(output.is_empty()); + assert!(matches!( + repair_inline_recovery_bytes_with_options(RAR50_SIGNATURE, options), + Err(Error::Cancelled) + )); + assert!(matches!( + recovery_end_header(RAR50_SIGNATURE, options), + Err(Error::Cancelled) + )); + assert!(matches!( + repair_inline_recovery_bytes_with_options( + RAR50_SIGNATURE, + crate::ArchiveReadOptions::new() + ), + Err(Error::Rar5Recovery( + crate::recovery::rar5::Error::BadRecoveryChunk + )) + )); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_end_header_preserves_split_volume_continuation() { + let first = include_bytes!("../tests/fixtures/rar50/multivol.part1.rar"); + let last = include_bytes!("../tests/fixtures/rar50/multivol.part3.rar"); + for (bytes, expected) in [(first.as_slice(), EFL_NEXT_VOLUME), (last.as_slice(), 0)] { + let archive = Archive::parse(bytes).unwrap(); + assert_eq!( + archive.files().last().unwrap().is_split_after(), + expected != 0 + ); + let end = recovery_end_header(bytes, crate::ArchiveReadOptions::new()).unwrap(); + let parsed = parse_block_header_bytes( + &end, + 0, + end.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + .unwrap(); + assert_eq!(parsed.block.header_type, HEAD_END); + let mut reader = HeaderReader::new(&parsed.header, parsed.type_specific_range); + assert_eq!(reader.read_vint().unwrap(), expected); + } + + assert!(matches!( + recovery_end_header(RAR50_SIGNATURE, crate::ArchiveReadOptions::new()), + Err(Error::TooShort) + )); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_end_header_keeps_parse_cancellation_distinct() { + assert!(matches!( + recovery_end_parse_error(Error::Cancelled), + Err(Error::Cancelled) + )); + assert_eq!(recovery_end_parse_error(Error::TooShort).unwrap(), 0); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_end_header_requires_keys_for_encrypted_archive() { + let bytes = include_bytes!("../tests/fixtures/rar50/header_encrypted.rar"); + #[cfg(feature = "encryption")] + { + assert!(matches!( + recovery_end_header(bytes, crate::ArchiveReadOptions::new()), + Err(Error::NeedPassword) + )); + assert!(matches!( + recovery_end_header(bytes, crate::ArchiveReadOptions::with_password(b"wrong")), + Err(Error::WrongPasswordOrCorruptData) + )); + assert!(!recovery_end_header( + bytes, + crate::ArchiveReadOptions::with_password(b"password") + ) + .unwrap() + .is_empty()); + } + #[cfg(not(feature = "encryption"))] + for options in [ + crate::ArchiveReadOptions::new(), + crate::ArchiveReadOptions::with_password(b"wrong"), + crate::ArchiveReadOptions::with_password(b"password"), + ] { + let error = recovery_end_header(bytes, options).unwrap_err(); + assert!( + matches!( + error.root_cause(), + Error::FeatureDisabled { + feature: "encryption" + } + ), + "{error:?}" + ); + } + } + + #[test] + fn header_fields_reject_truncation_overflow_and_unexpected_encryption() { + let image = |body: &[u8]| { + assert!(body.len() < 128); + let mut bytes = vec![body.len() as u8]; + bytes.extend_from_slice(body); + let mut header = crc32(&bytes).to_le_bytes().to_vec(); + header.extend_from_slice(&bytes); + header + }; + let parse = |bytes: &[u8]| { + parse_block_header_bytes( + bytes, + 0, + bytes.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + }; + for flags in [FHFL_MTIME, FHFL_CRC32] { + let header = image(&[HEAD_FILE as u8, 0, flags as u8, 0, 0]); + let parsed = parse(&header).unwrap(); + assert!(matches!( + parse_file_header_bytes(&parsed), + Err(Error::TooShort) + )); + } + let header = image(&[HEAD_FILE as u8, 0, 0, 0, 0, 0, 0, 10]); + assert!(matches!( + parse_file_header_bytes(&parse(&header).unwrap()), + Err(Error::TooShort) + )); + let header = image(&[HEAD_FILE as u8, HFL_DATA as u8, 1]); + assert!(matches!(parse(&header), Err(Error::TooShort))); + let mut empty = RAR50_SIGNATURE.to_vec(); + empty.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, 0])); + assert!(Archive::parse(&empty).unwrap().blocks.is_empty()); + empty = RAR50_SIGNATURE.to_vec(); + empty.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, 0, 0])); + assert!( + !Archive::parse(&empty) + .unwrap() + .main + .rewrite_metadata_complete + ); + let maximum = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1]; + let mut body = vec![HEAD_FILE as u8, 0, 0, 0, 0, 0, 0]; + body.extend_from_slice(&maximum); + let header = image(&body); + let expected_name_error = if usize::BITS < 64 { + "RAR 5 file name length overflows usize" + } else { + "RAR 5 field size overflows usize" + }; + assert!(matches!( + parse_file_header_bytes(&parse(&header).unwrap()), + Err(Error::InvalidHeader(message)) if message == expected_name_error + )); + let header = image(&[HEAD_FILE as u8, HFL_EXTRA as u8, 20, 0]); + assert!(matches!(parse(&header), Err(Error::TooShort))); + let mut body = vec![HEAD_FILE as u8, HFL_DATA as u8]; + body.extend_from_slice(&maximum); + assert!(matches!(parse(&image(&body)), Err(Error::InvalidHeader(_)))); + + empty = RAR50_SIGNATURE.to_vec(); + empty.extend_from_slice(&image(&[HEAD_MAIN as u8, HFL_EXTRA as u8, 1, 0, 0])); + assert!( + !Archive::parse(&empty) + .unwrap() + .main + .rewrite_metadata_complete + ); + + #[cfg(feature = "encryption")] + { + // A crypt header with a valid CRC can still truncate the KDF count, + // salt or password-check field. Test every field boundary explicitly. + for flags in [0, 1] { + let mut body = vec![HEAD_CRYPT as u8, 0, 0, flags, 0]; + body.extend_from_slice(&[0; 16]); + if flags == 1 { + body.extend_from_slice(&[0; 12]); + } + for end in 4..body.len() { + let header = image(&body[..end]); + let parsed = parse(&header).unwrap(); + assert!( + matches!( + parse_archive_encryption_header(&parsed, Some(b"pw")), + Err(Error::TooShort) + ), + "flags {flags}, end {end}" + ); + } + if flags == 0 { + let header = image(&body); + parse_archive_encryption_header(&parse(&header).unwrap(), Some(b"pw")).unwrap(); + body.push(0); + let header = image(&body); + assert!(matches!( + parse_archive_encryption_header(&parse(&header).unwrap(), Some(b"pw")), + Err(Error::InvalidHeader( + "RAR 5 archive encryption header has trailing bytes" + )) + )); + } + } + } + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, 0])); + bytes.extend_from_slice(&image(&[HEAD_CRYPT as u8, 0])); + assert!(matches!( + Archive::parse(&bytes).unwrap_err().root_cause(), + Error::UnsupportedFeature { + feature: "RAR 5 encrypted headers", + .. + } + )); + } + + #[test] + fn oversized_header_declarations_refuse_before_payload_access() { + fn vint(mut value: u64) -> Vec { + let mut bytes = Vec::new(); + loop { + let byte = (value & 0x7f) as u8; + value >>= 7; + bytes.push(byte | if value != 0 { 0x80 } else { 0 }); + if value == 0 { + return bytes; + } + } + } + + #[cfg(feature = "encryption")] + let keys = Rar50Keys::derive(b"pw", [0; 16], 0).unwrap(); + for (declared, _encrypted_expected) in [ + (u64::MAX, "RAR 5 header size overflows usize"), + (u64::MAX - 28, "RAR 5 encrypted header size overflows"), + (u64::MAX - 34, "RAR 5 encrypted header size overflows"), + ] { + let mut prefix = vec![0; 4]; + prefix.extend_from_slice(&vint(declared)); + assert_eq!(prefix.len(), 14); + let memory = parse_block_header_bytes( + &prefix, + 0, + prefix.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ); + let seekable = read_block_header_at( + &mut std::io::Cursor::new(&prefix), + 0, + prefix.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ); + for result in [memory, seekable] { + if usize::BITS == 32 || declared == u64::MAX { + assert!(matches!( + result, + Err(Error::InvalidHeader("RAR 5 header size overflows usize")) + )); + } else { + assert!(matches!(result, Err(Error::TooShort))); + } + } + + #[cfg(feature = "encryption")] + { + let mut first_plain = prefix; + first_plain.resize(16, 0); + Rar50Cipher::new(keys.key, [0; 16]) + .encrypt_in_place(&mut first_plain) + .unwrap(); + let mut encrypted = vec![0; 16]; + encrypted.extend_from_slice(&first_plain); + let memory = parse_encrypted_block_header_bytes( + &encrypted, + 0, + encrypted.len(), + 0, + &keys, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ); + let seekable = read_encrypted_block_header_at( + &mut std::io::Cursor::new(&encrypted), + 0, + encrypted.len(), + 0, + &keys, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ); + for result in [memory, seekable] { + let expected = if usize::BITS == 32 { + "RAR 5 header size overflows usize" + } else { + _encrypted_expected + }; + assert!( + matches!(result, Err(Error::InvalidHeader(message)) if message == expected) + ); + } + } + } + } + + #[test] + fn malformed_header_size_vints_and_optional_lengths_reach_both_adapters() { + let mut overlong = vec![0; 4]; + overlong.extend_from_slice(&[0x80; 10]); + for result in [ + parse_block_header_bytes( + &overlong, + 0, + overlong.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + read_block_header_at( + &mut std::io::Cursor::new(&overlong), + 0, + overlong.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + ] { + assert!(matches!( + result, + Err(Error::InvalidHeader("RAR 5 vint is too long")) + )); + } + #[cfg(feature = "encryption")] + { + let keys = Rar50Keys::derive(b"pw", [0; 16], 0).unwrap(); + let mut first_plain = overlong; + first_plain.resize(16, 0); + Rar50Cipher::new(keys.key, [0; 16]) + .encrypt_in_place(&mut first_plain) + .unwrap(); + let mut encrypted = vec![0; 16]; + encrypted.extend_from_slice(&first_plain); + for result in [ + parse_encrypted_block_header_bytes( + &encrypted, + 0, + encrypted.len(), + 0, + &keys, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + read_encrypted_block_header_at( + &mut std::io::Cursor::new(&encrypted), + 0, + encrypted.len(), + 0, + &keys, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + ] { + assert!(matches!( + result, + Err(Error::InvalidHeader("RAR 5 vint is too long")) + )); + } + } + let maximum_vint = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1]; + for (flag, expected) in [ + (HFL_EXTRA, "RAR 5 extra area size overflows usize"), + (HFL_DATA, "RAR 5 data size overflows usize"), + ] { + let mut body = vec![HEAD_FILE as u8, flag as u8]; + body.extend_from_slice(&maximum_vint); + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(&body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + for result in [ + parse_block_header_bytes( + &header, + 0, + header.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + read_block_header_at( + &mut std::io::Cursor::new(&header), + 0, + header.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + ] { + if flag == HFL_EXTRA && usize::BITS == 64 { + assert!(matches!(result, Err(Error::TooShort))); + } else { + assert!( + matches!(result, Err(Error::InvalidHeader(message)) if message == expected) + ); + } + } + } + } + + #[test] + fn file_header_field_boundaries_agree_across_reader_adapters() { + fn image(body: &[u8]) -> Vec { + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + header + } + // Type, block flags, file flags, unpacked size, attributes, + // compression, host, name length and one name byte. + let complete = [HEAD_FILE as u8, 0, 0, 0, 0, 0, 0, 1, b'x']; + for included in 0..=complete.len() { + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, 0])); + bytes.extend_from_slice(&image(&complete[..included])); + for result in [ + Archive::parse(&bytes), + Archive::parse_file_backed( + &mut std::io::Cursor::new(&bytes), + bytes.len(), + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + if included < complete.len() { + assert!( + matches!(result.unwrap_err().root_cause(), Error::TooShort), + "field prefix {included}" + ); + } else { + let archive = result.unwrap(); + assert_eq!(archive.files().next().unwrap().name, b"x"); + } + } + } + } + + #[test] + fn optional_block_header_fields_need_their_own_vints() { + for (body, complete) in [ + (vec![HEAD_FILE as u8, HFL_EXTRA as u8], false), + (vec![HEAD_FILE as u8, HFL_DATA as u8], false), + ( + vec![HEAD_FILE as u8, (HFL_EXTRA | HFL_DATA) as u8, 0], + false, + ), + ( + vec![HEAD_FILE as u8, (HFL_EXTRA | HFL_DATA) as u8, 0, 0], + true, + ), + ] { + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(&body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + for result in [ + parse_block_header_bytes( + &header, + 0, + header.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + read_block_header_at( + &mut std::io::Cursor::new(&header), + 0, + header.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ), + ] { + if complete { + let parsed = result.unwrap(); + assert_eq!(parsed.block.extra_area_size, Some(0)); + assert_eq!(parsed.block.data_size, Some(0)); + } else { + assert!(matches!(result, Err(Error::TooShort))); + } + } + } + } + + #[test] + fn file_extra_field_failures_reach_both_archive_readers() { + fn image(body: &[u8]) -> Vec { + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + header + } + let mut records = Vec::new(); + for mut crypt in [vec![0, 0, 0], vec![0, 1, 0]] { + crypt.extend_from_slice(&[0; 32]); // Salt and IV. + if crypt[1] == 1 { + crypt.extend_from_slice(&[0; 12]); // Optional password check. + } + for included in 0..=crypt.len() { + records.push(( + FHEXTRA_CRYPT as u8, + crypt[..included].to_vec(), + included == crypt.len(), + )); + } + } + records.extend([ + (FHEXTRA_HASH as u8, vec![], false), + (FHEXTRA_HASH as u8, vec![0], true), + (FHEXTRA_REDIR as u8, vec![], false), + (FHEXTRA_REDIR as u8, vec![1], false), + (FHEXTRA_REDIR as u8, vec![1, 0], false), + (FHEXTRA_REDIR as u8, vec![1, 0, 1], false), + (FHEXTRA_REDIR as u8, vec![1, 0, 1, b'y'], true), + ]); + for (kind, record, valid) in records { + let mut extra = vec![(record.len() + 1) as u8, kind]; + extra.extend_from_slice(&record); + let mut file_body = vec![ + HEAD_FILE as u8, + HFL_EXTRA as u8, + extra.len() as u8, + 0, + 0, + 0, + 0, + 0, + 1, + b'x', + ]; + file_body.extend_from_slice(&extra); + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, 0])); + let offset = bytes.len(); + bytes.extend_from_slice(&image(&file_body)); + for result in [ + Archive::parse(&bytes), + Archive::parse_file_backed( + &mut std::io::Cursor::new(&bytes), + bytes.len(), + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + if valid { + assert_eq!(result.unwrap().files().count(), 1); + } else { + let error = result.unwrap_err(); + assert!( + matches!(error, Error::AtArchiveOffset { offset: actual, .. } if actual == offset) + ); + assert!(matches!( + error.root_cause(), + Error::TooShort | Error::InvalidHeader(_) + )); + } + } + } + } + + #[test] + fn main_volume_and_first_crypt_fields_reject_truncation() { + fn image(body: &[u8]) -> Vec { + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + header + } + for body in [ + &[HEAD_MAIN as u8, 0, MHFL_VOLUME_NUMBER as u8][..], + &[HEAD_CRYPT as u8, 0][..], + &[HEAD_CRYPT as u8, 0, 0][..], + ] { + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&image(body)); + for result in [ + Archive::parse(&bytes), + Archive::parse_file_backed( + &mut std::io::Cursor::new(&bytes), + bytes.len(), + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + crate::ArchiveReadOptions::new(), + ), + ] { + let error = result.unwrap_err(); + let expected = if body[0] == HEAD_CRYPT as u8 && !cfg!(feature = "encryption") { + Error::FeatureDisabled { + feature: "encryption", + } + } else { + Error::TooShort + }; + assert_eq!(error.root_cause(), &expected); + } + } + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&image(&[HEAD_MAIN as u8, 0, MHFL_VOLUME_NUMBER as u8, 3])); + let archive = Archive::parse(&bytes).unwrap(); + assert_eq!(archive.main.volume_number, Some(3)); + } + + #[test] + fn seekable_parser_preserves_input_faults_and_cancellation() { + use std::io::{Cursor, Read, Seek, SeekFrom}; + use std::sync::atomic::{AtomicUsize, Ordering}; + + struct FaultReader { + input: Cursor>, + operations: Arc, + stop_at: usize, + cancellation: Option, + } + impl FaultReader { + fn check(&self) -> std::io::Result<()> { + let operation = self.operations.fetch_add(1, Ordering::Relaxed); + if operation != self.stop_at { + return Ok(()); + } + if let Some(token) = &self.cancellation { + token.cancel(); + Ok(()) + } else { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "RAR5 input fault", + )) + } + } + } + impl Read for FaultReader { + fn read(&mut self, output: &mut [u8]) -> std::io::Result { + self.check()?; + self.input.read(output) + } + } + impl Seek for FaultReader { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.check()?; + self.input.seek(from) + } + } + let source = build_archive_with_optional_comment(Some(b"comment")); + let bytes = source.read_range(0..source.source_len().unwrap()).unwrap(); + let operations = Arc::new(AtomicUsize::new(0)); + let parse = |stop_at, cancellation: Option<&crate::ReadCancellation>| { + operations.store(0, Ordering::Relaxed); + Archive::parse_file_backed( + &mut FaultReader { + input: Cursor::new(bytes.clone()), + operations: operations.clone(), + stop_at, + cancellation: cancellation.cloned(), + }, + bytes.len(), + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + cancellation.map_or_else(crate::ArchiveReadOptions::new, |token| { + crate::ArchiveReadOptions::new().with_cancellation(token) + }), + ) + }; + assert_eq!(parse(usize::MAX, None).unwrap().blocks, source.blocks); + let count = operations.load(Ordering::Relaxed); + assert!(count > 4); + let pre_cancelled = crate::ReadCancellation::new(); + pre_cancelled.cancel(); + assert!(matches!( + parse(usize::MAX, Some(&pre_cancelled)) + .unwrap_err() + .root_cause(), + Error::Cancelled + )); + assert_eq!(operations.load(Ordering::Relaxed), 0); + for operation in 0..count { + let error = parse(operation, None).unwrap_err(); + assert!(matches!(error.root_cause(), Error::Io(source) + if source.kind == std::io::ErrorKind::PermissionDenied && source.message == "RAR5 input fault")); + assert_eq!(operations.load(Ordering::Relaxed), operation + 1); + let cancelled = crate::ReadCancellation::new(); + let error = parse(operation, Some(&cancelled)).unwrap_err(); + assert!( + matches!(error.root_cause(), Error::Cancelled), + "operation {operation}: {error:?}" + ); + assert!(cancelled.is_cancelled()); + } + + #[cfg(feature = "encryption")] + { + let keys = Rar50Keys::derive(b"pw", [0; 16], 0).unwrap(); + let mut encoded = vec![3, HEAD_MAIN as u8, 0, 0]; + let mut first_plain = crc32(&encoded).to_le_bytes().to_vec(); + first_plain.append(&mut encoded); + first_plain.resize(16, 0); + Rar50Cipher::new(keys.key, [0; 16]) + .encrypt_in_place(&mut first_plain) + .unwrap(); + let mut encrypted = vec![0; 16]; + encrypted.extend_from_slice(&first_plain); + let parse_encrypted = |stop_at, cancellation: Option<&crate::ReadCancellation>| { + operations.store(0, Ordering::Relaxed); + read_encrypted_block_header_at( + &mut FaultReader { + input: Cursor::new(encrypted.clone()), + operations: operations.clone(), + stop_at, + cancellation: cancellation.cloned(), + }, + 0, + encrypted.len(), + 0, + &keys, + &mut crate::parse_budget::ParseBudget::new( + cancellation.map_or_else(crate::ArchiveReadOptions::new, |token| { + crate::ArchiveReadOptions::new().with_cancellation(token) + }), + ), + ) + }; + assert_eq!( + parse_encrypted(usize::MAX, None).unwrap().block.header_type, + HEAD_MAIN + ); + let count = operations.load(Ordering::Relaxed); + assert!(count > 1); + for operation in 0..count { + let error = parse_encrypted(operation, None) + .err() + .expect("input fault refused"); + assert!(matches!(error.root_cause(), Error::Io(source) + if source.kind == std::io::ErrorKind::PermissionDenied && source.message == "RAR5 input fault")); + assert_eq!(operations.load(Ordering::Relaxed), operation + 1); + let cancelled = crate::ReadCancellation::new(); + let error = parse_encrypted(operation, Some(&cancelled)) + .err() + .expect("cancellation observed"); + assert!( + matches!(error.root_cause(), Error::Cancelled), + "encrypted operation {operation}: {error:?}" + ); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_key_failures_retain_specific_diagnostics() { + let mut encoded = vec![HEAD_CRYPT as u8, 0, 0, 0, 25]; + encoded.extend_from_slice(&[0; 16]); + let mut image = vec![encoded.len() as u8]; + image.extend_from_slice(&encoded); + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&crc32(&image).to_le_bytes()); + bytes.extend_from_slice(&image); + let options = crate::ArchiveReadOptions::with_password(b"pw"); + for result in [ + Archive::parse_with_options(&bytes, options), + Archive::parse_file_backed( + &mut std::io::Cursor::new(&bytes), + bytes.len(), + 0, + ArchiveSource::Memory(Arc::from(bytes.clone())), + options, + ), + ] { + assert!(matches!( + result.unwrap_err().root_cause(), + Error::UnsupportedFeature { + feature: "RAR 5 KDF count", + .. + } + )); + } + + let archive = build_archive_with_optional_comment(None); + let mut file = archive.files().next().unwrap().clone(); + file.encrypted = true; + file.encryption = None; + assert!(matches!( + attach_file_crypto(&mut file, Some(b"pw")), + Err(Error::InvalidHeader( + "RAR 5 encrypted file is missing encryption record" + )) + )); + file.encryption = Some(FileEncryption { + version: 0, + flags: 1, + kdf_count: 25, + salt: [0; 16], + iv: [0; 16], + check_value: Some([0; 12]), + }); + assert!(matches!( + attach_file_crypto(&mut file, Some(b"pw")), + Err(Error::UnsupportedFeature { + feature: "RAR 5 KDF count", + .. + }) + )); + file.encryption.as_mut().unwrap().kdf_count = 0; + // WinRAR 5.21 and earlier wrote an all-zero password check, which + // deliberately defers verification to the data checksum. + attach_file_crypto(&mut file, Some(b"pw")).unwrap(); + let mut bad_check = file.clone(); + bad_check.encryption.as_mut().unwrap().check_value = Some([1; 12]); + assert!(matches!( + attach_file_crypto(&mut bad_check, Some(b"pw")), + Err(Error::WrongPasswordOrCorruptData) + )); + } + + #[test] + #[cfg(feature = "encryption")] + fn unknown_archive_encryption_flags_disable_rewrite_preservation() { + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50) + .store(true) + .password(Some(b"pw".to_vec())) + .header_encryption(true); + builder + .add_bytes(b"x".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let mut bytes = builder.to_bytes().unwrap(); + let parsed = parse_block_header_bytes( + &bytes, + RAR50_SIGNATURE.len(), + bytes.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + .unwrap(); + assert_eq!(parsed.block.header_type, HEAD_CRYPT); + let options = crate::ArchiveReadOptions::with_password(b"pw"); + assert!( + Archive::parse_with_options(&bytes, options) + .unwrap() + .main + .rewrite_metadata_complete + ); + + let flags_at = RAR50_SIGNATURE.len() + parsed.type_specific_range.start + 1; + bytes[flags_at] |= 2; // Retain the check-value bit and add a future flag. + let crc_at = RAR50_SIGNATURE.len(); + let end = crc_at + parsed.header.len(); + let crc = crc32(&bytes[crc_at + 4..end]); + bytes[crc_at..crc_at + 4].copy_from_slice(&crc.to_le_bytes()); + let archive = Archive::parse_with_options(&bytes, options).unwrap(); + assert!(!archive.main.rewrite_metadata_complete); + assert_eq!(archive.files().next().unwrap().name, b"x"); + } + + #[test] + fn unknown_header_remains_readable_and_budget_error_keeps_one_offset() { + let header = |body: &[u8]| { + let mut encoded = vec![body.len() as u8]; + encoded.extend_from_slice(body); + let mut header = crc32(&encoded).to_le_bytes().to_vec(); + header.extend_from_slice(&encoded); + header + }; + let mut bytes = RAR50_SIGNATURE.to_vec(); + bytes.extend_from_slice(&header(&[HEAD_MAIN as u8, 0, 0])); + bytes.extend_from_slice(&header(&[127, 0])); + bytes.extend_from_slice(&header(&[HEAD_END as u8, 0, 0])); + + let archive = Archive::parse(&bytes).unwrap(); + assert!(matches!( + archive.blocks.as_slice(), + [Block::Unknown(_), Block::End(_)] + )); + + let error = Archive::parse_with_options( + &bytes, + crate::ArchiveReadOptions::new().with_max_header_bytes(0), + ) + .unwrap_err(); + let Error::AtArchiveOffset { offset, source } = error else { + panic!("header refusal needs its physical offset"); + }; + assert_eq!(offset, RAR50_SIGNATURE.len()); + assert!(matches!(*source, Error::HeaderBytesLimitExceeded { .. })); + } + + #[test] + fn header_reader_u32_obeys_type_specific_boundary() { + // Extra-area bytes remain physically available in the header image, + // but must not satisfy a field in the type-specific part. + let input = [99, 99, 1, 2, 3, 4, 77]; + for available in 0..=4 { + let mut reader = HeaderReader::new(&input, 2..2 + available); + let result = reader.read_u32(); + if available < 4 { + assert!( + matches!(result, Err(Error::TooShort)), + "available {available}" + ); + assert_eq!(reader.pos, 2); + } else { + assert_eq!(result.unwrap(), 0x0403_0201); + assert_eq!(reader.pos, 6); + } + } + } + + #[test] + fn main_extra_records_keep_future_and_duplicate_layouts_readable() { + let control = crate::read_control::ReadControl::default(); + // Locator zero offsets are retained as wire values; they do not + // indicate an actual service block at the main header's location. + for (data, quick_open, recovery, complete) in [ + (vec![0], None, None, true), + (vec![1, 0], Some(0), None, true), + (vec![1, 127], Some(127), None, true), + (vec![2, 0x80, 1], None, Some(128), true), + (vec![3, 12, 34], Some(12), Some(34), true), + (vec![4], None, None, false), + (vec![4, 99], None, None, false), + (vec![0, 99], None, None, false), + ] { + let extra = [vec![(1 + data.len()) as u8, MHEXTRA_LOCATOR as u8], data].concat(); + let (records, is_complete) = + parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert_eq!(is_complete, complete); + assert!( + matches!(records.as_slice(), [MainExtraRecord::Locator(record)] + if record.quick_open_offset == quick_open && record.recovery_record_offset == recovery) + ); + } + for extra in [ + vec![2, MHEXTRA_LOCATOR as u8, 0, 2, MHEXTRA_LOCATOR as u8, 0], + vec![ + 2, + MHEXTRA_ARCHIVE_METADATA as u8, + 0, + 2, + MHEXTRA_ARCHIVE_METADATA as u8, + 0, + ], + ] { + let (records, complete) = + parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert_eq!(records.len(), 2); + assert!( + !complete, + "duplicate records must not be silently rewritten" + ); + } + for (extra, count) in [ + (vec![1, 64], 0), + (vec![2, MHEXTRA_ARCHIVE_METADATA as u8, 16], 1), + (vec![1, 64, 2, MHEXTRA_ARCHIVE_METADATA as u8, 16], 1), + ] { + let (records, complete) = + parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert!(!complete); + assert_eq!(records.len(), count); + if count != 0 { + assert!( + matches!(records.as_slice(), [MainExtraRecord::ArchiveMetadata(record)] + if record.flags == 16 && record.name.is_none() && record.creation_time.is_none()) + ); + } + } + let extra = [2, MHEXTRA_LOCATOR as u8, 0, 0x80]; + let (records, complete) = parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert_eq!(records.len(), 1); + assert!( + !complete, + "a malformed tail must not erase preceding records" + ); + } + + #[test] + fn main_extra_records_reject_truncated_known_fields_and_metadata_trailing_bytes() { + let control = crate::read_control::ReadControl::default(); + let truncated = [ + vec![1, MHEXTRA_LOCATOR as u8], // Missing locator flags. + vec![2, MHEXTRA_LOCATOR as u8, 1], // Missing quick-open offset. + vec![2, MHEXTRA_LOCATOR as u8, 2], // Missing recovery offset. + vec![1, MHEXTRA_ARCHIVE_METADATA as u8], // Missing metadata flags. + vec![2, MHEXTRA_ARCHIVE_METADATA as u8, 1], // Missing name length. + vec![4, MHEXTRA_ARCHIVE_METADATA as u8, 1, 2, b'a'], // Short name. + vec![5, MHEXTRA_ARCHIVE_METADATA as u8, 6, 1, 2, 3], // Short Unix seconds. + vec![9, MHEXTRA_ARCHIVE_METADATA as u8, 2, 1, 2, 3, 4, 5, 6, 7], // Short FILETIME. + vec![9, MHEXTRA_ARCHIVE_METADATA as u8, 14, 1, 2, 3, 4, 5, 6, 7], // Short Unix nanoseconds. + ]; + for extra in truncated { + // Bytes following the extra area must never satisfy a field read. + let input = [extra.clone(), vec![0; 16]].concat(); + assert!( + matches!( + parse_main_extra_area(&input, 0..extra.len(), &control), + Err(Error::TooShort) + ), + "extra {extra:?}" + ); + } + let trailing = [3, MHEXTRA_ARCHIVE_METADATA as u8, 0, 99]; + assert!(matches!( + parse_main_extra_area(&trailing, 0..trailing.len(), &control), + Err(Error::InvalidHeader( + "RAR 5 archive metadata record has trailing bytes" + )) + )); + let huge_name = [ + 12, + MHEXTRA_ARCHIVE_METADATA as u8, + 1, + 0xff, + 0xff, + 0xff, + 0xff, + 0xff, + 0xff, + 0xff, + 0xff, + 0xff, + 1, + ]; + let expected = if usize::BITS < 64 { + "RAR 5 archive metadata name length overflows usize" + } else { + "RAR 5 field size overflows usize" + }; + assert!( + matches!(parse_main_extra_area(&huge_name, 0..huge_name.len(), &control), + Err(Error::InvalidHeader(message)) if message == expected) + ); + } + + #[test] + fn main_extra_records_preserve_reserved_name_buffers_and_following_times() { + let control = crate::read_control::ReadControl::default(); + let time = 0x01d9_0000_0000_0000u64; + // RARLAB documents padding after renamed archives and a leading zero + // when the final name did not fit the buffer reserved during archiving. + for name in [ + b"original.rar".as_slice(), + b"short.rar\0\0\0", + b"\0old-name.rar", + b"", + ] { + let mut extra = vec![ + (3 + name.len() + 8) as u8, + MHEXTRA_ARCHIVE_METADATA as u8, + 3, + name.len() as u8, + ]; + extra.extend_from_slice(name); + extra.extend_from_slice(&time.to_le_bytes()); + let (records, complete) = + parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert!(complete); + assert!( + matches!(records.as_slice(), [MainExtraRecord::ArchiveMetadata(record)] + if record.name.as_deref() == Some(name) && record.creation_time == Some(time)) + ); + } + } + + #[test] + fn archive_metadata_time_flags_follow_rar5_wire_widths() { + let control = crate::read_control::ReadControl::default(); + // RARLAB technote: 0x04 selects Unix time, and 0x08 widens Unix + // seconds to nanoseconds. Without 0x04, time is a FILETIME u64. + for (flags, time, expected, complete) in [ + ( + 0x02, + 0x01d9_0000_0000_0000u64.to_le_bytes().to_vec(), + 0x01d9_0000_0000_0000, + true, + ), + ( + 0x06, + 1_700_000_000u32.to_le_bytes().to_vec(), + 1_700_000_000, + true, + ), + ( + 0x0e, + 1_700_000_000_123_456_789u64.to_le_bytes().to_vec(), + 1_700_000_000_123_456_789, + true, + ), + ( + 0x0a, + 1_700_000_000_123_456_789u64.to_le_bytes().to_vec(), + 1_700_000_000_123_456_789, + false, + ), + ] { + let mut extra = vec![ + (2 + time.len()) as u8, + MHEXTRA_ARCHIVE_METADATA as u8, + flags, + ]; + extra.extend_from_slice(&time); + let (records, is_complete) = + parse_main_extra_area(&extra, 0..extra.len(), &control).unwrap(); + assert_eq!(is_complete, complete, "flags {flags:#x}"); + assert!( + matches!(records.as_slice(), [MainExtraRecord::ArchiveMetadata(record)] + if record.flags == u64::from(flags) && record.creation_time == Some(expected)) + ); + } + } + + #[test] + fn malformed_extra_tail_keeps_preceding_record_and_marks_area_incomplete() { + let valid = [1, 2]; // Record type 2 with no data. + let overflowing_size = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01]; + let tails: [&[u8]; 5] = [&[0x80], &overflowing_size, &[1, 0x80], &[0], &[9, 2]]; + let control = crate::read_control::ReadControl::default(); + + for tail in tails { + let input = [valid.as_slice(), tail].concat(); + let mut records = Vec::new(); + let complete = super::parse_extra_records( + &input, + 0..input.len(), + false, + &control, + |record_type, data| { + records.push((record_type, input[data].to_vec())); + Ok(()) + }, + ) + .unwrap(); + assert!(!complete, "tail {tail:?} must be incomplete"); + assert_eq!(records, [(2, Vec::new())]); + } + } + + #[test] + fn cancellation_interrupts_metadata_record_iteration() { + let input = [2, 127, 0].repeat(10000); + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(1); + let mut handled = 0; + let err = super::parse_extra_records(&input, 0..input.len(), false, &control, |_, _| { + handled += 1; + Ok(()) + }) + .unwrap_err(); + assert_eq!(err.kind(), crate::ErrorKind::Cancelled); + assert!(handled > 0 && handled < 10000); + } + #[test] + fn file_extra_cancellation_propagates_from_the_metadata_phase() { + let archive = build_archive_with_optional_comment(None); + let file = archive.files().next().unwrap(); + let bytes = archive + .read_range(file.block.offset..file.block.data_range.end) + .unwrap(); + let mut parsed = parse_block_header_bytes( + &bytes, + 0, + bytes.len(), + 0, + &mut crate::parse_budget::ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + .unwrap(); + assert!(!parsed.extra_range.is_empty()); + let token = crate::ReadCancellation::new(); + parsed.control = crate::read_control::ReadControl::new(Some(&token)); + token.cancel(); + assert_eq!( + parse_file_header_bytes(&parsed).unwrap_err().kind(), + crate::ErrorKind::Cancelled + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_header_extent_rejects_short_prefix_and_declared_ciphertext() { + use crate::parse_budget::ParseBudget; + let keys = crate::crypto::rar50::Rar50Keys::derive(b"secret", [0; 16], 0).unwrap(); + let mut plain = vec![0; 16]; + plain[4] = 60; + crate::crypto::rar50::Rar50Cipher::new(keys.key, [0; 16]) + .encrypt_in_place(&mut plain) + .unwrap(); + let mut bytes = vec![0; 16]; + bytes.extend_from_slice(&plain); + for len in [31, 32] { + let input = &bytes[..len]; + let memory = super::parse_encrypted_block_header_bytes( + input, + 0, + len, + 0, + &keys, + &mut ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + .map(|_| ()) + .unwrap_err(); + let seekable = super::read_encrypted_block_header_at( + &mut std::io::Cursor::new(input), + 0, + len, + 0, + &keys, + &mut ParseBudget::new(crate::ArchiveReadOptions::new()), + ) + .map(|_| ()) + .unwrap_err(); + assert!(matches!(memory, crate::Error::TooShort)); + assert!(matches!(seekable, crate::Error::TooShort)); + } + } + + #[test] + fn header_budget_refuses_full_reads_after_plain_and_encrypted_prefixes() { + use crate::parse_budget::{ParseBudget, PrefixReader}; + let mut plain = vec![0u8; 16]; + plain[4] = 60; // 65 plaintext header bytes, larger than the prefix. + let mut reader = PrefixReader::new(plain[..14].to_vec()); + let options = crate::ArchiveReadOptions::new().with_max_header_bytes(64); + let e = super::read_block_header_at(&mut reader, 0, 128, 0, &mut ParseBudget::new(options)) + .map(|_| ()) + .expect_err("header budget must refuse"); + assert!(matches!( + e.root_cause(), + crate::Error::HeaderBytesLimitExceeded { required: 65, .. } + )); + assert_eq!(reader.reads, [14]); + + #[cfg(feature = "encryption")] + { + let keys = crate::crypto::rar50::Rar50Keys::derive(b"secret", [0; 16], 0).unwrap(); + crate::crypto::rar50::Rar50Cipher::new(keys.key, [0; 16]) + .encrypt_in_place(&mut plain) + .unwrap(); + let mut prefix = vec![0; 16]; + prefix.extend_from_slice(&plain); + let mut reader = PrefixReader::new(prefix); + let e = super::read_encrypted_block_header_at( + &mut reader, + 0, + 128, + 0, + &keys, + &mut ParseBudget::new(options), + ) + .map(|_| ()) + .expect_err("header budget must refuse"); + assert!(matches!( + e.root_cause(), + crate::Error::HeaderBytesLimitExceeded { required: 65, .. } + )); + assert_eq!(reader.reads, [32]); + } + } + use super::*; + + #[test] + fn read_vint_at_honors_logical_end_before_decoding() { + assert_eq!(read_vint_at(&[0x01], 0, 0), Err(Error::TooShort)); + assert_eq!(read_vint_at(&[0x81, 0x01], 0, 1), Err(Error::TooShort)); + assert_eq!(read_vint_at(&[0x81, 0x01], 0, 2).unwrap(), (129, 2)); + assert_eq!( + read_vint_at(&[], usize::MAX, usize::MAX), + Err(Error::TooShort) + ); + } + + #[test] + fn read_vint_at_rejects_overflow_and_overlong_continuations() { + let max = [0xff; 9].into_iter().chain([0x01]).collect::>(); + assert_eq!(read_vint_at(&max, 0, max.len()).unwrap(), (u64::MAX, 10)); + + let overflow = [0xff; 9].into_iter().chain([0x02]).collect::>(); + assert_eq!( + read_vint_at(&overflow, 0, overflow.len()), + Err(Error::InvalidHeader("RAR 5 vint overflows u64")) + ); + + let overlong = [0x80; 10]; + assert_eq!( + read_vint_at(&overlong, 0, overlong.len()), + Err(Error::InvalidHeader("RAR 5 vint is too long")) + ); + } + + #[test] + fn parses_file_redirection_extra_record() { + let input = [1, 1, 6, b't', b'a', b'r', b'g', b'e', b't']; + let record = parse_file_redirection_record(&input, 0..input.len()).unwrap(); + + assert_eq!(record.redirection_type, 1); + assert_eq!(record.flags, 1); + assert_eq!(record.target_name, b"target"); + } + + #[test] + fn redirection_target_length_cannot_overflow_its_record() { + let input = [ + 1, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1, + ]; + let expected = if usize::BITS == 64 { + "RAR 5 file redirection target length overflows" + } else { + "RAR 5 file redirection target length overflows host address size" + }; + assert!( + matches!(parse_file_redirection_record(&input, 0..input.len()), + Err(Error::InvalidHeader(message)) if message == expected) + ); + } + + #[test] + fn oversized_extra_record_length_keeps_preceding_metadata() { + let mut extra = vec![2, MHEXTRA_LOCATOR as u8, 0]; + // A valid vint can declare more bytes than a 32-bit process can + // address; on 64-bit the physical record still cannot contain them. + extra.extend_from_slice(&[0xff; 9]); + extra.push(1); + let (records, complete) = parse_main_extra_area( + &extra, + 0..extra.len(), + &crate::read_control::ReadControl::default(), + ) + .unwrap(); + assert!(!complete); + assert!(matches!(records.as_slice(), [MainExtraRecord::Locator(_)])); + } + + #[test] + fn rejects_file_redirection_record_with_trailing_bytes() { + let input = [1, 0, 3, b'f', b'o', b'o', 0]; + + assert!(matches!( + parse_file_redirection_record(&input, 0..input.len()), + Err(Error::InvalidHeader( + "RAR 5 file redirection record has trailing bytes" + )) + )); + } + + #[test] + fn htime_precision_respects_record_bounds_and_time_layout() { + let mut unix = vec![0x1f]; // mtime, ctime, atime, then their fractions + for value in [123u32, 456, 789, 987_654_321, 111, 222] { + unix.extend_from_slice(&value.to_le_bytes()); + } + let (seconds, detail) = parse_htime_mtime(&unix, 0..unix.len()).unwrap(); + assert_eq!(seconds, 123); + assert_eq!(detail.unwrap().nanoseconds, 987_654_321); + assert_eq!(parse_htime_mtime(&unix, 0..2), None); + assert_eq!(parse_htime_mtime(&unix, 0..14), Some((123, None))); + unix[13..17].copy_from_slice(&1_000_000_000u32.to_le_bytes()); + assert_eq!(parse_htime_mtime(&unix, 0..unix.len()), Some((123, None))); + + let mut filetime = vec![2]; + let ticks = (11_644_473_600u64 + 123) * 10_000_000 + 7_040_883; + filetime.extend_from_slice(&ticks.to_le_bytes()); + let (seconds, detail) = parse_htime_mtime(&filetime, 0..filetime.len()).unwrap(); + assert_eq!(seconds, 123); + assert_eq!(detail.unwrap().nanoseconds, 704_088_300); + assert_eq!(parse_htime_mtime(&filetime, 0..8), None); + } + + #[test] + fn file_header_name_bytes_preserve_non_utf8_names() { + let file = FileHeader { + block: BlockHeader { + header_crc: 0, + header_size: 0, + header_type: HEAD_FILE, + flags: 0, + extra_area_size: None, + data_size: Some(0), + offset: 0, + header_range: 0..0, + data_range: 0..0, + }, + file_flags: 0, + rewrite_metadata_complete: true, + unpacked_size: 0, + attributes: 0, + mtime: None, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32: None, + compression_info: 0, + host_os: 0, + name: vec![0xff, b'.', b'b', b'i', b'n'], + hash: None, + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + }; + + assert_eq!(file.name_bytes(), [0xff, b'.', b'b', b'i', b'n']); + assert_eq!(file.name_lossy(), "\u{fffd}.bin"); + } + + /// Builds a member from bytes the test already holds. + fn rar50_entry(name: &[u8], data: &[u8]) -> crate::rar50::ArchiveEntry { + crate::rar50::ArchiveEntry::new( + name.to_vec(), + crate::EntrySource::from_bytes(std::sync::Arc::<[u8]>::from(data.to_vec())), + ) + } + + fn build_archive_with_optional_comment(comment: Option<&[u8]>) -> Archive { + use crate::FeatureSet; + let features = FeatureSet::store_only(); + let entries = [rar50_entry(b"payload.txt", b"payload bytes") + .with_attributes(0x20) + .with_host_os(3)]; + let bytes = crate::rar50::Rar50Writer::new( + crate::rar50::WriterOptions::new(crate::version::ArchiveVersion::Rar50, features) + .with_compression_level(0), + ) + .entries(entries.to_vec()) + .archive_comment(comment) + .finish() + .unwrap(); + Archive::parse(&bytes).unwrap() + } + + #[test] + fn parser_metadata_failures_retain_physical_header_offsets() { + fn image(body: &[u8]) -> Vec { + assert!(body.len() < 128); + let mut bytes = vec![body.len() as u8]; + bytes.extend_from_slice(body); + let mut result = crc32(&bytes).to_le_bytes().to_vec(); + result.extend_from_slice(&bytes); + result + } + let main = image(&[HEAD_MAIN as u8, 0, 0]); + let mut cases = vec![( + image(&[HEAD_MAIN as u8, 0]), + true, + crate::ErrorKind::InvalidArchive, + )]; + for kind in [HEAD_FILE, HEAD_SERVICE] { + cases.push(( + image(&[kind as u8, 0]), + false, + crate::ErrorKind::InvalidArchive, + )); + // Structurally complete encryption record, unsupported version. + let mut record = vec![FHEXTRA_CRYPT as u8, 1, 0, 0]; + record.extend_from_slice(&[0; 32]); + let mut body = vec![ + kind as u8, + HFL_EXTRA as u8, + (record.len() + 1) as u8, + 0, + 0, + 0, + 0, + 0, + 1, + b'x', + record.len() as u8, + ]; + body.extend_from_slice(&record); + cases.push((image(&body), false, crate::ErrorKind::UnsupportedFeature)); + } + for (header, is_main, expected_kind) in cases { + let mut bytes = RAR50_SIGNATURE.to_vec(); + if !is_main { + bytes.extend_from_slice(&main); + } + let offset = bytes.len(); + bytes.extend_from_slice(&header); + let options = crate::ArchiveReadOptions::with_password(b"secret"); + let memory = Archive::parse_with_options(&bytes, options); + let seekable = Archive::parse_file_backed( + &mut std::io::Cursor::new(&bytes), + bytes.len(), + 0, + ArchiveSource::Memory(std::sync::Arc::from(bytes.clone())), + options, + ); + if expected_kind == crate::ErrorKind::UnsupportedFeature + && !cfg!(feature = "encryption") + { + // Without crypto, an unknown encryption version remains readable metadata. + for archive in [memory, seekable] { + let archive = archive.unwrap(); + let file = match archive.blocks.last().unwrap() { + Block::File(file) | Block::Service(file) => file, + _ => panic!("expected encryption metadata"), + }; + assert_eq!(file.encryption.as_ref().unwrap().version, 1); + assert!(file.crypto.is_none()); + assert!(!file.rewrite_metadata_complete); + for password in [None, Some(b"secret".as_slice())] { + let mut output = b"untouched".to_vec(); + assert_eq!( + file.write_to(&archive, password, &mut output) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "encryption" + } + ); + assert_eq!(output, b"untouched"); + } + } + continue; + } + for error in [memory, seekable] { + let error = error.unwrap_err(); + assert_eq!(error.kind(), expected_kind, "{error}"); + assert!( + matches!(error, Error::AtArchiveOffset { offset: actual, .. } if actual == offset), + "{error}" + ); + } + } + } + + #[test] + fn memory_and_file_backed_parsers_reject_a_non_main_first_header() { + let archive = build_archive_with_optional_comment(None); + let mut bytes = archive + .read_range(0..archive.source_len().unwrap()) + .unwrap(); + let start = RAR50_SIGNATURE.len(); + let (body_size, size_len) = read_vint_at(&bytes, start + 4, bytes.len()).unwrap(); + let header_end = start + 4 + size_len + body_size as usize; + let header_type = start + 4 + size_len; + assert_eq!(bytes[header_type], HEAD_MAIN as u8); + bytes[header_type] = HEAD_FILE as u8; + let crc = crc32(&bytes[start + 4..header_end]); + bytes[start..start + 4].copy_from_slice(&crc.to_le_bytes()); + + let memory = Archive::parse(&bytes).unwrap_err(); + let mut cursor = std::io::Cursor::new(&bytes); + let file_backed = Archive::parse_file_backed( + &mut cursor, + bytes.len(), + 0, + ArchiveSource::Memory(std::sync::Arc::from(bytes.clone().into_boxed_slice())), + crate::ArchiveReadOptions::default(), + ) + .unwrap_err(); + + assert!(matches!( + memory, + Error::InvalidHeader("RAR 5 main header is missing") + )); + assert!(matches!( + file_backed, + Error::InvalidHeader("RAR 5 main header is missing") + )); + } + + #[test] + fn memory_and_file_backed_parsers_reject_truncated_first_header() { + let archive = build_archive_with_optional_comment(None); + let original = archive + .read_range(0..archive.source_len().unwrap()) + .unwrap(); + let first_header = RAR50_SIGNATURE.len(); + + for len in [first_header + 4, first_header + 5] { + let bytes = original[..len].to_vec(); + let memory = Archive::parse(&bytes).unwrap_err(); + let mut cursor = std::io::Cursor::new(&bytes); + let file_backed = Archive::parse_file_backed( + &mut cursor, + bytes.len(), + 0, + ArchiveSource::Memory(std::sync::Arc::from(bytes.clone().into_boxed_slice())), + crate::ArchiveReadOptions::default(), + ) + .unwrap_err(); + + assert!( + matches!(memory.root_cause(), Error::TooShort), + "length {len}" + ); + assert!( + matches!(file_backed.root_cause(), Error::TooShort), + "length {len}" + ); + } + } + + #[test] + fn archive_comment_returns_none_for_archive_without_a_cmt_service() { + let mut archive = build_archive_with_optional_comment(None); + assert!(archive.archive_comment().unwrap().is_none()); + for block in &mut archive.blocks { + if let Block::File(file) = block { + let mut service = file.clone(); + service.name = b"STM".to_vec(); + *block = Block::Service(service); + } + } + assert!(archive.archive_comment().unwrap().is_none()); + } + + #[test] + fn archive_comment_decodes_the_cmt_service_payload_text() { + let comment_text = b"archive comment from rars unit test\n"; + let archive = build_archive_with_optional_comment(Some(comment_text)); + let comment = archive.archive_comment().unwrap(); + assert_eq!(comment.as_deref(), Some(&comment_text[..])); + } + + #[test] + fn archive_comment_ignores_cmt_services_attached_to_files() { + // Service blocks that follow a File block belong to that file, not the + // archive — archive_comment should not surface them. + use crate::FeatureSet; + let entry = rar50_entry(b"payload.txt", b"payload bytes") + .with_attributes(0x20) + .with_host_os(3) + .with_service(crate::rar50::ServiceEntry::new( + b"CMT".to_vec(), + b"per-file comment".to_vec(), + )); + let features = FeatureSet::store_only(); + let bytes = crate::rar50::Rar50Writer::new(crate::rar50::WriterOptions::new( + crate::version::ArchiveVersion::Rar50, + features, + )) + .entry(entry) + .finish() + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + + assert!(archive.archive_comment().unwrap().is_none()); + } +} + +#[cfg(all(test, feature = "write"))] +#[test] +fn redirection_preservation_refuses_inconsistent_header_metadata() { + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"link".to_vec(), Vec::new(), None, None) + .unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let original = archive.members().next().unwrap(); + for (kind, flags, host, attr, directory, supported) in [ + (2, 0, 0, 0x400, false, true), + (2, 0, 1, 0x400, false, false), + (2, 0, 0, 0, false, false), + (2, 0, 0, 0x410, false, false), + (2, 1, 0, 0x400, false, false), + (3, 0, 0, 0x400, false, false), + (3, 1, 0, 0x410, true, true), + (4, 0, 0, 0, false, true), + (4, 0, 0, 0, true, false), + (5, 0, 1, 0o100600, false, true), + (0, 0, 0, 0, false, false), + (6, 0, 0, 0, false, false), + ] { + let mut member = original.clone(); + member.meta.host_os = Some(host); + member.meta.file_attr = attr; + member.meta.is_directory = directory; + member.meta.is_redirection = true; + let crate::ArchiveMemberDetail::Rar50Plus { redirection, .. } = &mut member.detail else { + panic!("expected RAR5 member"); + }; + *redirection = Some(FileRedirection { + redirection_type: kind, + flags, + target_name: b"target".to_vec(), + }); + assert_eq!( + member.supported_redirection().is_some(), + supported, + "kind={kind}, flags={flags}, host={host}, attr={attr:#x}, directory={directory}" + ); + if !supported { + let mut output = crate::Builder::new(crate::ArchiveVersion::Rar50); + assert_eq!( + output.add_archive_redirection(&member), + Err(Error::InvalidArgument("unsupported redirection metadata")) + ); + assert!(output.is_empty()); + } + } +} diff --git a/arca-rar/vendor/rars/src/rar50/blake2sp.rs b/arca-rar/vendor/rars/src/rar50/blake2sp.rs new file mode 100644 index 00000000..5cfa9894 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/blake2sp.rs @@ -0,0 +1,517 @@ +const BLOCK_BYTES: usize = 64; +const OUT_BYTES: usize = 32; +const PARALLELISM: usize = 8; +const BUFFER_BYTES: usize = BLOCK_BYTES * PARALLELISM; + +const IV: [u32; 8] = [ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +]; + +const SIGMA: [[usize; 16]; 10] = [ + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3], + [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4], + [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8], + [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13], + [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9], + [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11], + [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10], + [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5], + [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0], +]; + +struct Blake2s { + h: [u32; 8], + t: u64, + buf: [u8; BLOCK_BYTES], + buflen: usize, + last_node: bool, +} + +impl Blake2s { + fn new(node_offset: u64, node_depth: u8, last_node: bool) -> Self { + let mut param = [0u8; 32]; + param[0] = OUT_BYTES as u8; + param[2] = PARALLELISM as u8; + param[3] = 2; + param[8..14].copy_from_slice(&node_offset.to_le_bytes()[..6]); + param[14] = node_depth; + param[15] = OUT_BYTES as u8; + + let mut h = IV; + for (word, chunk) in h.iter_mut().zip(param.as_chunks::<4>().0.iter()) { + *word ^= u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]); + } + + Self { + h, + t: 0, + buf: [0; BLOCK_BYTES], + buflen: 0, + last_node, + } + } + + fn update(&mut self, mut input: &[u8]) { + // Stripe updates are one 64-byte block, final leaf tails are 1..=64 + // bytes, and the root consumes one 32-byte leaf digest at a time. + debug_assert!(!input.is_empty() && input.len() <= BLOCK_BYTES); + if self.buflen > 0 { + let fill = BLOCK_BYTES - self.buflen; + if input.len() > fill { + self.buf[self.buflen..].copy_from_slice(&input[..fill]); + self.t = self.t.wrapping_add(BLOCK_BYTES as u64); + let block = self.buf; + self.compress(&block, false); + self.buflen = 0; + input = &input[fill..]; + } else { + self.buf[self.buflen..self.buflen + input.len()].copy_from_slice(input); + self.buflen += input.len(); + return; + } + } + self.buf[..input.len()].copy_from_slice(input); + self.buflen = input.len(); + } + + fn finalize(mut self) -> [u8; OUT_BYTES] { + self.t = self.t.wrapping_add(self.buflen as u64); + self.buf[self.buflen..].fill(0); + let block = self.buf; + self.compress(&block, true); + + let mut out = [0u8; OUT_BYTES]; + for (chunk, word) in out.as_chunks_mut::<4>().0.iter_mut().zip(self.h) { + chunk.copy_from_slice(&word.to_le_bytes()); + } + out + } + + fn compress(&mut self, block: &[u8; BLOCK_BYTES], last_block: bool) { + let mut m = [0u32; 16]; + for (word, chunk) in m.iter_mut().zip(block.as_chunks::<4>().0.iter()) { + *word = u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]); + } + + let mut v = [0u32; 16]; + v[..8].copy_from_slice(&self.h); + v[8..].copy_from_slice(&IV); + v[12] ^= self.t as u32; + v[13] ^= (self.t >> 32) as u32; + if last_block { + v[14] = !v[14]; + } + if last_block && self.last_node { + v[15] = !v[15]; + } + + for s in SIGMA { + g(&mut v, 0, 4, 8, 12, m[s[0]], m[s[1]]); + g(&mut v, 1, 5, 9, 13, m[s[2]], m[s[3]]); + g(&mut v, 2, 6, 10, 14, m[s[4]], m[s[5]]); + g(&mut v, 3, 7, 11, 15, m[s[6]], m[s[7]]); + g(&mut v, 0, 5, 10, 15, m[s[8]], m[s[9]]); + g(&mut v, 1, 6, 11, 12, m[s[10]], m[s[11]]); + g(&mut v, 2, 7, 8, 13, m[s[12]], m[s[13]]); + g(&mut v, 3, 4, 9, 14, m[s[14]], m[s[15]]); + } + + for i in 0..8 { + self.h[i] ^= v[i] ^ v[i + 8]; + } + } +} + +pub(crate) struct Hasher { + leaves: [Blake2s; PARALLELISM], + buffer: [u8; BUFFER_BYTES], + buffer_len: usize, +} + +impl Hasher { + pub(crate) fn new() -> Self { + Self { + leaves: [ + Blake2s::new(0, 0, false), + Blake2s::new(1, 0, false), + Blake2s::new(2, 0, false), + Blake2s::new(3, 0, false), + Blake2s::new(4, 0, false), + Blake2s::new(5, 0, false), + Blake2s::new(6, 0, false), + Blake2s::new(7, 0, true), + ], + buffer: [0; BUFFER_BYTES], + buffer_len: 0, + } + } + + pub(crate) fn update(&mut self, mut input: &[u8]) { + if input.is_empty() { + return; + } + + if self.buffer_len > 0 { + let fill = BUFFER_BYTES - self.buffer_len; + if input.len() >= fill { + self.buffer[self.buffer_len..].copy_from_slice(&input[..fill]); + let group = self.buffer; + self.update_group(&group); + self.buffer_len = 0; + input = &input[fill..]; + } else { + self.buffer[self.buffer_len..self.buffer_len + input.len()].copy_from_slice(input); + self.buffer_len += input.len(); + return; + } + } + + let (groups, tail) = input.as_chunks::(); + for group in groups { + self.update_group(group); + } + self.buffer[..tail.len()].copy_from_slice(tail); + self.buffer_len = tail.len(); + } + + pub(crate) fn finalize(mut self) -> [u8; OUT_BYTES] { + if self.buffer_len > 0 { + let tail = &self.buffer[..self.buffer_len]; + for (leaf_index, leaf) in self.leaves.iter_mut().enumerate() { + let start = leaf_index * BLOCK_BYTES; + if tail.len() > start { + let end = (start + BLOCK_BYTES).min(tail.len()); + leaf.update(&tail[start..end]); + } + } + } + + let mut root = Blake2s::new(0, 1, true); + for leaf in self.leaves { + root.update(&leaf.finalize()); + } + root.finalize() + } + + fn update_group(&mut self, group: &[u8]) { + // Keep each leaf's final block pending, just as Blake2s::update does. + // A new full stripe proves the previous stripe is not final, so its + // eight independent compression states can run together. + if self.leaves[0].buflen == BLOCK_BYTES { + debug_assert!(self.leaves.iter().all(|leaf| leaf.buflen == BLOCK_BYTES)); + self.compress_leaf_group(); + for (leaf, block) in self + .leaves + .iter_mut() + .zip(group.as_chunks::().0.iter()) + { + leaf.buf.copy_from_slice(block); + } + return; + } + for (leaf, block) in self + .leaves + .iter_mut() + .zip(group.as_chunks::().0.iter()) + { + leaf.update(block); + } + } + + fn compress_leaf_group(&mut self) { + // Word-major lanes expose independent leaf work to the optimizer + // without CPU-specific intrinsics or changing the persistent state. + let mut message = [[0u32; PARALLELISM]; 16]; + let mut state = [[0u32; PARALLELISM]; 16]; + for (lane, leaf) in self.leaves.iter_mut().enumerate() { + leaf.t = leaf.t.wrapping_add(BLOCK_BYTES as u64); + for (word, bytes) in leaf.buf.as_chunks::<4>().0.iter().enumerate() { + message[word][lane] = u32::from_le_bytes(*bytes); + } + for word in 0..8 { + state[word][lane] = leaf.h[word]; + state[word + 8][lane] = IV[word]; + } + state[12][lane] ^= leaf.t as u32; + state[13][lane] ^= (leaf.t >> 32) as u32; + } + for schedule in SIGMA { + g_lanes::<0, 4, 8, 12>(&mut state, &message[schedule[0]], &message[schedule[1]]); + g_lanes::<1, 5, 9, 13>(&mut state, &message[schedule[2]], &message[schedule[3]]); + g_lanes::<2, 6, 10, 14>(&mut state, &message[schedule[4]], &message[schedule[5]]); + g_lanes::<3, 7, 11, 15>(&mut state, &message[schedule[6]], &message[schedule[7]]); + g_lanes::<0, 5, 10, 15>(&mut state, &message[schedule[8]], &message[schedule[9]]); + g_lanes::<1, 6, 11, 12>(&mut state, &message[schedule[10]], &message[schedule[11]]); + g_lanes::<2, 7, 8, 13>(&mut state, &message[schedule[12]], &message[schedule[13]]); + g_lanes::<3, 4, 9, 14>(&mut state, &message[schedule[14]], &message[schedule[15]]); + } + for (lane, leaf) in self.leaves.iter_mut().enumerate() { + for word in 0..8 { + leaf.h[word] ^= state[word][lane] ^ state[word + 8][lane]; + } + } + } +} + +#[inline(always)] +fn g_lanes( + state: &mut [[u32; PARALLELISM]; 16], + x: &[u32; PARALLELISM], + y: &[u32; PARALLELISM], +) { + for lane in 0..PARALLELISM { + state[A][lane] = state[A][lane] + .wrapping_add(state[B][lane]) + .wrapping_add(x[lane]); + state[D][lane] = (state[D][lane] ^ state[A][lane]).rotate_right(16); + state[C][lane] = state[C][lane].wrapping_add(state[D][lane]); + state[B][lane] = (state[B][lane] ^ state[C][lane]).rotate_right(12); + state[A][lane] = state[A][lane] + .wrapping_add(state[B][lane]) + .wrapping_add(y[lane]); + state[D][lane] = (state[D][lane] ^ state[A][lane]).rotate_right(8); + state[C][lane] = state[C][lane].wrapping_add(state[D][lane]); + state[B][lane] = (state[B][lane] ^ state[C][lane]).rotate_right(7); + } +} + +pub(crate) fn hash(input: &[u8]) -> [u8; OUT_BYTES] { + let mut hasher = Hasher::new(); + hasher.update(input); + hasher.finalize() +} + +fn g(v: &mut [u32; 16], a: usize, b: usize, c: usize, d: usize, x: u32, y: u32) { + v[a] = v[a].wrapping_add(v[b]).wrapping_add(x); + v[d] = (v[d] ^ v[a]).rotate_right(16); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(12); + v[a] = v[a].wrapping_add(v[b]).wrapping_add(y); + v[d] = (v[d] ^ v[a]).rotate_right(8); + v[c] = v[c].wrapping_add(v[d]); + v[b] = (v[b] ^ v[c]).rotate_right(7); +} + +#[cfg(test)] +mod tests { + use super::{hash, Blake2s, Hasher, BLOCK_BYTES, PARALLELISM}; + + #[test] + fn matches_public_blake2sp_vectors() { + assert_eq!( + hex(&hash(b"")), + "dd0e891776933f43c7d032b08a917e25741f8aa9a12c12e1cac8801500f2ca4f" + ); + assert_eq!( + hex(&hash(b"abc")), + "70f75b58f1fecab821db43c88ad84edde5a52600616cd22517b7bb14d440a7d5" + ); + } + + #[test] + fn block_and_stripe_boundaries_match_independent_tree_hash_vectors() { + // Python hashlib.blake2s oracle: distribute consecutive 64-byte + // blocks over eight leaves, fanout=8, depth=2, inner_size=32, + // node_offset=leaf index, node_depth=0, last_node on leaf 7. Hash + // their concatenated digests at node_depth=1, last_node=true. + // The same oracle reproduces both public vectors above. + for (length, expected) in [ + ( + 1, + "a6b9eecc25227ad788c99d3f236debc8da408849e9a5178978727a81457f7239", + ), + ( + 63, + "1024c940be7341449b5010522b509f65bbdc1287b455c2bb7f72b2c92fd0d189", + ), + ( + 64, + "52603b6cbfad4966cb044cb267568385cf35f21e6c45cf30aed19832cb51e9f5", + ), + ( + 65, + "fff24d3cc729d395daf978b0157306cb495797e6c8dca1731d2f6f81b849baae", + ), + ( + 127, + "a626543c271fccc3e4450b48d66bc9cbdeb25e5d077a6213cd90cbbd0fd22076", + ), + ( + 511, + "8e1e8ee1ffa0a01028fff3bff0ae9df2565a82e55a04e9541bb78b9c4778336f", + ), + ( + 512, + "8d9e357863298dd8364b7caf4234317f8a49f180d788b7abffb521925f1e1ff1", + ), + ( + 513, + "8a4bc3330497e681f15daf24fc496044a1c32bf0a837a210399e1ae4af7e92be", + ), + ( + 1023, + "0db3cb64828effe5b2aa6be5e865121f03226cca6423b8841b1019cfad09ac09", + ), + ( + 1024, + "48467549502e2d3f422870bfb1d09bce71a065735763bf654582cf46a5112793", + ), + ( + 1025, + "04e03e65b8f19a5f46288802b2a515bab73363262caa300ae75c0eb29c016e5a", + ), + ( + 4097, + "055d3f5f5440fe6c8dd0dcceb503b93caa03a533b71b1e47b4fdcb5577b8762a", + ), + ] { + let input: Vec<_> = (0..length).map(|i| (i % 251) as u8).collect(); + assert_eq!(hex(&hash(&input)), expected, "length={length}"); + for chunk_size in [1, 31, 32, 63, 64, 65, 127, 511, 512, 513] { + let mut hasher = Hasher::new(); + hasher.update(&[]); + for chunk in input.chunks(chunk_size) { + hasher.update(chunk); + hasher.update(&[]); + } + assert_eq!( + hex(&hasher.finalize()), + expected, + "length={length}, chunk_size={chunk_size}" + ); + } + } + } + + #[test] + fn streaming_hasher_matches_one_shot_hash() { + let input: Vec = (0..4097).map(|i| (i % 251) as u8).collect(); + let mut hasher = Hasher::new(); + for chunk in input.chunks(37) { + hasher.update(chunk); + } + assert_eq!(hasher.finalize(), hash(&input)); + } + + #[test] + fn batched_stripes_match_independent_long_tree_hash_vectors() { + // Same independent hashlib tree parameters as the boundary vectors, + // with enough complete stripes to repeatedly enter the batched path. + for (length, expected) in [ + ( + 65_535, + "ab141a58697b388f28149af484e466beea9f28dbd5aed8e649f02fa8d0afcb0d", + ), + ( + 65_536, + "f31ebaad05d2ead9e476110facfaaf38141a58d53da972a09be1d9e22e0a94ad", + ), + ( + 65_537, + "60e42e849f6f22218ae9faeb17cf9eaf00fd9bc140a4b392109d6378557a4192", + ), + ( + 1_048_576, + "65f05ea2b52b252474eadbcc69d159009c3b7b98e2c630a3056561269d78656e", + ), + ] { + let input: Vec<_> = (0..length).map(|i| (i % 251) as u8).collect(); + assert_eq!(hex(&hash(&input)), expected, "length={length}"); + for chunk_size in [63, 64, 65, 511, 512, 513, 4097, 65_536] { + let mut hasher = Hasher::new(); + for chunk in input.chunks(chunk_size) { + hasher.update(chunk); + } + assert_eq!( + hex(&hasher.finalize()), + expected, + "length={length}, chunk={chunk_size}" + ); + } + } + } + + #[test] + fn batched_updates_match_scalar_leaves_for_varied_data_and_tails() { + let mut random = 0x1234_5678u32; + let input: Vec<_> = (0..65_537) + .map(|_| { + random = random.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (random >> 24) as u8 + }) + .collect(); + for length in [ + 0, 1, 63, 64, 65, 511, 512, 513, 1023, 1024, 1025, 4095, 4096, 4097, 65_535, 65_536, + 65_537, + ] { + let data = &input[..length]; + let mut leaves: [Blake2s; PARALLELISM] = + std::array::from_fn(|lane| Blake2s::new(lane as u64, 0, lane == PARALLELISM - 1)); + for (block_index, block) in data.chunks(BLOCK_BYTES).enumerate() { + leaves[block_index % PARALLELISM].update(block); + } + let mut root = Blake2s::new(0, 1, true); + for leaf in leaves { + root.update(&leaf.finalize()); + } + let expected = root.finalize(); + assert_eq!(hash(data), expected, "length={length}"); + for chunk_size in [1, 67, 511, 512, 513, 4097] { + let mut hasher = Hasher::new(); + for chunk in data.chunks(chunk_size) { + hasher.update(chunk); + } + assert_eq!( + hasher.finalize(), + expected, + "length={length}, chunk={chunk_size}" + ); + } + } + } + + #[test] + fn batched_compression_keeps_each_leaf_counter_and_wrapping_arithmetic() { + for counter in [0, 1, u64::MAX - 64, u64::MAX - 63, u64::MAX - 32] { + let prepare = || { + let mut hasher = Hasher::new(); + for (lane, leaf) in hasher.leaves.iter_mut().enumerate() { + leaf.t = counter.wrapping_add(lane as u64); + leaf.buflen = BLOCK_BYTES; + for (byte_index, byte) in leaf.buf.iter_mut().enumerate() { + *byte = (byte_index * 17 + lane * 41) as u8; + } + for (word, value) in leaf.h.iter_mut().enumerate() { + *value ^= u32::MAX.wrapping_sub((word * 17 + lane * 41) as u32); + } + } + hasher + }; + let mut actual = prepare(); + let mut expected = prepare(); + actual.compress_leaf_group(); + for leaf in &mut expected.leaves { + leaf.t = leaf.t.wrapping_add(BLOCK_BYTES as u64); + let block = leaf.buf; + leaf.compress(&block, false); + } + for (actual, expected) in actual.leaves.iter().zip(expected.leaves) { + assert_eq!(actual.h, expected.h); + assert_eq!(actual.t, expected.t); + assert_eq!(actual.buf, expected.buf); + assert_eq!(actual.buflen, expected.buflen); + } + } + } + + fn hex(bytes: &[u8]) -> String { + const HEX: &[u8; 16] = b"0123456789abcdef"; + let mut out = String::with_capacity(bytes.len() * 2); + for &byte in bytes { + out.push(HEX[(byte >> 4) as usize] as char); + out.push(HEX[(byte & 0x0f) as usize] as char); + } + out + } +} diff --git a/arca-rar/vendor/rars/src/rar50/extract.rs b/arca-rar/vendor/rars/src/rar50/extract.rs new file mode 100644 index 00000000..5186406f --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/extract.rs @@ -0,0 +1,4148 @@ +#[path = "scratch.rs"] +mod scratch; +use super::{blake2sp, Archive, ExtractedEntryMeta, FileHeader, FileRedirection}; +use crate::codec::rar50::{ + DecodeMode, DecodedChunk, HistoryRetention, ReaderState, StreamDecodeError, +}; +use crate::codec::workspace::{Allowance, Boxed, Budget, Buffer}; +use crate::crc32::{crc32, Crc32}; +#[cfg(feature = "encryption")] +use crate::crypto::rar50::Rar50Cipher; +use crate::crypto::rar50::Rar50Keys; +use crate::error::{Error, Result}; +use crate::volume_extract::{ChainedReader, SplitVolumeState, SplitVolumeStep}; +use std::io::{Read, Write}; + +// Filtered RAR5 members still need whole-member byte transforms. Members at or +// below this boundary use the buffered path, while larger members stream once +// and reject filtered streams through the codec's typed sentinel. +#[cfg(not(test))] +const BUFFERED_DECODE_LIMIT: u64 = 512 * 1024 * 1024; +#[cfg(test)] +const BUFFERED_DECODE_LIMIT: u64 = 1024; + +#[cfg(all(test, feature = "write"))] +#[path = "streaming_checks_tests.rs"] +mod streaming_checks_tests; + +impl FileHeader { + fn check_output_limit(&self, budget: &crate::output_limit::OutputBudget) -> Result<()> { + if !budget.is_limited() || self.is_directory() || self.redirection.is_some() { + return Ok(()); + } + let size = self.known_unpacked_size().ok_or_else(|| { + self.entry_error( + "limiting output", + Error::UnsupportedFeature { + version: crate::ArchiveVersion::Rar50, + feature: "output-limited extraction of an unknown-size member", + }, + ) + })?; + budget.check(size, &self.name) + } + + fn check_dictionary_limit(&self, limit: Option) -> Result<()> { + let Some(limit) = limit else { + return Ok(()); + }; + if self.is_stored() || self.is_directory() || self.redirection.is_some() { + return Ok(()); + } + let required = self + .decoded_compression_info() + .map_err(|error| self.entry_error("checking dictionary limit", error))? + .dictionary_size; + if required > limit { + return Err(self.entry_error( + "checking dictionary limit", + Error::Rar50DictionaryLimitExceeded { limit, required }, + )); + } + Ok(()) + } + + fn encryption_keys(&self, password: Option<&[u8]>) -> Result { + #[cfg(not(feature = "encryption"))] + { + let _ = (self, password); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + crate::crypto::require_encryption()?; + + // Both callers have already selected an encrypted member. + if let Some(crypto) = &self.crypto { + return Ok(crypto.keys.clone()); + } + let password = password.ok_or(Error::NeedPassword)?; + let encryption = self.encryption.as_ref().ok_or(Error::InvalidHeader( + "RAR 5 encrypted file is missing encryption record", + ))?; + if encryption.version != 0 { + return Err(Error::UnsupportedFeature { + version: crate::version::ArchiveVersion::Rar50, + feature: "RAR 5 unknown file encryption version", + }); + } + let keys = Rar50Keys::derive(password, encryption.salt, encryption.kdf_count) + .map_err(super::map_rar50_crypto_error)?; + if let Some(check_value) = encryption.check_value { + keys.check_password(&check_value) + .map_err(super::map_rar50_crypto_error)?; + } + Ok(keys) + } + } + + fn encryption_iv(&self) -> Result<[u8; 16]> { + if let Some(crypto) = &self.crypto { + return Ok(crypto.iv); + } + self.encryption + .as_ref() + .map(|encryption| encryption.iv) + .ok_or(Error::InvalidHeader( + "RAR 5 encrypted file is missing encryption record", + )) + } + + fn packed_data_with_allowance( + &self, + archive: &Archive, + password: Option<&[u8]>, + control: &crate::read_control::ReadControl, + allowance: &B, + ) -> Result<(Buffer, Option)> { + control.check()?; + let (reader, keys) = self.packed_reader_with_allowance(archive, password, allowance)?; + let mut reader = control.reader(reader); + let mut packed = Buffer::new(allowance); + packed.read_to_end(&mut reader)?; + Ok((packed, keys)) + } + + fn packed_reader_with_allowance<'a, B: Budget>( + &self, + archive: &'a Archive, + password: Option<&[u8]>, + allowance: &B, + ) -> Result<( + PackedReader, B>, + Option, + )> { + let reader = archive.range_reader(self.block.data_range.clone())?; + if !self.encrypted { + return Ok((PackedReader::Plain(reader), None)); + } + if !self.packed_size().is_multiple_of(16) { + return Err(Error::InvalidHeader( + "RAR 5 encrypted file payload is not block aligned", + )); + } + let keys = self.encryption_keys(password)?; + let iv = self.encryption_iv()?; + let reader = Boxed::try_new( + || Rar50DecryptingReader::with_keys(reader, keys.key, iv), + allowance, + )?; + Ok((PackedReader::Encrypted(reader), Some(keys))) + } + + #[cfg(all(test, feature = "write", feature = "encryption"))] + fn packed_reader_with_password<'a>( + &self, + archive: &'a Archive, + password: Option<&[u8]>, + ) -> Result<( + PackedReader>, + Option, + )> { + self.packed_reader_with_allowance(archive, password, &Allowance::default()) + } + + /// True when the header carries a BLAKE2sp record this build can check. + /// + /// That record is the authoritative check, and the header's CRC32 is not + /// evaluated beside it. Measured on RAR 7.12 and unrar 7.20 with a file + /// header carrying both: a deliberately wrong CRC32 next to a correct + /// BLAKE2sp tests clean in both readers, while a correct CRC32 next to a + /// corrupted BLAKE2sp is rejected by both. rars used to check both fields + /// and so rejected the first archive. + /// + /// WinRAR writes one or the other, never both, so this only shows up on + /// archives from somewhere else. + fn blake2sp_supersedes_crc32(&self) -> bool { + self.hash + .as_ref() + .is_some_and(|hash| hash.hash_type == 0 && hash.data.len() == 32) + } + + fn needs_crc32(&self) -> bool { + self.data_crc32.is_some() && !self.blake2sp_supersedes_crc32() + } + + pub(super) fn verify_integrity_with_keys( + &self, + data: &[u8], + keys: Option<&Rar50Keys>, + ) -> Result<()> { + if let Some(expected) = self + .data_crc32 + .filter(|_| !self.blake2sp_supersedes_crc32()) + { + let actual = crc32(data); + let actual = if self.uses_hash_mac() { + let keys = keys.ok_or(Error::InvalidHeader( + "RAR 5 encrypted hash MAC needs encryption keys", + ))?; + keys.checked_crc_mac(actual)? + } else { + actual + }; + if actual != expected { + return Err(Error::Crc32Mismatch { expected, actual }); + } + } + + let Some(hash) = &self.hash else { + return Ok(()); + }; + match hash.hash_type { + 0 if hash.data.len() == 32 => { + let actual = blake2sp::hash(data); + let actual = if self.uses_hash_mac() { + let keys = keys.ok_or(Error::InvalidHeader( + "RAR 5 encrypted hash MAC needs encryption keys", + ))?; + keys.checked_hash_mac(actual)? + } else { + actual + }; + if constant_time_eq(&hash.data, &actual) { + Ok(()) + } else { + Err(Error::HashMismatch { hash_type: 0 }) + } + } + 0 => Err(Error::InvalidHeader( + "RAR 5 BLAKE2sp hash record has invalid length", + )), + _ => Ok(()), + } + } + + fn verify_streaming_integrity( + &self, + crc: Crc32, + hash: Option<([u8; 32], blake2sp::Hasher)>, + keys: Option<&Rar50Keys>, + ) -> Result<()> { + if let Some(expected) = self + .data_crc32 + .filter(|_| !self.blake2sp_supersedes_crc32()) + { + let actual = if self.uses_hash_mac() { + let keys = keys.ok_or(Error::InvalidHeader( + "RAR 5 encrypted hash MAC needs encryption keys", + ))?; + keys.checked_crc_mac(crc.finish())? + } else { + crc.finish() + }; + if actual != expected { + return Err(Error::Crc32Mismatch { expected, actual }); + } + } + + if let Some((expected, hasher)) = hash { + let actual = if self.uses_hash_mac() { + let keys = keys.ok_or(Error::InvalidHeader( + "RAR 5 encrypted hash MAC needs encryption keys", + ))?; + keys.checked_hash_mac(hasher.finalize())? + } else { + hasher.finalize() + }; + if !constant_time_eq(&expected, &actual) { + return Err(Error::HashMismatch { hash_type: 0 }); + } + } + Ok(()) + } + + /// Modification time in Unix seconds, using extraction's established + /// base-header precedence and falling back to the extended time record. + /// Unlike filesystem extraction metadata, this retains absent versus epoch. + pub fn modification_time(&self) -> Option { + self.mtime.or(self.htime_mtime) + } + + pub fn modification_time_refinement(&self) -> Option { + // Do not attach a fraction from the lower-priority extended timestamp + // to a different base-header timestamp. + self.mtime + .is_none() + .then_some(self.htime_mtime_refinement) + .flatten() + } + + pub fn metadata(&self) -> ExtractedEntryMeta { + ExtractedEntryMeta { + name: self.name.clone(), + file_time: self.modification_time(), + mtime_refinement: self.modification_time_refinement(), + attr: self.attributes, + host_os: self.host_os, + is_directory: self.is_directory(), + } + } + + pub fn write_to( + &self, + archive: &Archive, + password: Option<&[u8]>, + out: &mut impl Write, + ) -> Result<()> { + let mut session = DecoderSession::new_with_password(password, BUFFERED_DECODE_LIMIT); + session.write_file_to(archive, self, out) + } + + #[cfg(all(test, feature = "write"))] + pub(crate) fn decoded_data_unverified( + &self, + archive: &Archive, + password: Option<&[u8]>, + ) -> Result> { + let mut decoder = ReaderState::new(&Allowance::default()); + Ok(self + .decoded_data_with_decoder(archive, &mut decoder, password)? + .data + .into_vec()) + } + + #[cfg(feature = "recovery")] + pub(super) fn decoded_recovery_data( + &self, + archive: &Archive, + password: Option<&[u8]>, + control: &crate::read_control::ReadControl, + ) -> Result> { + let mut decoder = ReaderState::new(&Allowance::default()); + decoder.read_control = control.clone(); + let decoded = + control.finish(self.decoded_data_with_decoder(archive, &mut decoder, password))?; + control.check()?; + Ok(decoded.data.into_vec()) + } + + pub(super) fn decoded_comment_with_options( + &self, + archive: &Archive, + options: crate::ArchiveReadOptions<'_>, + ) -> Result> { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.decoded_comment_with_allowance( + archive, + options, + &Allowance::limited(limit), + ); + } + self.decoded_comment_with_allowance(archive, options, &Allowance::default()) + } + + fn decoded_comment_with_allowance( + &self, + archive: &Archive, + options: crate::ArchiveReadOptions<'_>, + allowance: &B, + ) -> Result> { + let mut budget = crate::output_limit::OutputBudget::new(options); + if budget.is_limited() && self.known_unpacked_size().is_none() { + return Err(Error::UnsupportedFeature { + version: crate::ArchiveVersion::Rar50, + feature: "output-limited decoding of an unknown-size comment", + }); + } + budget.check(self.unpacked_size, &self.name)?; + if !self.is_stored() { + if let Some(limit) = options.rar50_dictionary_size_limit { + let required = self.decoded_compression_info()?.dictionary_size; + if required > limit { + return Err(self.entry_error( + "checking dictionary limit", + Error::Rar50DictionaryLimitExceeded { limit, required }, + )); + } + } + } + // Comment services historically decode without checking payload hashes. + // Reuse bounded member decoding while retaining that checksum contract. + let payload = FileHeader { + block: self.block.clone(), + file_flags: self.file_flags, + rewrite_metadata_complete: self.rewrite_metadata_complete, + unpacked_size: self.unpacked_size, + attributes: self.attributes, + mtime: self.mtime, + htime_mtime: self.htime_mtime, + htime_mtime_refinement: self.htime_mtime_refinement, + file_times: self.file_times, + data_crc32: None, + compression_info: self.compression_info, + host_os: self.host_os, + name: self.name.clone(), + hash: None, + redirection: None, + // Parsed service payloads belong to the archive. Decoding reads its + // source range; copying service_data would create uncharged staging. + service_data: None, + encrypted: self.encrypted, + encryption: self.encryption.clone(), + crypto: self.crypto.clone(), + }; + let mut session = DecoderSession::with_allowance( + options.password, + options.rar50_buffered_decode_limit.unwrap_or(u64::MAX), + allowance, + ); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + let mut data = Vec::new(); + budget.run(&self.name, &mut data, |writer| { + if payload.is_stored() { + let decoded = payload.decoded_data_with_decoder( + archive, + &mut session.decoder, + options.password, + )?; + writer.write_all(&decoded.data)?; + Ok(()) + } else { + session.write_file_to(archive, &payload, writer) + } + })?; + Ok(data) + } + + fn decoded_data_with_decoder( + &self, + archive: &Archive, + decoder: &mut ReaderState, + password: Option<&[u8]>, + ) -> Result> { + self.decoded_data_with_decoder_and_history( + archive, + decoder, + password, + HistoryRetention::Retain, + ) + } + + fn decoded_data_with_decoder_and_history( + &self, + archive: &Archive, + decoder: &mut ReaderState, + password: Option<&[u8]>, + history: HistoryRetention, + ) -> Result> { + let (packed, keys) = self.packed_data_with_allowance( + archive, + password, + &decoder.read_control, + &decoder.allowance(), + )?; + let data = self.decode_packed_owned(&packed, decoder, history)?; + Ok(DecodedData { data, keys }) + } + + fn decode_packed_owned( + &self, + packed: &[u8], + decoder: &mut ReaderState, + history: HistoryRetention, + ) -> Result> { + if self.is_stored() { + if self.encrypted { + let unpacked_size = usize::try_from(self.unpacked_size).map_err(|_| { + Error::InvalidHeader("RAR 5 unpacked size overflows host address size") + })?; + if packed.len() < unpacked_size { + return Err(Error::InvalidHeader( + "RAR 5 encrypted stored file is shorter than unpacked size", + )); + } + if packed[unpacked_size..].iter().any(|&byte| byte != 0) { + return Err(Error::InvalidHeader( + "RAR 5 encrypted stored file has non-zero padding", + )); + } + return Buffer::copied(&packed[..unpacked_size], &decoder.allowance()) + .map_err(Error::from); + } + if packed.len() as u64 != self.unpacked_size { + return Err(Error::InvalidHeader( + "RAR 5 stored file has mismatched packed and unpacked sizes", + )); + } + return Buffer::copied(packed, &decoder.allowance()).map_err(Error::from); + } + // Empty compressed members can legitimately omit the packed stream. + // Any other member must decode successfully, even without CRC/hash. + if self.unpacked_size == 0 && packed.is_empty() { + return Ok(Buffer::new(&decoder.allowance())); + } + + let info = self.decoded_compression_info()?; + let dictionary_size = usize::try_from(info.dictionary_size).map_err(|_| { + Error::InvalidHeader("RAR 5 dictionary size overflows host address size") + })?; + let output_size = checked_unpacked_size(self.unpacked_size)?; + decoder + .decode_member_with_dictionary_and_history( + packed, + info.algorithm_version, + output_size, + dictionary_size, + info.solid, + DecodeMode::Lz, + history, + ) + .map_err(Error::from) + } + + fn stream_packed_with_decoder( + &self, + packed: &mut R, + keys: Option<&Rar50Keys>, + decoder: &mut ReaderState, + buffered_decode_limit: u64, + scratch_policy: Option<&crate::Rar50Scratch>, + writer: &mut dyn Write, + ) -> Result<()> { + // Split members retain their existing checksum work. Only ordinary + // members select the optional policy, independently of scratch decoding. + self.stream_packed_with_crc_policy::( + packed, + keys, + decoder, + buffered_decode_limit, + scratch_policy, + writer, + ) + } + + fn stream_packed_with_crc_policy( + &self, + packed: &mut R, + keys: Option<&Rar50Keys>, + decoder: &mut ReaderState, + buffered_decode_limit: u64, + scratch_policy: Option<&crate::Rar50Scratch>, + writer: &mut dyn Write, + ) -> Result<()> { + if let Some(policy) = scratch_policy { + return scratch::decode(self, packed, keys, decoder, policy, writer); + } + + let info = self.decoded_compression_info()?; + let dictionary_size = usize::try_from(info.dictionary_size).map_err(|_| { + Error::InvalidHeader("RAR 5 dictionary size overflows host address size") + })?; + let output_size = usize::try_from(self.unpacked_size) + .map_err(|_| Error::InvalidHeader("RAR 5 unpacked size overflows host address size"))?; + let mut crc = Crc32::new(); + let check_crc = !OPTIONAL_CRC || self.needs_crc32(); + let mut hash = streaming_hash_verifier(self)?; + decoder + .decode_member_from_reader_with_dictionary_to_sink( + packed, + info.algorithm_version, + output_size, + dictionary_size, + info.solid, + |chunk| match chunk { + DecodedChunk::Bytes(chunk) => { + if check_crc { + #[cfg(all(test, feature = "write"))] + streaming_checks_tests::record_crc_work(chunk.len(), false); + crc.update(chunk); + } + if let Some((_, hasher)) = &mut hash { + hasher.update(chunk); + } + writer.write_all(chunk) + } + DecodedChunk::Repeated { byte, len } => { + if check_crc { + write_repeated_chunk(writer, &mut crc, &mut hash, byte, len) + } else { + write_repeated_chunk_with_optional_crc( + writer, None, &mut hash, byte, len, + ) + } + } + }, + ) + .map_err(|error| match error { + StreamDecodeError::Decode(error) => Error::from(error), + StreamDecodeError::FilteredMember => Error::Rar50BufferedDecodeLimitExceeded { + limit: buffered_decode_limit, + required: self.unpacked_size, + }, + StreamDecodeError::Sink(error) => Error::from(error), + })?; + self.verify_streaming_integrity(crc, hash, keys) + } + + fn write_stored_with_allowance( + &self, + archive: &Archive, + password: Option<&[u8]>, + writer: &mut dyn Write, + allowance: &B, + ) -> Result<()> { + if !self.encrypted && self.packed_size() != self.unpacked_size { + return Err(self.entry_error( + "decoding", + Error::InvalidHeader("RAR 5 stored file has mismatched packed and unpacked sizes"), + )); + } + let (mut reader, keys) = self + .packed_reader_with_allowance(archive, password, allowance) + .map_err(|error| self.entry_error("decoding", error))?; + let mut crc = Crc32::new(); + let check_crc = self.needs_crc32(); + let mut hash = + streaming_hash_verifier(self).map_err(|error| self.entry_error("decoding", error))?; + let mut written = 0u64; + let mut buf = [0u8; 64 * 1024]; + + loop { + let count = reader + .read(&mut buf) + .map_err(Error::from) + .map_err(|error| self.entry_error("decoding", error))?; + if count == 0 { + break; + } + let remaining = + usize::try_from(self.unpacked_size.saturating_sub(written)).unwrap_or(usize::MAX); + let chunk_len = count.min(remaining); + let chunk = &buf[..chunk_len]; + if self.encrypted && buf[chunk_len..count].iter().any(|&byte| byte != 0) { + return Err(self.entry_error( + "decoding", + Error::InvalidHeader("RAR 5 encrypted stored file has non-zero padding"), + )); + } + // chunk_len is bounded by unpacked_size - written, so this sum + // cannot exceed the declared u64 size, including u64::MAX. + written += chunk.len() as u64; + if check_crc { + #[cfg(all(test, feature = "write"))] + streaming_checks_tests::record_crc_work(chunk.len(), false); + crc.update(chunk); + } + if let Some((_, hasher)) = &mut hash { + hasher.update(chunk); + } + writer + .write_all(chunk) + .map_err(Error::from) + .map_err(|error| self.entry_error("writing", error))?; + } + + if written != self.unpacked_size { + return Err(self.entry_error( + "decoding", + Error::InvalidHeader("RAR 5 stored file has mismatched packed and unpacked sizes"), + )); + } + self.verify_streaming_integrity(crc, hash, keys.as_ref()) + .map_err(|error| self.entry_error("verifying", error)) + } + + #[cfg(all(test, feature = "write"))] + fn decode_packed_with_decoder( + &self, + packed: &[u8], + decoder: &mut ReaderState, + ) -> Result> { + self.decode_packed_owned(packed, decoder, HistoryRetention::Retain) + .map(Buffer::into_vec) + } + + fn entry_error(&self, operation: &'static str, error: Error) -> Error { + error.at_entry(self.name.clone(), operation) + } +} + +fn write_repeated_chunk( + writer: &mut dyn Write, + crc: &mut Crc32, + hash: &mut Option<([u8; 32], blake2sp::Hasher)>, + byte: u8, + len: usize, +) -> std::io::Result<()> { + write_repeated_chunk_with_optional_crc(writer, Some(crc), hash, byte, len) +} + +fn write_repeated_chunk_with_optional_crc( + writer: &mut dyn Write, + mut crc: Option<&mut Crc32>, + hash: &mut Option<([u8; 32], blake2sp::Hasher)>, + byte: u8, + mut len: usize, +) -> std::io::Result<()> { + let buffer = [byte; 64 * 1024]; + while len > 0 { + let take = len.min(buffer.len()); + let chunk = &buffer[..take]; + writer.write_all(chunk)?; + #[cfg(all(test, feature = "write"))] + streaming_checks_tests::record_repeated_output(take, byte == 0); + if let Some(crc) = crc.as_mut() { + #[cfg(all(test, feature = "write"))] + streaming_checks_tests::record_crc_work(take, byte == 0); + if byte == 0 { + crc.update_zeroes(take as u64); + } else { + crc.update(chunk); + } + } + if let Some((_, hasher)) = hash.as_mut() { + hasher.update(chunk); + } + len -= take; + } + Ok(()) +} + +impl Archive { + pub fn extract_to(&self, options: crate::ArchiveReadOptions<'_>, mut open: F) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + self.extract_to_impl(options, &mut open, &mut |_, _| Ok(()), false, None, None) + .map(|_| ()) + } + + pub fn extract_to_with_redirections( + &self, + options: crate::ArchiveReadOptions<'_>, + mut open: F, + mut redirect: R, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, + { + options.check_cancelled()?; + self.extract_to_impl(options, &mut open, &mut redirect, true, None, None) + .map(|_| ()) + } + + pub(crate) fn extract_controlled( + &self, + options: crate::ArchiveReadOptions<'_>, + selector: &mut crate::extraction_control::Selector<'_>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result { + self.extract_to_impl( + options, + &mut |_| unreachable!("controlled selection supplies writer"), + &mut |_, _| Ok(()), + false, + Some(selector), + on_error, + ) + } + + fn extract_to_impl( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + redirect: &mut R, + emit_redirections: bool, + selector: Option<&mut crate::extraction_control::Selector<'_>>, + on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, + { + if let Some(limit) = options.max_reader_workspace_bytes { + return self.extract_with_allowance( + options, + open, + redirect, + emit_redirections, + selector, + on_error, + &crate::codec::workspace::Allowance::limited(limit), + ); + } + self.extract_with_allowance( + options, + open, + redirect, + emit_redirections, + selector, + on_error, + &Allowance::default(), + ) + } + + #[allow(clippy::too_many_arguments)] + fn extract_with_allowance( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + redirect: &mut R, + emit_redirections: bool, + mut selector: Option<&mut crate::extraction_control::Selector<'_>>, + mut on_error: Option<&mut crate::extraction_control::ErrorHandler<'_>>, + allowance: &B, + ) -> Result + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, + { + options.check_cancelled()?; + let mut budget = crate::output_limit::OutputBudget::new(options); + let buffered_decode_limit = rar50_buffered_decode_limit(options); + let mut session = + DecoderSession::with_allowance(options.password, buffered_decode_limit, allowance); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + let solid = selector.is_some() + && (self.main.is_solid() || self.files().any(|file| file.compression_info & 0x40 != 0)); + for file in self.files() { + let selected = crate::extraction_control::select( + &mut selector, + options, + || crate::rar50_member(file), + solid, + )?; + let selected_writer = match selected { + Some(crate::ExtractionDecision::Skip) => continue, + Some(crate::ExtractionDecision::Stop) => { + return Ok(crate::ExtractionOutcome::Stopped); + } + Some(crate::ExtractionDecision::Extract(writer)) => Some(writer), + None => None, + }; + let result = (|| { + options.check_cancelled()?; + file.check_dictionary_limit(options.rar50_dictionary_size_limit)?; + if let Some(redirection) = &file.redirection { + if selected_writer.is_some() { + return Err(file.entry_error( + "selecting", + Error::UnsupportedFeature { + version: crate::ArchiveVersion::Rar50, + feature: "extracting redirections through extraction control", + }, + )); + } + if emit_redirections { + options.check_cancelled()?; + redirect(&file.metadata(), redirection)?; + options.check_cancelled()?; + } + return Ok(()); + } + if file.is_split_before() || file.is_split_after() { + return Err(Error::InvalidHeader( + "RAR 5 split entry requires multivolume extraction", + )); + } + file.check_output_limit(&budget)?; + let meta = file.metadata(); + options.check_cancelled()?; + let mut writer = match selected_writer { + Some(writer) => writer, + None => open(&meta)?, + }; + options.check_cancelled()?; + if !meta.is_directory { + budget.run(&file.name, &mut writer, |writer| { + session.write_file_to(self, file, writer) + })?; + } + Ok(()) + })(); + if crate::extraction_control::finish_member( + &mut on_error, + options, + || crate::rar50_member(file), + solid, + result, + )? { + session = DecoderSession::with_allowance( + options.password, + buffered_decode_limit, + allowance, + ); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + } + } + options.check_cancelled()?; + Ok(crate::ExtractionOutcome::Complete) + } + + /// Decodes independent members in bounded batches, emitting in archive order. + /// Completed batches can have been emitted when a later batch fails. The + /// buffering limit bounds retained payload bytes, not aggregate decoder state. + /// A configured total output ceiling selects sequential extraction. + pub fn extract_to_parallel_buffered( + &self, + options: crate::ArchiveReadOptions<'_>, + mut open: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + self.parallel_to_impl(options, &mut open, false) + } + + pub(crate) fn test_to( + &self, + options: crate::ArchiveReadOptions<'_>, + mut tested: F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result<()>, + { + self.parallel_to_impl( + options, + &mut |meta| { + tested(meta)?; + Ok(Box::new(std::io::sink()) as Box) + }, + true, + ) + } + + fn parallel_to_impl( + &self, + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + verification: bool, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + options.check_cancelled()?; + // Admit and charge total-limited work in archive order before dispatch. + if options.rar50_scratch.is_some() + || options.max_total_output_bytes.is_some() + || self.main.is_solid() + || self.files().any(|file| { + file.is_split_before() + || file.is_split_after() + || file.unpacked_size > rar50_buffered_decode_limit(options) + || file.decoded_compression_info().is_ok_and(|info| info.solid) + }) + { + return self.extract_to(options, open); + } + + if let Some(limit) = options.max_reader_workspace_bytes { + let ledger = Allowance::limited(limit); + let publication = crate::read_control::ReadControl::new(options.cancellation); + return crate::codec::workspace::coordinator::extract_windowed( + self.files(), + &ledger, + |file| { + if file.is_directory() || file.redirection.is_some() { + 0 + } else if file.is_stored() { + if verification { + 0 + } else { + file.unpacked_size + } + } else { + file.unpacked_size + .saturating_add(file.packed_size()) + .saturating_add(8192) + } + }, + |file, local| { + options.check_cancelled()?; + decode_parallel_entry_with_allowance( + self, + file, + options.password, + rar50_buffered_decode_limit(options), + options, + verification, + local, + ) + }, + |entry| write_parallel_entry(entry, open, &mut |_, _| Ok(()), &publication), + ); + } + + let password = options.password; + let buffered_decode_limit = rar50_buffered_decode_limit(options); + let mut files = self.files().peekable(); + let window = crate::parallel::default_window().max(1); + let publication = crate::read_control::ReadControl::new(options.cancellation); + while files.peek().is_some() { + options.check_cancelled()?; + let mut batch = Vec::new(); + let mut remaining = buffered_decode_limit; + while batch.len() < window { + let Some(file) = files.peek() else { break }; + if file.unpacked_size > remaining { + break; + } + remaining -= file.unpacked_size; + batch.push(files.next().expect("peeked file")); + } + // Write the verified members ahead of a failure before reporting it. + let (entries, failure) = crate::parallel::map_prefix(batch, |file| { + decode_parallel_entry( + self, + file, + password, + buffered_decode_limit, + options, + verification, + ) + }); + for entry in entries { + write_parallel_entry(entry, open, &mut |_, _| Ok(()), &publication)?; + } + if let Some(error) = failure { + return Err(error); + } + } + options.check_cancelled()?; + Ok(()) + } +} + +fn decode_parallel_entry( + archive: &Archive, + file: &FileHeader, + password: Option<&[u8]>, + buffered_decode_limit: u64, + options: crate::ArchiveReadOptions<'_>, + verification: bool, +) -> Result { + decode_parallel_entry_with_allowance( + archive, + file, + password, + buffered_decode_limit, + options, + verification, + &Allowance::default(), + ) +} + +enum ParallelExtractedEntry { + Directory(ExtractedEntryMeta), + Verified(ExtractedEntryMeta), + File { + meta: ExtractedEntryMeta, + data: Buffer, + }, + Redirection { + meta: ExtractedEntryMeta, + redirection: FileRedirection, + }, +} + +fn decode_parallel_entry_with_allowance( + archive: &Archive, + file: &FileHeader, + password: Option<&[u8]>, + buffered_decode_limit: u64, + options: crate::ArchiveReadOptions<'_>, + verification: bool, + allowance: &B, +) -> Result> { + options.check_cancelled()?; + let mut budget = crate::output_limit::OutputBudget::new(options); + file.check_dictionary_limit(options.rar50_dictionary_size_limit)?; + file.check_output_limit(&budget)?; + if let Some(redirection) = &file.redirection { + return Ok(ParallelExtractedEntry::Redirection { + meta: file.metadata(), + redirection: redirection.clone(), + }); + } + // The only caller dispatches workers after excluding split members. + let meta = file.metadata(); + if meta.is_directory { + return Ok(ParallelExtractedEntry::Directory(meta)); + } + let mut session = DecoderSession::with_allowance(password, buffered_decode_limit, allowance); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + // Only a disposable buffered worker can omit the final dictionary copy. + // Compression metadata is still validated at its original decode boundary; + // ReaderState also forces retention for solid and limited decoding. + let history = if !B::LIMITED + && !archive.main.is_solid() + && !file.is_split_before() + && !file.is_split_after() + && !file.is_stored() + && session.scratch.is_none() + && !file.should_stream_decode(buffered_decode_limit) + { + HistoryRetention::DiscardIndependent + } else { + HistoryRetention::Retain + }; + if verification { + budget.run(&file.name, std::io::sink(), |writer| { + session.write_file_to_with_history(archive, file, writer, history) + })?; + return Ok(ParallelExtractedEntry::Verified(meta)); + } + let mut data = Buffer::new(allowance); + budget.run(&file.name, &mut data, |writer| { + session.write_file_to_with_history(archive, file, writer, history) + })?; + Ok(ParallelExtractedEntry::File { meta, data }) +} + +fn write_parallel_entry( + entry: ParallelExtractedEntry, + open: &mut F, + redirect: &mut R, + control: &crate::read_control::ReadControl, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, +{ + control.check()?; + match entry { + ParallelExtractedEntry::Directory(meta) | ParallelExtractedEntry::Verified(meta) => { + let _ = open(&meta)?; + } + ParallelExtractedEntry::File { meta, data } => { + let mut writer = open(&meta)?; + control.check()?; + control + .write_all(&mut writer, &data) + .map_err(|error| Error::from(error).at_entry(meta.name.clone(), "extracting"))?; + } + ParallelExtractedEntry::Redirection { meta, redirection } => { + redirect(&meta, &redirection)?; + } + } + control.check()?; + Ok(()) +} + +struct DecodedData { + data: Buffer, + keys: Option, +} + +struct DecoderSession<'a, B: Budget = Allowance> { + decoder: ReaderState, + allowance: B, + password: Option<&'a [u8]>, + buffered_decode_limit: u64, + scratch: Option<&'a crate::Rar50Scratch>, +} + +impl<'a, B: Budget> DecoderSession<'a, B> { + fn with_allowance( + password: Option<&'a [u8]>, + buffered_decode_limit: u64, + allowance: &B, + ) -> Self { + Self { + decoder: ReaderState::new(allowance), + allowance: allowance.clone(), + password, + buffered_decode_limit, + scratch: None, + } + } + + fn write_file_to( + &mut self, + archive: &Archive, + file: &FileHeader, + writer: &mut dyn Write, + ) -> Result<()> { + self.write_file_to_with_history(archive, file, writer, HistoryRetention::Retain) + } + + fn write_file_to_with_history( + &mut self, + archive: &Archive, + file: &FileHeader, + writer: &mut dyn Write, + history: HistoryRetention, + ) -> Result<()> { + if file.is_stored() { + return file.write_stored_with_allowance( + archive, + self.password, + writer, + &self.allowance, + ); + } + if file.should_stream_decode(self.buffered_decode_limit) { + return self.stream_file_to(archive, file, writer); + } + let decoded = self + .decoded_file_data(archive, file, history) + .map_err(|error| file.entry_error("decoding", error))?; + file.verify_integrity_with_keys(&decoded.data, decoded.keys.as_ref()) + .map_err(|error| file.entry_error("verifying", error))?; + writer + .write_all(&decoded.data) + .map_err(Error::from) + .map_err(|error| file.entry_error("writing", error)) + } + + fn stream_file_to( + &mut self, + archive: &Archive, + file: &FileHeader, + writer: &mut dyn Write, + ) -> Result<()> { + let mut streaming_decoder = self.decoder.try_clone_for_stream()?; + let (mut packed, keys) = file + .packed_reader_with_allowance(archive, self.password, &self.allowance) + .map_err(|error| file.entry_error("reading", error))?; + file.stream_packed_with_crc_policy::( + &mut packed, + keys.as_ref(), + &mut streaming_decoder, + self.buffered_decode_limit, + self.scratch, + writer, + ) + .map_err(|error| file.entry_error("decoding", error))?; + self.decoder = streaming_decoder; + Ok(()) + } + + fn decoded_file_data( + &mut self, + archive: &Archive, + file: &FileHeader, + history: HistoryRetention, + ) -> Result> { + file.decoded_data_with_decoder_and_history( + archive, + &mut self.decoder, + self.password, + history, + ) + } + + fn split_decryptor( + &self, + split: &PendingSplitRefs, + volumes: &[Archive], + ) -> Result> { + split.split_decryptor(volumes, self.password) + } + + fn decode_split( + &mut self, + volumes: &[Archive], + split: &PendingSplitRefs, + final_file: &FileHeader, + decryptor: Option<&SplitDecryptor>, + ) -> Result> { + final_file.decode_split_with_decoder(volumes, split, &mut self.decoder, decryptor) + } + + fn stream_split_to( + &mut self, + volumes: &[Archive], + split: &PendingSplitRefs, + final_file: &FileHeader, + decryptor: Option<&SplitDecryptor>, + writer: &mut dyn Write, + ) -> Result<()> { + // Keep solid state only after successful emission and integrity checks, + // just as for a non-split streaming member. + self.decoder.read_control.check()?; + let mut decoder = self.decoder.try_clone_for_stream()?; + let control = decoder.read_control.clone(); + let mut packed = + split.fragment_reader_with_allowance(volumes, decryptor, &self.allowance)?; + control + .finish(final_file.stream_packed_with_decoder( + &mut packed, + decryptor.map(|decryptor| &decryptor.keys), + &mut decoder, + self.buffered_decode_limit, + self.scratch, + writer, + )) + .map_err(|error| match error { + // Sink/reader I/O and the intentional filter limit must retain their + // own meaning. Fragment diagnostics are for decode/integrity failure. + error + if matches!( + error.kind(), + crate::ErrorKind::Io + | crate::ErrorKind::ResourceLimit + | crate::ErrorKind::Cancelled + | crate::ErrorKind::UnsupportedFeature + ) => + { + error + } + error => split.checksum_error(volumes).unwrap_or(error), + })?; + self.decoder = decoder; + Ok(()) + } +} + +impl<'a> DecoderSession<'a, Allowance> { + fn new_with_password(password: Option<&'a [u8]>, buffered_decode_limit: u64) -> Self { + Self::with_allowance(password, buffered_decode_limit, &Allowance::default()) + } +} + +impl FileHeader { + fn should_stream_decode(&self, buffered_decode_limit: u64) -> bool { + self.unpacked_size > buffered_decode_limit + } +} + +fn rar50_buffered_decode_limit(options: crate::ArchiveReadOptions<'_>) -> u64 { + options + .rar50_buffered_decode_limit + .unwrap_or(BUFFERED_DECODE_LIMIT) +} + +/// Streams a RAR 5 multivolume archive set to caller-provided writers. +/// Compressed logical members obey the same buffered-decode threshold as ordinary +/// members. Above it, filtered members return a typed limit error. Direct sinks +/// can receive data before an integrity or decoding failure; callers requiring +/// verified publication must stage output until extraction succeeds. +pub fn extract_volumes_to( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + mut open: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, +{ + options.check_cancelled()?; + extract_volumes_to_impl(volumes, options, &mut open, &mut |_, _| Ok(()), false) +} + +pub(crate) fn test_volumes_to( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + mut tested: F, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result<()>, +{ + extract_volumes_to(volumes, options, |meta| { + tested(meta)?; + Ok(Box::new(std::io::sink()) as Box) + }) +} + +pub fn extract_volumes_to_with_redirections( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + mut open: F, + mut redirect: R, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, +{ + options.check_cancelled()?; + extract_volumes_to_impl(volumes, options, &mut open, &mut redirect, true) +} + +fn extract_volumes_to_impl( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + redirect: &mut R, + emit_redirections: bool, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, +{ + if let Some(limit) = options.max_reader_workspace_bytes { + return extract_volumes_with_allowance( + volumes, + options, + open, + redirect, + emit_redirections, + &Allowance::limited(limit), + ); + } + extract_volumes_with_allowance( + volumes, + options, + open, + redirect, + emit_redirections, + &Allowance::default(), + ) +} + +fn extract_volumes_with_allowance( + volumes: &[Archive], + options: crate::ArchiveReadOptions<'_>, + open: &mut F, + redirect: &mut R, + emit_redirections: bool, + allowance: &B, +) -> Result<()> +where + F: FnMut(&ExtractedEntryMeta) -> Result>, + R: FnMut(&ExtractedEntryMeta, &FileRedirection) -> Result<()>, +{ + options.check_cancelled()?; + if volumes.is_empty() { + return Err(Error::InvalidHeader("RAR 5 volume set is empty")); + } + + let password = options.password; + let mut budget = crate::output_limit::OutputBudget::new(options); + let mut split = SplitVolumeState::new(); + let buffered_decode_limit = rar50_buffered_decode_limit(options); + let mut session = DecoderSession::with_allowance(password, buffered_decode_limit, allowance); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + + for (volume_index, archive) in volumes.iter().enumerate() { + for (file_index, file) in archive.files().enumerate() { + options.check_cancelled()?; + // Admission precedes split decryption and checksum-error preference: + // a resource refusal must not read payloads or become a checksum error. + file.check_dictionary_limit(options.rar50_dictionary_size_limit)?; + match split.advance(file.is_split_before(), file.is_split_after()) { + SplitVolumeStep::Regular => { + if let Some(redirection) = &file.redirection { + if emit_redirections { + options.check_cancelled()?; + redirect(&file.metadata(), redirection)?; + options.check_cancelled()?; + } + continue; + } + file.check_output_limit(&budget)?; + let meta = file.metadata(); + options.check_cancelled()?; + let mut writer = open(&meta)?; + options.check_cancelled()?; + if !meta.is_directory { + budget.run(&file.name, &mut writer, |writer| { + session.write_file_to(archive, file, writer) + })?; + } + } + SplitVolumeStep::Start => { + validate_split_fragment(file, password)?; + split.begin(PendingSplitRefs::with_allowance( + file, + volume_index, + file_index, + allowance, + )?); + } + SplitVolumeStep::Continue(current) => { + validate_split_continuation_refs(current, file, password)?; + current.append(volume_index, file_index)?; + } + SplitVolumeStep::Finish(mut completed) => { + validate_split_continuation_refs(&completed, file, password)?; + completed.append(volume_index, file_index)?; + file.check_output_limit(&budget)?; + completed.write_to(volumes, file, &mut session, &mut budget, &mut *open)?; + } + SplitVolumeStep::MissingFirst => { + return Err(Error::InvalidHeader( + "RAR 5 split entry is missing its first part", + )); + } + SplitVolumeStep::Interrupted => { + return Err(Error::InvalidHeader( + "RAR 5 split entry is interrupted by a regular entry", + )); + } + } + } + } + + if split.is_pending() { + return Err(Error::InvalidHeader("RAR 5 split entry is incomplete")); + } + + options.check_cancelled()?; + Ok(()) +} + +fn validate_split_fragment(file: &FileHeader, password: Option<&[u8]>) -> Result<()> { + if file.is_directory() { + return Err(Error::InvalidHeader( + "RAR 5 split directory entry is invalid", + )); + } + if file.encrypted { + crate::crypto::require_encryption()?; + } + if file.encrypted && password.is_none() && file.crypto.is_none() { + return Err(Error::NeedPassword); + } + Ok(()) +} + +fn validate_split_continuation_refs( + pending: &PendingSplitRefs, + file: &FileHeader, + password: Option<&[u8]>, +) -> Result<()> { + validate_split_fragment(file, password)?; + if file.name != pending.name { + return Err(Error::InvalidHeader("RAR 5 split entry name changed")); + } + if file.compression_info != pending.compression_info { + return Err(Error::InvalidHeader( + "RAR 5 split entry compression info changed", + )); + } + if file.encrypted != pending.encrypted { + return Err(Error::InvalidHeader( + "RAR 5 split entry encryption flag changed", + )); + } + Ok(()) +} + +struct PendingSplitRefs { + name: Vec, + fragments: Buffer<(usize, usize), B>, + file_time: Option, + mtime_refinement: Option, + attr: u64, + host_os: u64, + compression_info: u64, + encrypted: bool, +} + +impl PendingSplitRefs { + fn with_allowance( + file: &FileHeader, + volume_index: usize, + file_index: usize, + allowance: &B, + ) -> Result { + Ok(Self { + name: file.name.clone(), + fragments: Buffer::copied(&[(volume_index, file_index)], allowance)?, + file_time: file.modification_time(), + mtime_refinement: file.modification_time_refinement(), + attr: file.attributes, + host_os: file.host_os, + compression_info: file.compression_info, + encrypted: file.encrypted, + }) + } + + fn append(&mut self, volume_index: usize, file_index: usize) -> Result<()> { + self.fragments.try_push((volume_index, file_index))?; + Ok(()) + } + + fn write_to( + self, + volumes: &[Archive], + final_file: &FileHeader, + session: &mut DecoderSession<'_, B>, + budget: &mut crate::output_limit::OutputBudget, + open: &mut F, + ) -> Result<()> + where + F: FnMut(&ExtractedEntryMeta) -> Result>, + { + budget.control.check()?; + let decryptor = session.split_decryptor(&self, volumes)?; + budget.control.check()?; + let meta = ExtractedEntryMeta { + name: self.name.clone(), + file_time: self.file_time, + mtime_refinement: self.mtime_refinement, + attr: self.attr, + host_os: self.host_os, + is_directory: false, + }; + let mut writer = open(&meta)?; + budget.run(&final_file.name, &mut writer, |mut writer| { + // Decode/integrity failures can gain fragment context. I/O failures + // (including the output guard sentinel) must retain their meaning. + if final_file.is_stored() { + return self + .write_stored_to(volumes, final_file, decryptor.as_ref(), &mut writer) + .map_err(|error| { + if error.kind() == crate::ErrorKind::Io { + error + } else { + self.checksum_error(volumes).unwrap_or(error) + } + }) + .map_err(|error| final_file.entry_error("extracting", error)); + } + + if final_file.should_stream_decode(session.buffered_decode_limit) { + return session + .stream_split_to(volumes, &self, final_file, decryptor.as_ref(), &mut writer) + .map_err(|error| final_file.entry_error("decoding", error)); + } + + let data = session + .decode_split(volumes, &self, final_file, decryptor.as_ref()) + .map_err(|error| final_file.entry_error("decoding", error))?; + final_file + .verify_integrity_with_keys( + &data, + decryptor.as_ref().map(|decryptor| &decryptor.keys), + ) + .map_err(|error| self.checksum_error(volumes).unwrap_or(error)) + .map_err(|error| final_file.entry_error("verifying", error))?; + writer + .write_all(&data) + .map_err(Error::from) + .map_err(|error| final_file.entry_error("writing", error))?; + Ok(()) + }) + } + + fn write_stored_to( + &self, + volumes: &[Archive], + final_file: &FileHeader, + decryptor: Option<&SplitDecryptor>, + writer: &mut dyn Write, + ) -> Result<()> { + let mut reader = + self.fragment_reader_with_allowance(volumes, decryptor, &self.fragments.allowance())?; + let mut crc = Crc32::new(); + let mut hash = streaming_hash_verifier(final_file)?; + let mut written = 0u64; + let mut buf = [0u8; 64 * 1024]; + + loop { + let count = reader.read(&mut buf)?; + if count == 0 { + break; + } + let chunk = if final_file.encrypted { + let remaining = usize::try_from(final_file.unpacked_size.saturating_sub(written)) + .unwrap_or(usize::MAX); + let chunk_len = count.min(remaining); + if buf[chunk_len..count].iter().any(|&byte| byte != 0) { + return Err(Error::InvalidHeader( + "RAR 5 encrypted stored split file has non-zero padding", + )); + } + &buf[..chunk_len] + } else { + &buf[..count] + }; + written = written + .checked_add(chunk.len() as u64) + .ok_or(Error::InvalidHeader("RAR 5 stored split size overflows"))?; + crc.update(chunk); + if let Some((_, hasher)) = &mut hash { + hasher.update(chunk); + } + writer.write_all(chunk)?; + } + + if written != final_file.unpacked_size { + return Err(Error::InvalidHeader( + "RAR 5 stored split file has mismatched packed and unpacked sizes", + )); + } + if let Some(expected) = final_file + .data_crc32 + .filter(|_| !final_file.blake2sp_supersedes_crc32()) + { + // Gate on the tweaked-checksum flag, not on "is encrypted". + // An encrypted file whose crypt record leaves flag 0x0002 clear + // stores a plain CRC32, and MACing ours fails a sound archive. + let actual = if final_file.uses_hash_mac() { + let decryptor = decryptor.ok_or(Error::InvalidHeader( + "RAR 5 encrypted split CRC needs encryption keys", + ))?; + decryptor.keys.checked_crc_mac(crc.finish())? + } else { + crc.finish() + }; + if actual != expected { + return Err(Error::Crc32Mismatch { expected, actual }); + } + } + if let Some((expected, hasher)) = hash { + let actual = if final_file.uses_hash_mac() { + let decryptor = decryptor.ok_or(Error::InvalidHeader( + "RAR 5 encrypted split hash needs encryption keys", + ))?; + decryptor.keys.checked_hash_mac(hasher.finalize())? + } else { + hasher.finalize() + }; + if !constant_time_eq(&expected, &actual) { + return Err(Error::HashMismatch { hash_type: 0 }); + } + } + Ok(()) + } + + fn split_decryptor( + &self, + volumes: &[Archive], + password: Option<&[u8]>, + ) -> Result> { + if !self.encrypted { + return Ok(None); + } + // Fragment indices come from this immutable volume slice. + let (volume_index, file_index) = self.fragments[0]; + let archive = &volumes[volume_index]; + let file = archive + .files() + .nth(file_index) + .expect("split fragment index comes from archive enumeration"); + let keys = file.encryption_keys(password)?; + Ok(Some(SplitDecryptor { + keys, + iv: file.encryption_iv()?, + })) + } + + /// Re-reads every fragment that carries a checksum over its own stored + /// bytes and reports the first that disagrees. + /// + /// Only consulted once a member has already failed. Checking as the + /// fragments are read would reject an archive whose fragment checksums say + /// something other than what rars and WinRAR put there, and unrar and RAR + /// 7.12 both extract those. Reading the set a second time to explain a + /// failure is worth it; refusing a member that would have come out intact + /// is not. + fn checksum_error(&self, volumes: &[Archive]) -> Option { + let last = self.fragments.len().saturating_sub(1); + for (index, &(volume_index, file_index)) in self.fragments.iter().enumerate() { + if index == last { + break; + } + // Indices originate in extract_volumes_to_impl's enumeration of + // this same immutable volume slice; neither collection can change. + let archive = &volumes[volume_index]; + let file = archive + .files() + .nth(file_index) + .expect("split fragment index comes from archive enumeration"); + let Some(expected) = file.data_crc32 else { + continue; + }; + let mut crc = Crc32::new(); + if archive + .copy_range_to(file.block.data_range.clone(), &mut CrcSink(&mut crc)) + .is_err() + { + continue; + } + let actual = crc.finish(); + if actual != expected { + return Some(Error::InVolume { + number: volume_index + 1, + source: Box::new(Error::Crc32Mismatch { expected, actual }), + }); + } + } + None + } + + fn fragment_reader_with_allowance<'a>( + &self, + volumes: &'a [Archive], + decryptor: Option<&SplitDecryptor>, + allowance: &B, + ) -> Result, B>, B>> { + let mut readers = Buffer::with_capacity(self.fragments.len(), allowance)?; + for &(volume_index, file_index) in &self.fragments { + let archive = &volumes[volume_index]; + let file = archive + .files() + .nth(file_index) + .expect("split fragment index comes from archive enumeration"); + readers.push_admitted(archive.range_reader(file.block.data_range.clone())?); + } + let chained = ChainedReader::with_readers(readers); + if let Some(decryptor) = decryptor { + Ok(PackedReader::Encrypted(Boxed::try_new( + || Rar50DecryptingReader::with_keys(chained, decryptor.keys.key, decryptor.iv), + allowance, + )?)) + } else { + Ok(PackedReader::Plain(chained)) + } + } +} + +#[cfg(all(test, feature = "write"))] +impl PendingSplitRefs { + fn new(file: &FileHeader, volume_index: usize, file_index: usize) -> Self { + Self::with_allowance(file, volume_index, file_index, &Allowance::default()) + .expect("unlimited split bookkeeping") + } +} + +struct SplitDecryptor { + keys: Rar50Keys, + iv: [u8; 16], +} + +fn streaming_hash_verifier(file: &FileHeader) -> Result> { + let Some(hash) = &file.hash else { + return Ok(None); + }; + match hash.hash_type { + 0 if hash.data.len() == 32 => { + let mut expected = [0u8; 32]; + expected.copy_from_slice(&hash.data); + Ok(Some((expected, blake2sp::Hasher::new()))) + } + 0 => Err(Error::InvalidHeader( + "RAR 5 BLAKE2sp hash record has invalid length", + )), + _ => Ok(None), + } +} + +fn checked_unpacked_size(size: u64) -> Result { + usize::try_from(size) + .map_err(|_| Error::InvalidHeader("RAR 5 unpacked size overflows host address size")) +} + +fn constant_time_eq(left: &[u8], right: &[u8]) -> bool { + if left.len() != right.len() { + return false; + } + let mut diff = 0u8; + for (&left, &right) in left.iter().zip(right) { + diff |= left ^ right; + } + diff == 0 +} + +impl FileHeader { + fn decode_split_with_decoder( + &self, + volumes: &[Archive], + split: &PendingSplitRefs, + decoder: &mut ReaderState, + decryptor: Option<&SplitDecryptor>, + ) -> Result> { + // PendingSplitRefs::write_to dispatches stored members to + // write_stored_to before calling this compressed-member decoder. + let info = self.decoded_compression_info()?; + let dictionary_size = usize::try_from(info.dictionary_size).map_err(|_| { + Error::InvalidHeader("RAR 5 dictionary size overflows host address size") + })?; + let mut reader = + split.fragment_reader_with_allowance(volumes, decryptor, &decoder.allowance())?; + let output_size = checked_unpacked_size(self.unpacked_size)?; + let decoded = decoder + .decode_member_from_reader_with_dictionary( + &mut reader, + info.algorithm_version, + output_size, + dictionary_size, + info.solid, + DecodeMode::Lz, + ) + .map_err(Error::from); + // A damaged volume usually derails the decoder before the fragment it + // sits in is read to its end, so the reader's own check never fires and + // the member fails as "truncated" instead. Checking the fragments here + // turns that into the checksum mismatch it is. + match decoded { + Err(error) + if matches!( + error.kind(), + crate::ErrorKind::ResourceLimit + | crate::ErrorKind::Cancelled + | crate::ErrorKind::Io + | crate::ErrorKind::UnsupportedFeature + ) => + { + Err(error) + } + Err(error) => Err(split.checksum_error(volumes).unwrap_or(error)), + decoded => decoded, + } + } +} + +/// Feeds what it is given to a running CRC32 and keeps none of it. +struct CrcSink<'a>(&'a mut Crc32); + +impl Write for CrcSink<'_> { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.0.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +enum PackedReader { + Plain(R), + Encrypted(Boxed, B>), +} +impl Read for PackedReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + match self { + Self::Plain(reader) => reader.read(out), + Self::Encrypted(reader) => reader.read(out), + } + } +} + +#[cfg(not(feature = "encryption"))] +type Rar50DecryptingReader = crate::crypto::unavailable::Reader; + +#[cfg(feature = "encryption")] +struct Rar50DecryptingReader { + inner: R, + cipher: Rar50Cipher, + buffer: [u8; 16], + encrypted_len: usize, + pos: usize, + len: usize, +} + +#[cfg(feature = "encryption")] +impl Rar50DecryptingReader { + fn with_keys(inner: R, key: [u8; 32], iv: [u8; 16]) -> Result { + Ok(Self::new(inner, key, iv)) + } + + fn new(inner: R, key: [u8; 32], iv: [u8; 16]) -> Self { + Self { + inner, + cipher: Rar50Cipher::new(key, iv), + buffer: [0; 16], + encrypted_len: 0, + pos: 0, + len: 0, + } + } + + fn fill_buffer(&mut self) -> std::io::Result { + // Preserve bytes already consumed if the source returns an error. + // In particular, Read::read_to_end retries Interrupted automatically. + while self.encrypted_len < self.buffer.len() { + let count = self.inner.read(&mut self.buffer[self.encrypted_len..])?; + if count == 0 { + if self.encrypted_len == 0 { + return Ok(false); + } + return Err(std::io::Error::new( + std::io::ErrorKind::UnexpectedEof, + "truncated RAR 5 encrypted stream", + )); + } + self.encrypted_len += count; + } + self.cipher.decrypt_block(&mut self.buffer); + self.encrypted_len = 0; + self.pos = 0; + self.len = self.buffer.len(); + Ok(true) + } +} + +#[cfg(feature = "encryption")] +impl Read for Rar50DecryptingReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + if out.is_empty() { + return Ok(0); + } + if self.pos == self.len && !self.fill_buffer()? { + return Ok(0); + } + let count = out.len().min(self.len - self.pos); + out[..count].copy_from_slice(&self.buffer[self.pos..self.pos + count]); + self.pos += count; + Ok(count) + } +} + +#[cfg(all(test, feature = "write"))] +mod tests { + #[test] + fn checksum_sink_flush_preserves_accumulated_checksum() { + let mut crc = Crc32::new(); + { + let mut sink = CrcSink(&mut crc); + sink.flush().unwrap(); + assert_eq!(sink.write(b"").unwrap(), 0); + assert_eq!(sink.write(b"a").unwrap(), 1); + sink.flush().unwrap(); + sink.write_all(b"bc").unwrap(); + sink.flush().unwrap(); + sink.flush().unwrap(); + } + assert_eq!(crc.finish(), 0x3524_41c2); + } + + #[test] + fn reader_workspace_split_descriptor_growth_is_admitted_before_mutation() { + let first = stored_split_archive(b"a", b"a", crc32(b"a"), HFL_SPLIT_AFTER) + .files() + .next() + .unwrap() + .clone(); + let bytes = std::mem::size_of::<(usize, usize)>() as u64; + let quota = Allowance::limited(bytes); + let mut pending = PendingSplitRefs::with_allowance(&first, 0, 0, "a).unwrap(); + assert_eq!(quota.used(), bytes); + let error = pending.append(1, 0).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(&pending.fragments[..], &[(0, 0)]); + assert_eq!(quota.used(), bytes); + drop(pending); + assert_eq!(quota.used(), 0); + } + + #[test] + fn compressed_split_reader_releases_each_refused_allocation() { + let volumes = [ + include_bytes!("../../tests/fixtures/rar50/multivol.part1.rar").as_slice(), + include_bytes!("../../tests/fixtures/rar50/multivol.part2.rar").as_slice(), + include_bytes!("../../tests/fixtures/rar50/multivol.part3.rar").as_slice(), + ] + .map(|bytes| Archive::parse(bytes).unwrap()); + let first = volumes[0].files().next().unwrap(); + let last = volumes[2].files().next().unwrap(); + assert!(!last.is_stored()); + refuse_each_reader_session_allocation(|budget| { + let mut split = PendingSplitRefs::with_allowance(first, 0, 0, budget)?; + split.append(1, 0)?; + split.append(2, 0)?; + let mut decoder = ReaderState::new(budget); + let decoded = last.decode_split_with_decoder(&volumes, &split, &mut decoder, None)?; + assert_eq!(decoded.len(), 4096); + assert_eq!(crc32(&decoded), 0xb9c5_4415); + Ok(()) + }); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_split_reader_releases_descriptor_and_cipher_allocations() { + let volumes = [ + include_bytes!("../../tests/fixtures/rar50/encrypted_multivol.part1.rar").as_slice(), + include_bytes!("../../tests/fixtures/rar50/encrypted_multivol.part2.rar").as_slice(), + include_bytes!("../../tests/fixtures/rar50/encrypted_multivol.part3.rar").as_slice(), + ] + .map(|bytes| Archive::parse_with_password(bytes, Some(b"password")).unwrap()); + let first = volumes[0].files().next().unwrap(); + assert!(first.encrypted); + let decryptor = SplitDecryptor { + keys: first.encryption_keys(Some(b"password")).unwrap(), + iv: first.encryption_iv().unwrap(), + }; + refuse_each_reader_session_allocation(|budget| { + let mut split = PendingSplitRefs::with_allowance(first, 0, 0, budget)?; + split.append(1, 0)?; + split.append(2, 0)?; + let _reader = + split.fragment_reader_with_allowance(&volumes, Some(&decryptor), budget)?; + Ok(()) + }); + } + + #[test] + fn reader_session_workspace_refusals_release_rar5_scratch_filter_buffers_and_files() { + let dir = crate::scratch::case("reader-workspace-rar5-scratch"); + let policy = crate::Rar50Scratch::new(&*dir, 4096); + let data = b"scratch Delta quota buffers scratch Delta quota buffers".repeat(2); + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1), + ) + .entry(entry(b"filtered.bin", &data)) + .filter_policy(FilterPolicy::Explicit(crate::FilterSpec::whole( + FilterKind::Delta { channels: 2 }, + ))) + .finish() + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + refuse_each_reader_session_allocation(|budget| { + let result = (|| { + let mut session = DecoderSession::with_allowance(None, 1, budget); + session.scratch = Some(&policy); + let mut out = Buffer::new(budget); + session.write_file_to(&archive, file, &mut out)?; + assert_eq!(&out[..], &data); + Ok(()) + })(); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + result + }); + let budget = Allowance::limited(1); + let mut session = DecoderSession::with_allowance(None, 1, &budget); + session.scratch = Some(&policy); + let error = session + .write_file_to(&archive, file, &mut std::io::sink()) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(budget.used(), 0); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + } + + fn refuse_each_reader_session_allocation( + mut run: impl FnMut(&crate::codec::workspace::RefusingBudget) -> Result<()>, + ) { + use crate::codec::workspace::RefusingBudget; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline).unwrap(); + assert_eq!(baseline.used(), 0); + assert!(baseline.attempts() > 0); + for index in 0..baseline.attempts() { + let budget = RefusingBudget::new(index); + let error = run(&budget).unwrap_err(); + assert_eq!( + error.kind(), + crate::ErrorKind::Cancelled, + "allocation {index}: {error}" + ); + assert_eq!(budget.used(), 0, "allocation {index}"); + } + } + + #[test] + fn reader_session_workspace_refusals_release_rar5_packed_output_cipher_and_checkpoints() { + let data = b"RAR5 charged member payload!\n".repeat(3); + for encrypted in crate::test_features::encryption_cases() { + for filtered in [false, true] { + let input = if encrypted { + entry(b"charged.bin", &data).with_password(b"password".to_vec()) + } else { + entry(b"charged.bin", &data) + }; + let mut writer = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1), + ) + .entry(input); + if filtered { + writer = writer.filter_policy(FilterPolicy::Explicit( + crate::FilterSpec::whole(FilterKind::Delta { channels: 2 }), + )); + } + let bytes = writer.finish().unwrap(); + let archive = Archive::parse_with_password(&bytes, Some(b"password")).unwrap(); + let file = archive.files().next().unwrap(); + assert!(!file.is_stored()); + for limit in if filtered { + vec![u64::MAX] + } else { + vec![u64::MAX, 1] + } { + refuse_each_reader_session_allocation(|budget| { + let mut session = + DecoderSession::with_allowance(Some(b"password"), limit, budget); + let mut out = Buffer::new(budget); + session.write_file_to(&archive, file, &mut out)?; + assert_eq!(&out[..], &data); + let mut second = Buffer::new(budget); + session.write_file_to(&archive, file, &mut second)?; + assert_eq!(&second[..], &data); + Ok(()) + }); + } + } + } + } + + use super::super::{ + ArchiveEntry, ArchiveSource, Block, BlockHeader, FileEncryption, FileHash, FilterKind, + FilterPolicy, MainHeader, Rar50Writer, WriterOptions, HEAD_FILE, HFL_SPLIT_AFTER, + HFL_SPLIT_BEFORE, + }; + use super::*; + use crate::{ArchiveVersion, FeatureSet}; + use std::cell::RefCell; + #[cfg(feature = "encryption")] + use std::io::Cursor; + use std::rc::Rc; + use std::sync::Arc; + + /// Builds a member from bytes the test already holds. + fn entry(name: &[u8], data: &[u8]) -> ArchiveEntry { + ArchiveEntry::new( + name.to_vec(), + crate::EntrySource::from_bytes(Arc::<[u8]>::from(data.to_vec())), + ) + } + + #[test] + fn streaming_checkpoint_rolls_back_filter_sink_cancellation_and_integrity_failures() { + let mut word = 0x1234_5678u32; + // Avoid a period aligned with the 64 KiB flush: appending or resetting + // to the first failed flush must change the successor's match bytes. + let seed: Vec<_> = (0..32749) + .map(|_| { + word ^= word << 13; + word ^= word >> 17; + word ^= word << 5; + word as u8 + }) + .collect(); + let first_data = seed.repeat(4); + let next_data = first_data[127..4224].to_vec(); + let mut builder = crate::Builder::new(ArchiveVersion::Rar50) + .store(false) + .solid(true) + .compression_level(Some(1)); + builder + .add_bytes(b"first".to_vec(), first_data.clone(), None, None) + .unwrap(); + builder + .add_bytes(b"next".to_vec(), next_data.clone(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + let files: Vec<_> = archive.files().collect(); + assert!(files.iter().all(|file| !file.is_stored())); + assert!(files[1].decoded_compression_info().unwrap().solid); + assert!( + files[1].packed_size() < 128, + "next member must use old history" + ); + + let filtered_data = b"late filter checkpoint bytes\n".repeat(8192); + let filtered_bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1), + ) + .entry(entry(b"filtered", &filtered_data)) + .filter_policy(FilterPolicy::Explicit(crate::FilterSpec::range( + FilterKind::E8, + 128 * 1024..filtered_data.len(), + ))) + .finish() + .unwrap(); + let filtered_archive = Archive::parse_owned(filtered_bytes).unwrap(); + let mut filtered = filtered_archive.files().next().unwrap().clone(); + filtered.compression_info |= 0x40; + + struct CancelOnWrite<'a> { + token: &'a crate::ReadCancellation, + written: usize, + } + impl Write for CancelOnWrite<'_> { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.written += bytes.len(); + self.token.cancel(); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + struct RejectWrite; + impl Write for RejectWrite { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::other("checkpoint sink failed")) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + for failure in ["filter", "sink", "cancellation", "integrity"] { + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + session + .write_file_to(&archive, files[0], &mut std::io::sink()) + .unwrap(); + match failure { + "filter" => { + let mut partial = Vec::new(); + let error = session + .write_file_to(&filtered_archive, &filtered, &mut partial) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert!(partial.len() >= 64 * 1024, "filter follows a flush"); + } + "sink" => { + let error = session + .write_file_to(&archive, files[0], &mut RejectWrite) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + } + "cancellation" => { + let token = crate::ReadCancellation::new(); + session.decoder.read_control = + crate::read_control::ReadControl::new(Some(&token)); + let mut writer = CancelOnWrite { + token: &token, + written: 0, + }; + let error = session + .write_file_to(&archive, files[0], &mut writer) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled); + assert!(writer.written >= 64 * 1024); + session.decoder.read_control = Default::default(); + } + "integrity" => { + let mut corrupt = files[1].clone(); + corrupt.hash = None; + corrupt.data_crc32 = Some(crc32(&next_data) ^ 1); + let error = session + .write_file_to(&archive, &corrupt, &mut std::io::sink()) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ChecksumMismatch); + } + _ => unreachable!(), + } + // The successor references the old, nonperiodic raw dictionary. + // A failed checkpoint must not have reset or appended to it. + let mut decoded = Vec::new(); + session + .write_file_to(&archive, files[1], &mut decoded) + .unwrap(); + assert_eq!(decoded, next_data, "after {failure}"); + } + + // Prove the successor detects the two erroneous history states that + // the failed first flush could publish, rather than accepting a fixture + // whose repeating phase accidentally masks a broken checkpoint. + let prefix = &first_data[..64 * 1024]; + let packed_prefix = crate::codec::rar50::encode_literal_only(prefix, 0).unwrap(); + for appended in [false, true] { + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + session + .write_file_to(&archive, files[0], &mut std::io::sink()) + .unwrap(); + session + .decoder + .decode_member_from_reader_with_dictionary_to_sink( + &mut packed_prefix.as_slice(), + 0, + prefix.len(), + 4 * 1024 * 1024, + appended, + |_| Ok::<(), std::convert::Infallible>(()), + ) + .unwrap(); + let error = session + .write_file_to(&archive, files[1], &mut std::io::sink()) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ChecksumMismatch); + } + } + + #[test] + fn parallel_extraction_emits_a_bounded_batch_before_decoding_the_next() { + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(0), + ) + .entries([entry(b"first", &[1; 64]), entry(b"second", &[2; 64])]) + .finish() + .unwrap(); + let mut archive = Archive::parse_owned(bytes).unwrap(); + for block in &mut archive.blocks { + if let super::super::Block::File(file) = block { + if file.name == b"second" { + file.hash = None; + file.data_crc32 = Some(0); + } + } + } + let mut opened = Vec::new(); + let error = archive + .extract_to_parallel_buffered( + crate::ArchiveReadOptions::default().with_rar50_buffered_decode_limit(64), + |meta| { + opened.push(meta.name.clone()); + Ok(Box::new(std::io::sink())) + }, + ) + .unwrap_err(); + assert!(matches!(error, Error::AtEntry { source, .. } + if matches!(*source, Error::Crc32Mismatch { .. }))); + assert_eq!(opened, vec![b"first".to_vec()]); + } + + #[test] + fn parallel_extraction_handles_empty_entries_and_small_limits() { + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(0), + ) + .entries([entry(b"empty", &[]), entry(b"data", &[1; 64])]) + .finish() + .unwrap(); + let archive = Archive::parse_owned(bytes).unwrap(); + for limit in [0, 32, 64, 128] { + let mut opened = Vec::new(); + archive + .extract_to_parallel_buffered( + crate::ArchiveReadOptions::default().with_rar50_buffered_decode_limit(limit), + |meta| { + opened.push(meta.name.clone()); + Ok(Box::new(std::io::sink())) + }, + ) + .unwrap(); + assert_eq!(opened, vec![b"empty".to_vec(), b"data".to_vec()]); + } + } + + fn plain_file(name: &[u8], data: &[u8], hash: Option) -> FileHeader { + FileHeader { + block: empty_block(HEAD_FILE, 0, 0..0), + file_flags: 0, + rewrite_metadata_complete: true, + unpacked_size: data.len() as u64, + attributes: 0x20, + mtime: None, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32: None, + compression_info: 0, + host_os: 2, + name: name.to_vec(), + hash, + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + } + } + + #[test] + fn limited_parallel_extraction_accounts_for_directory_link_and_stored_file() { + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let mut directory = plain_file(b"dir", b"", None); + directory.file_flags |= super::super::FHFL_DIRECTORY; + let mut link = plain_file(b"link", b"", None); + link.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"file".to_vec(), + }); + let mut file = plain_file(b"file", b"payload", None); + file.block = empty_block(HEAD_FILE, 0, 0..7); + let archive = archive_with_blocks( + vec![Block::File(directory), Block::File(link), Block::File(file)], + b"payload".to_vec(), + ); + let output = Rc::new(RefCell::new(Vec::new())); + let mut seen = Vec::new(); + archive + .extract_to_parallel_buffered( + crate::ArchiveReadOptions::new().with_max_reader_workspace_bytes(1 << 20), + |meta| { + seen.push((meta.name.clone(), meta.is_directory)); + Ok(Box::new(Capture(output.clone()))) + }, + ) + .unwrap(); + assert_eq!(seen, [(b"dir".to_vec(), true), (b"file".to_vec(), false)]); + assert_eq!(&*output.borrow(), b"payload"); + } + + #[test] + fn direct_streaming_extracts_compressed_zero_run() { + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let data = vec![0; 16 * 1024]; + let bytes = Rar50Writer::new(WriterOptions::new( + ArchiveVersion::Rar50, + FeatureSet::store_only(), + )) + .entries([entry(b"zeroes", &data)]) + .finish() + .unwrap(); + let archive = Archive::parse_owned(bytes).unwrap(); + assert!(!archive.files().next().unwrap().is_stored()); + let output = Rc::new(RefCell::new(Vec::new())); + archive + .extract_to( + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(0), + |_| Ok(Box::new(Capture(output.clone()))), + ) + .unwrap(); + assert_eq!(*output.borrow(), data); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_streams_rar50_blocks() { + let key = [3u8; 32]; + let iv = [4u8; 16]; + let plain = *b"0123456789abcdefRAR5 block two!!"; + let mut encrypted = plain; + Rar50Cipher::new(key, iv) + .encrypt_in_place(&mut encrypted) + .unwrap(); + let mut reader = Rar50DecryptingReader::new(Cursor::new(encrypted), key, iv); + let mut out = Vec::new(); + let mut buf = [0u8; 5]; + + loop { + let count = reader.read(&mut buf).unwrap(); + if count == 0 { + break; + } + out.extend_from_slice(&buf[..count]); + } + + assert_eq!(out, plain); + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_preserves_partial_blocks_across_source_errors() { + let key = [3; 32]; + let iv = [4; 16]; + let plain = *b"0123456789abcdefRAR5 block two!!"; + let mut encrypted = plain; + Rar50Cipher::new(key, iv) + .encrypt_in_place(&mut encrypted) + .unwrap(); + for kind in [ + std::io::ErrorKind::Interrupted, + std::io::ErrorKind::PermissionDenied, + ] { + for fail_at in [0, 5, 16, 21] { + let inner = + crate::read_errors::ErrorOnceReader::new(encrypted.to_vec(), fail_at, kind); + let mut reader = Rar50DecryptingReader::new(inner, key, iv); + let mut out = Vec::new(); + let result = reader.read_to_end(&mut out); + if kind == std::io::ErrorKind::Interrupted { + result.unwrap(); + } else { + let error = result.unwrap_err(); + assert_eq!(error.kind(), kind); + assert_eq!(error.to_string(), "source read failed"); + assert_eq!(out, plain[..fail_at as usize / 16 * 16]); + reader.read_to_end(&mut out).unwrap(); + } + assert_eq!(out, plain, "error {kind:?} at {fail_at}"); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn decrypting_reader_handles_short_reads_and_truncated_final_blocks() { + let key = [3u8; 32]; + let iv = [4u8; 16]; + let plain = *b"0123456789abcdefRAR5 block two!!"; + let mut encrypted = plain; + Rar50Cipher::new(key, iv) + .encrypt_in_place(&mut encrypted) + .unwrap(); + + struct ShortReads(Cursor>); + impl Read for ShortReads { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + let count = out.len().min(3); + self.0.read(&mut out[..count]) + } + } + + for length in 0..=encrypted.len() { + let mut reader = Rar50DecryptingReader::new( + ShortReads(Cursor::new(encrypted[..length].to_vec())), + key, + iv, + ); + // An empty destination must neither consume nor validate input. + assert_eq!(reader.read(&mut []).unwrap(), 0); + assert_eq!(reader.inner.0.position(), 0); + let mut out = Vec::new(); + let result = reader.read_to_end(&mut out); + let complete_length = length / 16 * 16; + assert_eq!(out, plain[..complete_length], "ciphertext length {length}"); + if length % 16 == 0 { + result.unwrap(); + assert_eq!(reader.read(&mut [0]).unwrap(), 0); + } else { + assert_eq!( + result.unwrap_err().kind(), + std::io::ErrorKind::UnexpectedEof, + "ciphertext length {length}" + ); + } + } + } + + #[test] + fn split_checksum_diagnostics_continue_past_uncheckable_fragments() { + let data = b"fragment"; + let scratch = crate::scratch::case("rar5-split-checksum-source"); + let missing = scratch.join("removed.part"); + std::fs::write(&missing, data).unwrap(); + for first_kind in 0..5 { + let mut first = stored_split_archive(data, data, crc32(data), HFL_SPLIT_AFTER); + match first_kind { + 0 => { + let Block::File(file) = &mut first.blocks[0] else { + unreachable!(); + }; + file.data_crc32 = None; + } + 1 => {} + 2 => first.source = ArchiveSource::File(Arc::new(missing.clone())), + 3 | 4 => { + let Block::File(file) = &mut first.blocks[0] else { + unreachable!(); + }; + file.block.data_range = if first_kind == 3 { + data.len()..0 + } else { + 0..data.len() + 1 + }; + } + _ => unreachable!(), + } + let mut volumes = vec![ + first, + stored_split_archive( + data, + data, + crc32(data) ^ 1, + HFL_SPLIT_BEFORE | HFL_SPLIT_AFTER, + ), + stored_split_archive(data, data, crc32(data) ^ 2, HFL_SPLIT_BEFORE), + ]; + let mut pending = PendingSplitRefs::new(volumes[0].files().next().unwrap(), 0, 0); + pending.append(1, 0).unwrap(); + pending.append(2, 0).unwrap(); + if first_kind == 2 { + std::fs::remove_file(&missing).unwrap(); + } + let error = pending.checksum_error(&volumes).unwrap(); + assert!(matches!(error, Error::InVolume { number: 2, source } + if matches!(*source, Error::Crc32Mismatch { expected, actual } + if expected == crc32(data) ^ 1 && actual == crc32(data)))); + let Block::File(file) = &mut volumes[1].blocks[0] else { + unreachable!(); + }; + file.data_crc32 = Some(crc32(data)); + // The final fragment carries the member checksum, not a checksum + // of its packed bytes, and must be excluded from this diagnostic. + assert!(pending.checksum_error(&volumes).is_none()); + } + } + + #[test] + fn stored_split_entries_stream_fragments_to_writer() { + struct SharedWriter(Rc>>); + + impl Write for SharedWriter { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let first = b"stored "; + let second = b"split payload"; + let full = [first.as_slice(), second.as_slice()].concat(); + let expected_crc = crc32(&full); + let volumes = vec![ + stored_split_archive(first, &full, expected_crc, HFL_SPLIT_AFTER), + stored_split_archive(second, &full, expected_crc, HFL_SPLIT_BEFORE), + ]; + let captured = Rc::new(RefCell::new(Vec::new())); + let sink = captured.clone(); + + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default(), + move |_meta| Ok(Box::new(SharedWriter(sink.clone()))), + ) + .unwrap(); + + assert_eq!(&*captured.borrow(), &full); + } + + #[test] + fn filtered_checksum_failure_cannot_publish_unfiltered_payload() { + let data = [ + b"prefix".as_slice(), + b"\xe8\0\0\0\0code".repeat(20).as_slice(), + ] + .concat(); + let mut bytes = Rar50Writer::new(WriterOptions::new( + ArchiveVersion::Rar50, + FeatureSet::store_only(), + )) + .entry(entry(b"filtered.bin", &data)) + .filter_policy(FilterPolicy::explicit(FilterKind::E8)) + .finish() + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let file = archive.files().next().unwrap(); + let info = file.decoded_compression_info().unwrap(); + let raw = ReaderState::new(&Allowance::default()) + .decode_member_with_dictionary( + &file.packed_data(&archive).unwrap(), + info.algorithm_version, + data.len(), + info.dictionary_size as usize, + false, + DecodeMode::LzNoFilters, + ) + .unwrap(); + assert_ne!(raw, data); + let mut fields = super::super::HeaderReader::new(&bytes, file.block.header_range.clone()); + let flags = fields.read_vint().unwrap(); + fields.read_vint().unwrap(); + fields.read_vint().unwrap(); + if flags & super::super::FHFL_MTIME != 0 { + fields.read_u32().unwrap(); + } + let crc_pos = fields.pos; + assert_ne!(flags & super::super::FHFL_CRC32, 0); + let header_end = file.block.header_range.end + file.block.extra_area_size.unwrap() as usize; + let mut hash_range = None; + super::super::parse_extra_records( + &bytes, + file.block.header_range.end..header_end, + false, + &crate::read_control::ReadControl::default(), + |kind, range| { + if kind == super::super::FHEXTRA_HASH { + assert_eq!(bytes[range.start], 0); + hash_range = Some(range.start + 1..range.end); + } + Ok(()) + }, + ) + .unwrap(); + bytes[crc_pos..crc_pos + 4].copy_from_slice(&crc32(&raw).to_le_bytes()); + bytes[hash_range.unwrap()].copy_from_slice(&blake2sp::hash(&raw)); + let start = file.block.offset; + let header_crc = crc32(&bytes[start + 4..header_end]); + bytes[start..start + 4].copy_from_slice(&header_crc.to_le_bytes()); + let archive = Archive::parse(&bytes).unwrap(); + let captured = Rc::new(RefCell::new(Vec::new())); + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let error = archive + .extract_to(crate::ArchiveReadOptions::new(), |_| { + Ok(Box::new(Capture(captured.clone()))) + }) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::HashMismatch { hash_type: 0 } + )); + assert!(captured.borrow().is_empty()); + } + + #[test] + fn bounded_filtered_members_use_buffered_decode() { + let mut data = Vec::new(); + while data.len() + 29 <= BUFFERED_DECODE_LIMIT as usize { + data.extend_from_slice(b"\xe8\0\0\0\0filtered payload block\n"); + } + assert!(data.len() as u64 <= BUFFERED_DECODE_LIMIT); + + let archive = Rar50Writer::new(WriterOptions { + target: crate::ArchiveVersion::Rar50, + features: crate::FeatureSet::store_only(), + compression_level: None, + dictionary_size: None, + }) + .entries( + [entry(b"filtered.bin", &data) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(FilterPolicy::explicit(FilterKind::E8)) + .finish() + .unwrap(); + let archive = Archive::parse(&archive).unwrap(); + let file = archive.files().next().unwrap(); + assert!(!file.should_stream_decode(BUFFERED_DECODE_LIMIT)); + + let mut out = Vec::new(); + file.write_to(&archive, None, &mut out).unwrap(); + + assert_eq!(out, data); + } + + #[test] + fn streaming_filtered_members_return_typed_error_without_preflight_decode() { + for prefix_len in [0, 64 * 1024] { + let mut data = vec![b'P'; prefix_len]; + while (data.len() - prefix_len) as u64 <= BUFFERED_DECODE_LIMIT { + data.extend_from_slice(b"\xe8\0\0\0\0filtered payload block\n"); + } + + let archive = Rar50Writer::new(WriterOptions { + target: crate::ArchiveVersion::Rar50, + features: crate::FeatureSet::store_only(), + compression_level: None, + dictionary_size: None, + }) + .entries( + [entry(b"filtered.bin", &data) + .with_attributes(0x20) + .with_host_os(3)] + .to_vec(), + ) + .filter_policy(FilterPolicy::Explicit(crate::FilterSpec::range( + FilterKind::E8, + prefix_len..data.len(), + ))) + .finish() + .unwrap(); + let archive = Archive::parse(&archive).unwrap(); + let file = archive.files().next().unwrap(); + assert!(file.should_stream_decode(BUFFERED_DECODE_LIMIT)); + + // The member is valid and extracts in full when buffering is allowed. + let captured = Rc::new(RefCell::new(Vec::new())); + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + archive + .extract_to( + crate::ArchiveReadOptions::new() + .with_rar50_buffered_decode_limit(data.len() as u64), + |_| Ok(Box::new(Capture(captured.clone()))), + ) + .unwrap(); + assert_eq!(*captured.borrow(), data); + + let mut out = Vec::new(); + let error = file.write_to(&archive, None, &mut out).unwrap_err(); + + assert!(matches!( + error, + Error::AtEntry { + operation: "decoding", + source, + .. + } if matches!(*source, Error::Rar50BufferedDecodeLimitExceeded { .. }) + )); + assert_eq!(out, data[..prefix_len]); + } + } + + #[test] + fn streaming_crc32_zero_advance_matches_byte_update() { + let mut bytewise = Crc32::new(); + bytewise.update(&vec![0; 100_000]); + + let mut skipped = Crc32::new(); + skipped.update_zeroes(100_000); + + assert_eq!(skipped.finish(), bytewise.finish()); + } + + #[test] + fn repeated_chunk_does_not_advance_crc_after_sink_error() { + struct FailingWriter; + + impl Write for FailingWriter { + fn write(&mut self, _buf: &[u8]) -> std::io::Result { + Err(std::io::Error::other("sink failed")) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let mut writer = FailingWriter; + let mut crc = Crc32::new(); + let expected = Crc32::new().finish(); + + assert!(write_repeated_chunk(&mut writer, &mut crc, &mut None, 0, 1024).is_err()); + assert_eq!(crc.finish(), expected); + } + + #[test] + fn encrypted_stored_decode_rejects_nonzero_discarded_padding() { + let mut file = plain_file(b"secret.txt", b"secret", None); + file.encrypted = true; + file.unpacked_size = 6; + let mut decoder = ReaderState::new(&Allowance::default()); + + assert_eq!( + file.decode_packed_with_decoder(b"secret\0\0", &mut decoder) + .unwrap(), + b"secret" + ); + assert!(matches!( + file.decode_packed_with_decoder(b"secret\0\x01", &mut decoder), + Err(Error::InvalidHeader( + "RAR 5 encrypted stored file has non-zero padding" + )) + )); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn unrepresentable_dictionary_is_refused_by_buffered_streaming_and_split_decoders() { + struct NeverRead; + impl Read for NeverRead { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + panic!("an unrepresentable dictionary must be rejected before reading") + } + } + let mut file = plain_file(b"large-dictionary", &[0], None); + file.compression_info = (5 << 7) | (15 << 10); + assert_eq!( + file.decoded_compression_info().unwrap().dictionary_size, + 1u64 << 32 + ); + let expected = Error::InvalidHeader("RAR 5 dictionary size overflows host address size"); + let mut decoder = ReaderState::new(&Allowance::default()); + assert_eq!( + file.decode_packed_owned(&[0], &mut decoder).unwrap_err(), + expected + ); + assert_eq!( + file.stream_packed_with_decoder( + &mut NeverRead, + None, + &mut decoder, + u64::MAX, + None, + &mut std::io::sink() + ) + .unwrap_err(), + expected + ); + + let mut first = file.clone(); + first.block.flags = HFL_SPLIT_AFTER; + first.block.data_range = 0..1; + first.block.data_size = Some(1); + let mut last = first.clone(); + last.block.flags = HFL_SPLIT_BEFORE; + let volumes = [ + archive_with_blocks(vec![Block::File(first.clone())], vec![0]), + archive_with_blocks(vec![Block::File(last.clone())], vec![0]), + ]; + let mut split = PendingSplitRefs::new(&first, 0, 0); + split.append(1, 0).unwrap(); + assert_eq!( + last.decode_split_with_decoder(&volumes, &split, &mut decoder, None) + .unwrap_err(), + expected + ); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn encrypted_stored_size_above_the_host_limit_is_refused() { + let mut file = plain_file(b"large-stored", &[], None); + file.encrypted = true; + file.encryption = Some(FileEncryption { + version: 0, + flags: 0, + kdf_count: 0, + salt: [0; 16], + iv: [0; 16], + check_value: None, + }); + file.unpacked_size = 1u64 << 32; + let mut decoder = ReaderState::new(&Allowance::default()); + assert_eq!( + file.decode_packed_owned(&[0; 16], &mut decoder) + .unwrap_err(), + Error::InvalidHeader("RAR 5 unpacked size overflows host address size") + ); + } + + #[test] + fn checked_unpacked_size_rejects_values_above_host_usize() { + assert_eq!(checked_unpacked_size(123).unwrap(), 123usize); + + let overflowing = usize::MAX as u128 + 1; + if overflowing <= u64::MAX as u128 { + assert!(checked_unpacked_size(overflowing as u64).is_err()); + } + } + + #[test] + fn constant_time_hash_comparison_keeps_hash_validation_behaviour() { + let data = b"hash me"; + let file = FileHeader { + block: empty_block(HEAD_FILE, 0, 0..0), + file_flags: 0, + rewrite_metadata_complete: true, + unpacked_size: data.len() as u64, + attributes: 0x20, + mtime: None, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32: None, + compression_info: 0, + host_os: 2, + name: b"hash.txt".to_vec(), + hash: Some(FileHash { + hash_type: 0, + data: blake2sp::hash(data).to_vec(), + }), + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + }; + + file.verify_integrity_with_keys(data, None).unwrap(); + + let mut wrong = file; + wrong.hash.as_mut().unwrap().data[31] ^= 0x01; + assert!(matches!( + wrong.verify_integrity_with_keys(data, None), + Err(Error::HashMismatch { hash_type: 0 }) + )); + } + + #[test] + fn verify_integrity_rejects_bad_blake2sp_length_and_ignores_unknown_hash_type() { + let data = b"hash me"; + let mut bad_length = plain_file( + b"a.txt", + data, + Some(FileHash { + hash_type: 0, + data: vec![0u8; 16], + }), + ); + bad_length.data_crc32 = Some(crc32(data)); + assert!(matches!( + bad_length.verify_integrity_with_keys(data, None), + Err(Error::InvalidHeader(_)) + )); + + bad_length.hash.as_mut().unwrap().hash_type = 99; + bad_length.hash.as_mut().unwrap().data = vec![0u8; 32]; + bad_length.verify_integrity_with_keys(data, None).unwrap(); + bad_length.data_crc32 = Some(0); + assert!(matches!( + bad_length.verify_integrity_with_keys(data, None), + Err(Error::Crc32Mismatch { .. }) + )); + } + + #[test] + fn streaming_hash_verifier_rejects_bad_blake2sp_length_and_ignores_unknown_hash_type() { + let mut file = plain_file( + b"a.txt", + b"", + Some(FileHash { + hash_type: 0, + data: vec![0u8; 16], + }), + ); + assert!(matches!( + streaming_hash_verifier(&file), + Err(Error::InvalidHeader(_)) + )); + + file.hash.as_mut().unwrap().hash_type = 7; + file.hash.as_mut().unwrap().data = vec![0u8; 32]; + assert!(matches!(streaming_hash_verifier(&file), Ok(None))); + + let nohash = plain_file(b"a.txt", b"", None); + assert!(matches!(streaming_hash_verifier(&nohash), Ok(None))); + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_keys_reject_missing_password_record_and_unsupported_versions() { + let mut missing = plain_file(b"a.txt", b"", None); + missing.encrypted = true; + assert!(matches!( + missing.encryption_keys(None), + Err(Error::NeedPassword) + )); + assert!(matches!( + missing.encryption_keys(Some(b"pw")), + Err(Error::InvalidHeader(_)) + )); + + let mut bad_version = plain_file(b"a.txt", b"", None); + bad_version.encrypted = true; + bad_version.encryption = Some(FileEncryption { + version: 1, + flags: 0, + kdf_count: 0, + salt: [0u8; 16], + iv: [0u8; 16], + check_value: None, + }); + assert!(matches!( + bad_version.encryption_keys(Some(b"pw")), + Err(Error::UnsupportedFeature { .. }) + )); + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_keys_handles_missing_check_value() { + let mut file = plain_file(b"a.txt", b"", None); + file.encrypted = true; + file.encryption = Some(FileEncryption { + version: 0, + flags: 0, + kdf_count: 0, + salt: [0u8; 16], + iv: [0u8; 16], + check_value: None, + }); + file.encryption_keys(Some(b"pw")).unwrap(); + } + + #[test] + fn decode_packed_rejects_stored_size_mismatch() { + let mut decoder = ReaderState::new(&Allowance::default()); + + let mut file = plain_file(b"a.txt", &[0u8; 32], None); + file.unpacked_size = 32; + let short = vec![0u8; 16]; + assert!(matches!( + file.decode_packed_with_decoder(&short, &mut decoder), + Err(Error::InvalidHeader(_)) + )); + + let mut encrypted = plain_file(b"b.txt", &[0u8; 32], None); + encrypted.encrypted = true; + encrypted.unpacked_size = 32; + let too_short = vec![0u8; 16]; + assert!(matches!( + encrypted.decode_packed_with_decoder(&too_short, &mut decoder), + Err(Error::InvalidHeader(_)) + )); + + let exact = vec![0u8; 64]; + let trimmed = encrypted + .decode_packed_with_decoder(&exact, &mut decoder) + .unwrap(); + assert_eq!(trimmed.len(), encrypted.unpacked_size as usize); + } + + #[test] + fn extraction_rejects_stored_members_with_mismatched_packed_size() { + let data = b"payload"; + for unpacked_size in [data.len() as u64 - 1, data.len() as u64 + 1] { + let mut file = plain_file(b"stored.txt", data, None); + file.unpacked_size = unpacked_size; + file.block.data_range = 0..data.len(); + let archive = archive_with_blocks(vec![Block::File(file)], data.to_vec()); + + for parallel in [false, true] { + let open = |_: &ExtractedEntryMeta| Ok(Box::new(std::io::sink()) as Box); + let result = if parallel { + archive.extract_to_parallel_buffered(crate::ArchiveReadOptions::default(), open) + } else { + archive.extract_to(crate::ArchiveReadOptions::default(), open) + }; + let error = result.expect_err("stored member size mismatch must fail"); + assert!(matches!(error.root_cause(), Error::InvalidHeader(_))); + } + } + } + + #[test] + fn stored_extraction_rejects_file_source_truncated_after_header_read() { + let data = b"stored source can change"; + let mut file = plain_file(b"stored.txt", data, None); + file.block.data_range = 0..data.len(); + file.block.data_size = Some(data.len() as u64); + let scratch = crate::scratch::case("rar5-stored-truncated-source"); + let path = scratch.join("member.part"); + std::fs::write(&path, data).unwrap(); + let mut archive = archive_with_blocks(vec![Block::File(file)], Vec::new()); + archive.source = ArchiveSource::File(Arc::new(path.clone())); + std::fs::write(&path, &data[..data.len() - 3]).unwrap(); + + let captured = Rc::new(RefCell::new(Vec::new())); + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let error = archive + .extract_to(crate::ArchiveReadOptions::default(), |_| { + Ok(Box::new(Capture(captured.clone()))) + }) + .unwrap_err(); + assert_eq!(*captured.borrow(), data[..data.len() - 3]); + assert!(matches!( + error.root_cause(), + Error::InvalidHeader("RAR 5 stored file has mismatched packed and unpacked sizes") + )); + } + + #[test] + fn verify_streaming_integrity_validates_crc_and_hash() { + let payload = b"streaming"; + let crc_value = crc32(payload); + let hash_value = blake2sp::hash(payload); + + let mut file = plain_file(b"s.txt", payload, None); + file.data_crc32 = Some(crc_value); + file.hash = Some(FileHash { + hash_type: 0, + data: hash_value.to_vec(), + }); + + let make_state = || { + let mut crc = Crc32::new(); + crc.update(payload); + let mut hasher = blake2sp::Hasher::new(); + hasher.update(payload); + (crc, Some((hash_value, hasher))) + }; + + let (crc, hash) = make_state(); + file.verify_streaming_integrity(crc, hash, None).unwrap(); + + // A wrong CRC32 alongside a valid BLAKE2sp is ignored, because the + // reference readers never evaluate it there. Drop the hash record and + // the same wrong CRC32 has to be caught. + let (crc, hash) = make_state(); + let mut bad = file.clone(); + bad.data_crc32 = Some(crc_value ^ 0x1); + bad.verify_streaming_integrity(crc, hash, None).unwrap(); + + let (crc, _) = make_state(); + let mut crc_only = bad.clone(); + crc_only.hash = None; + assert!(matches!( + crc_only.verify_streaming_integrity(crc, None, None), + Err(Error::Crc32Mismatch { .. }) + )); + + let (crc, _) = make_state(); + let mut wrong_expected = hash_value; + wrong_expected[0] ^= 0xff; + let mut hasher = blake2sp::Hasher::new(); + hasher.update(payload); + let mut bad_hash = file.clone(); + bad_hash.data_crc32 = None; + assert!(matches!( + bad_hash.verify_streaming_integrity(crc, Some((wrong_expected, hasher)), None), + Err(Error::HashMismatch { hash_type: 0 }) + )); + + let empty = plain_file(b"e.txt", b"", None); + empty + .verify_streaming_integrity(Crc32::new(), None, None) + .unwrap(); + } + + #[test] + fn write_repeated_chunk_updates_crc_hash_and_writer() { + let mut writer = Vec::new(); + let mut crc_zero = Crc32::new(); + let mut hash = Some(([0u8; 32], blake2sp::Hasher::new())); + write_repeated_chunk(&mut writer, &mut crc_zero, &mut hash, 0, 70_000).unwrap(); + assert_eq!(writer.len(), 70_000); + let zero_crc = crc_zero.finish(); + + let mut bytewise = Crc32::new(); + bytewise.update(&vec![0u8; 70_000]); + assert_eq!(zero_crc, bytewise.finish()); + + let mut writer = Vec::new(); + let mut crc_ff = Crc32::new(); + let mut hash_none: Option<([u8; 32], blake2sp::Hasher)> = None; + write_repeated_chunk(&mut writer, &mut crc_ff, &mut hash_none, 0xff, 1024).unwrap(); + assert_eq!(writer, vec![0xffu8; 1024]); + } + + #[test] + #[cfg(feature = "encryption")] + fn map_rar50_crypto_error_translates_kdf_count() { + assert!(matches!( + super::super::map_rar50_crypto_error(crate::crypto::rar50::Error::KdfCountTooLarge), + Error::UnsupportedFeature { .. } + )); + assert!(matches!( + super::super::map_rar50_crypto_error(crate::crypto::rar50::Error::BadPassword), + Error::WrongPasswordOrCorruptData + )); + } + + #[test] + fn constant_time_eq_returns_false_for_length_mismatch() { + assert!(!constant_time_eq(b"abc", b"abcd")); + assert!(constant_time_eq(b"abc", b"abc")); + assert!(!constant_time_eq(b"abc", b"abd")); + } + + fn stored_split_archive(data: &[u8], full: &[u8], crc: u32, flags: u64) -> Archive { + let source: Arc<[u8]> = Arc::from(data.to_vec().into_boxed_slice()); + Archive { + sfx_offset: 0, + main: MainHeader { + block: empty_block(1, 0, 0..0), + archive_flags: 0, + volume_number: None, + extras: Vec::new(), + encrypted_headers: false, + rewrite_metadata_complete: true, + }, + blocks: vec![Block::File(FileHeader { + block: empty_block(HEAD_FILE, flags, 0..data.len()), + file_flags: 0, + rewrite_metadata_complete: true, + unpacked_size: full.len() as u64, + attributes: 0x20, + mtime: None, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32: Some(crc), + compression_info: 0, + host_os: 2, + name: b"split.txt".to_vec(), + hash: Some(FileHash { + hash_type: 0, + data: blake2sp::hash(full).to_vec(), + }), + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + })], + source: ArchiveSource::Memory(source), + } + } + + fn empty_block( + header_type: u64, + flags: u64, + data_range: std::ops::Range, + ) -> BlockHeader { + BlockHeader { + header_crc: 0, + header_size: 0, + header_type, + flags, + extra_area_size: None, + data_size: Some(data_range.len() as u64), + offset: 0, + header_range: 0..0, + data_range, + } + } + + fn split_fragment_file(name: &[u8], hfl_flags: u64) -> FileHeader { + FileHeader { + block: empty_block(HEAD_FILE, hfl_flags, 0..0), + file_flags: 0, + rewrite_metadata_complete: true, + unpacked_size: 0, + attributes: 0x20, + mtime: None, + htime_mtime: None, + htime_mtime_refinement: None, + file_times: None, + data_crc32: None, + compression_info: 0, + host_os: 2, + name: name.to_vec(), + hash: None, + redirection: None, + service_data: None, + encrypted: false, + encryption: None, + crypto: None, + } + } + + fn archive_with_blocks(blocks: Vec, source: Vec) -> Archive { + let bytes: Arc<[u8]> = Arc::from(source.into_boxed_slice()); + Archive { + sfx_offset: 0, + main: MainHeader { + block: empty_block(1, 0, 0..0), + archive_flags: 0, + volume_number: None, + extras: Vec::new(), + encrypted_headers: false, + rewrite_metadata_complete: true, + }, + blocks, + source: ArchiveSource::Memory(bytes), + } + } + + fn never_open(_meta: &ExtractedEntryMeta) -> Result> { + panic!("open should not be invoked for this test"); + } + + #[test] + fn extract_volumes_to_rejects_volume_state_violations() { + let empty: Vec = Vec::new(); + assert!(matches!( + extract_volumes_to(&empty, crate::ArchiveReadOptions::default(), never_open), + Err(Error::InvalidHeader(_)) + )); + + let only_continuation = vec![archive_with_blocks( + vec![Block::File(split_fragment_file(b"a.txt", HFL_SPLIT_BEFORE))], + Vec::new(), + )]; + assert!(matches!( + extract_volumes_to( + &only_continuation, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + + let interrupted = vec![archive_with_blocks( + vec![ + Block::File(split_fragment_file(b"a.txt", HFL_SPLIT_AFTER)), + Block::File(plain_file(b"other.txt", b"", None)), + ], + Vec::new(), + )]; + assert!(matches!( + extract_volumes_to( + &interrupted, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + + let incomplete = vec![archive_with_blocks( + vec![Block::File(split_fragment_file(b"a.txt", HFL_SPLIT_AFTER))], + Vec::new(), + )]; + assert!(matches!( + extract_volumes_to( + &incomplete, + crate::ArchiveReadOptions::default(), + never_open, + ), + Err(Error::InvalidHeader(_)) + )); + } + + #[test] + fn validate_split_fragment_rejects_directories_and_demands_password_for_encrypted() { + let mut dir = split_fragment_file(b"d", HFL_SPLIT_AFTER); + dir.file_flags = 0x0001; + assert!(matches!( + validate_split_fragment(&dir, None), + Err(Error::InvalidHeader(_)) + )); + + let mut encrypted = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + encrypted.encrypted = true; + #[cfg(feature = "encryption")] + { + assert!(matches!( + validate_split_fragment(&encrypted, None), + Err(Error::NeedPassword) + )); + validate_split_fragment(&encrypted, Some(b"pw")).unwrap(); + } + #[cfg(not(feature = "encryption"))] + for password in [None, Some(b"pw".as_slice())] { + assert!(matches!( + validate_split_fragment(&encrypted, password), + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + } + + let plain = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + validate_split_fragment(&plain, None).unwrap(); + } + + #[test] + fn validate_split_continuation_refs_rejects_property_drift_between_fragments() { + let first = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + let pending = PendingSplitRefs::new(&first, 0, 0); + + let renamed = split_fragment_file(b"b.txt", HFL_SPLIT_BEFORE); + assert!(matches!( + validate_split_continuation_refs(&pending, &renamed, None), + Err(Error::InvalidHeader(_)) + )); + + let mut new_compression = split_fragment_file(b"a.txt", HFL_SPLIT_BEFORE); + new_compression.compression_info = 0x123; + assert!(matches!( + validate_split_continuation_refs(&pending, &new_compression, None), + Err(Error::InvalidHeader(_)) + )); + + let mut new_encryption = split_fragment_file(b"a.txt", HFL_SPLIT_BEFORE); + new_encryption.encrypted = true; + #[cfg(feature = "encryption")] + assert!(matches!( + validate_split_continuation_refs(&pending, &new_encryption, Some(b"pw")), + Err(Error::InvalidHeader(_)) + )); + #[cfg(not(feature = "encryption"))] + assert!(matches!( + validate_split_continuation_refs(&pending, &new_encryption, Some(b"pw")), + Err(Error::FeatureDisabled { + feature: "encryption" + }) + )); + + let same = split_fragment_file(b"a.txt", HFL_SPLIT_BEFORE); + validate_split_continuation_refs(&pending, &same, None).unwrap(); + } + + #[test] + fn extraction_modes_handle_directories_links_and_single_volume_splits() { + let mut directory = plain_file(b"dir", b"", None); + directory.file_flags = 1; + directory.compression_info = 5 << 7; + let mut link = plain_file(b"link", b"", None); + link.compression_info = 5 << 7; + link.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"dir".to_vec(), + }); + let archive = archive_with_blocks(vec![Block::File(directory), Block::File(link)], vec![]); + for parallel in [false, true] { + let mut opened = vec![]; + let options = crate::ArchiveReadOptions::new() + .with_rar50_dictionary_size_limit(0) + .with_max_member_output_bytes(0); + let mut open = |meta: &ExtractedEntryMeta| { + opened.push(meta.name.clone()); + assert!(meta.is_directory); + Ok(Box::new(std::io::sink()) as Box) + }; + if parallel { + archive.extract_to_parallel_buffered(options, &mut open) + } else { + extract_volumes_to(std::slice::from_ref(&archive), options, &mut open) + } + .unwrap(); + assert_eq!(opened, [b"dir".to_vec()]); + } + let mut select = |_: &crate::ArchiveMember| { + Ok(crate::ExtractionDecision::Extract( + Box::new(std::io::sink()), + )) + }; + let error = archive + .extract_controlled(crate::ArchiveReadOptions::new(), &mut select, None) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::UnsupportedFeature); + assert_eq!(error.entry_context().unwrap().0, b"link"); + + for flags in [HFL_SPLIT_BEFORE, HFL_SPLIT_AFTER] { + let archive = archive_with_blocks( + vec![Block::File(split_fragment_file(b"split", flags))], + vec![], + ); + let error = archive + .extract_to_parallel_buffered(crate::ArchiveReadOptions::new(), never_open) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::InvalidHeader("RAR 5 split entry requires multivolume extraction") + )); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_stored_split_checks_the_final_crc_mac() { + let data = b"Hello, RAR 5.0 fixture world.\n"; + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(0), + ) + .entry(entry(b"hello.txt", data).with_password(b"password".to_vec())) + .finish() + .unwrap(); + let archive = Archive::parse_with_password(&bytes, Some(b"password")).unwrap(); + let mut original = archive.files().next().unwrap().clone(); + assert!(original.uses_hash_mac()); + assert!(original.is_stored()); + // Exercise the CRC-only layout as well as the writer's default hash + // layout. The CRC is already MACed independently of its BLAKE2sp field. + original.hash = None; + let split = original.block.data_range.start + 13; + let mut first = original.clone(); + first.block.flags |= HFL_SPLIT_AFTER; + first.block.data_range.end = split; + first.block.data_size = Some(13); + first.data_crc32 = Some(crc32(&first.packed_data(&archive).unwrap())); + let mut last = original; + last.block.flags |= HFL_SPLIT_BEFORE; + last.block.data_range.start = split; + last.block.data_size = Some(last.block.data_range.len() as u64); + let mut volume1 = archive.clone(); + volume1.blocks = vec![Block::File(first)]; + let mut volume2 = archive; + volume2.blocks = vec![Block::File(last)]; + let captured = Rc::new(RefCell::new(Vec::new())); + struct Capture(Rc>>); + impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let mut volumes = [volume1, volume2]; + let options = crate::ArchiveReadOptions::with_password(b"password"); + extract_volumes_to(&volumes, options, |_| { + Ok(Box::new(Capture(captured.clone()))) + }) + .unwrap(); + assert_eq!( + captured.borrow().as_slice(), + b"Hello, RAR 5.0 fixture world.\n" + ); + let Block::File(last) = &mut volumes[1].blocks[0] else { + unreachable!() + }; + last.data_crc32 = Some(last.data_crc32.unwrap() ^ 1); + let error = + extract_volumes_to(&volumes, options, |_| Ok(Box::new(std::io::sink()))).unwrap_err(); + assert!(matches!(error.root_cause(), Error::Crc32Mismatch { .. })); + } + + #[test] + fn split_decode_failures_use_fragment_diagnostics_only_when_available() { + for crc in [None, Some(0), Some(1)] { + let mut first = split_fragment_file(b"truncated", HFL_SPLIT_AFTER); + first.compression_info = 5 << 7; + first.unpacked_size = 16; + first.data_crc32 = crc; + let mut last = first.clone(); + last.block.flags = HFL_SPLIT_BEFORE; + last.data_crc32 = None; + let volumes = [ + archive_with_blocks(vec![Block::File(first)], vec![]), + archive_with_blocks(vec![Block::File(last)], vec![]), + ]; + for limit in [0, 1024] { + let error = extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(limit), + |_| Ok(Box::new(std::io::sink())), + ) + .unwrap_err(); + if crc == Some(1) { + assert!(matches!( + error.root_cause(), + Error::Crc32Mismatch { + expected: 1, + actual: 0 + } + )); + } else { + assert!(matches!( + error.root_cause(), + Error::Codec(crate::codec::Error::NeedMoreInput) + )); + } + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_buffered_crc_verification_requires_keys_and_checks_mac() { + let data = b"MAC checked payload"; + let keys = Rar50Keys::derive(b"pw", [3; 16], 0).unwrap(); + let mut file = plain_file(b"encrypted", data, None); + file.encrypted = true; + file.encryption = Some(FileEncryption { + version: 0, + flags: 2, + kdf_count: 0, + salt: [3; 16], + iv: [4; 16], + check_value: None, + }); + file.data_crc32 = Some(keys.mac_crc32(crc32(data))); + assert!(matches!( + file.verify_integrity_with_keys(data, None), + Err(Error::InvalidHeader(_)) + )); + file.verify_integrity_with_keys(data, Some(&keys)).unwrap(); + assert!(matches!( + file.verify_integrity_with_keys(b"damaged", Some(&keys)), + Err(Error::Crc32Mismatch { .. }) + )); + file.block.data_range = 0..data.len(); + file.block.data_size = Some(data.len() as u64); + let archive = archive_with_blocks(vec![], data.to_vec()); + assert!(matches!( + file.packed_reader_with_password(&archive, Some(b"pw")), + Err(Error::InvalidHeader( + "RAR 5 encrypted file payload is not block aligned" + )) + )); + } + + #[test] + fn archive_extract_to_rejects_split_entries_in_single_volume_archive() { + let split = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + let archive = archive_with_blocks(vec![Block::File(split)], Vec::new()); + let err = archive + .extract_to(crate::ArchiveReadOptions::default(), never_open) + .unwrap_err(); + assert!( + matches!(err, Error::InvalidHeader(msg) if msg.contains("requires multivolume")), + "expected multivolume error, got {err:?}" + ); + } + + #[test] + fn archive_extract_to_skips_redirection_entries_without_opening_writer() { + let mut redirect = plain_file(b"link", b"", None); + redirect.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"target".to_vec(), + }); + let archive = archive_with_blocks(vec![Block::File(redirect)], Vec::new()); + archive + .extract_to( + crate::ArchiveReadOptions::default().with_rar50_dictionary_size_limit(0), + never_open, + ) + .unwrap(); + } + + #[test] + fn archive_extract_to_with_redirections_reports_redirection_entries() { + let mut redirect = plain_file(b"link", b"", None); + redirect.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"target".to_vec(), + }); + let archive = archive_with_blocks(vec![Block::File(redirect)], Vec::new()); + let mut seen = Vec::new(); + archive + .extract_to_with_redirections( + crate::ArchiveReadOptions::default(), + never_open, + |meta, redirection| { + seen.push((meta.name.clone(), redirection.target_name.clone())); + Ok(()) + }, + ) + .unwrap(); + + assert_eq!(seen, vec![(b"link".to_vec(), b"target".to_vec())]); + } + + #[test] + fn zero_total_allows_redirection_callbacks_in_regular_and_volume_extraction() { + let mut redirect = plain_file(b"link", b"", None); + // A metadata-only redirection's size placeholder must not consume quota + // or trigger the unknown logical file-size policy. + redirect.unpacked_size = u64::MAX; + redirect.file_flags |= 0x8; + redirect.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"target".to_vec(), + }); + let archive = archive_with_blocks(vec![Block::File(redirect)], Vec::new()); + let options = crate::ArchiveReadOptions::new().with_max_total_output_bytes(0); + for volumes in [false, true] { + let mut seen = 0; + let mut redirect = |_: &ExtractedEntryMeta, _: &FileRedirection| { + seen += 1; + Ok(()) + }; + if volumes { + extract_volumes_to_with_redirections( + std::slice::from_ref(&archive), + options, + never_open, + &mut redirect, + ) + .unwrap(); + } else { + archive + .extract_to_with_redirections(options, never_open, &mut redirect) + .unwrap(); + } + assert_eq!(seen, 1); + } + } + + #[test] + fn extract_volumes_to_skips_redirection_entries_without_opening_writer() { + let mut redirect = plain_file(b"link", b"", None); + redirect.redirection = Some(super::super::FileRedirection { + redirection_type: 1, + flags: 0, + target_name: b"target".to_vec(), + }); + let volumes = vec![archive_with_blocks(vec![Block::File(redirect)], Vec::new())]; + extract_volumes_to( + &volumes, + crate::ArchiveReadOptions::default().with_rar50_dictionary_size_limit(0), + never_open, + ) + .unwrap(); + } + + #[test] + fn extract_volumes_to_with_redirections_reports_redirection_entries() { + let mut redirect = plain_file(b"link", b"", None); + redirect.redirection = Some(super::super::FileRedirection { + redirection_type: 5, + flags: 0, + target_name: b"target".to_vec(), + }); + let volumes = vec![archive_with_blocks(vec![Block::File(redirect)], Vec::new())]; + let mut seen = Vec::new(); + extract_volumes_to_with_redirections( + &volumes, + crate::ArchiveReadOptions::default(), + never_open, + |meta, redirection| { + seen.push((meta.name.clone(), redirection.target_name.clone())); + Ok(()) + }, + ) + .unwrap(); + + assert_eq!(seen, vec![(b"link".to_vec(), b"target".to_vec())]); + } + + #[test] + fn pending_split_refs_write_stored_to_rejects_unpacked_size_mismatch() { + let payload: &[u8] = b"unmatched-size payload"; + let mut first = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + first.block.data_range = 0..payload.len(); + first.block.data_size = Some(payload.len() as u64); + first.unpacked_size = (payload.len() + 5) as u64; // mismatch + let final_file = first.clone(); + let pending = PendingSplitRefs::new(&first, 0, 0); + let volumes = vec![archive_with_blocks( + vec![Block::File(first)], + payload.to_vec(), + )]; + + let mut out: Vec = Vec::new(); + let err = pending + .write_stored_to(&volumes, &final_file, None, &mut out) + .unwrap_err(); + assert!( + matches!(err, Error::InvalidHeader(msg) if msg.contains("mismatched packed and unpacked")), + "expected size mismatch error, got {err:?}" + ); + } + + #[test] + fn pending_split_refs_write_stored_to_rejects_crc_mismatch_on_unencrypted() { + let payload: &[u8] = b"crc-mismatch payload"; + let mut first = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + first.block.data_range = 0..payload.len(); + first.block.data_size = Some(payload.len() as u64); + first.unpacked_size = payload.len() as u64; + first.data_crc32 = Some(crc32(payload).wrapping_add(1)); + let final_file = first.clone(); + let pending = PendingSplitRefs::new(&first, 0, 0); + let volumes = vec![archive_with_blocks( + vec![Block::File(first)], + payload.to_vec(), + )]; + + let mut out: Vec = Vec::new(); + let err = pending + .write_stored_to(&volumes, &final_file, None, &mut out) + .unwrap_err(); + assert!( + matches!(err, Error::Crc32Mismatch { .. }), + "expected CRC mismatch, got {err:?}" + ); + } + + #[test] + fn pending_split_refs_write_stored_to_rejects_hash_mismatch_on_unencrypted() { + let payload: &[u8] = b"hash-mismatch payload"; + let mut wrong_hash = blake2sp::hash(payload); + wrong_hash[0] ^= 0xff; + + let mut first = split_fragment_file(b"a.txt", HFL_SPLIT_AFTER); + first.block.data_range = 0..payload.len(); + first.block.data_size = Some(payload.len() as u64); + first.unpacked_size = payload.len() as u64; + first.data_crc32 = Some(crc32(payload)); + first.hash = Some(FileHash { + hash_type: 0, + data: wrong_hash.to_vec(), + }); + let final_file = first.clone(); + let pending = PendingSplitRefs::new(&first, 0, 0); + let volumes = vec![archive_with_blocks( + vec![Block::File(first)], + payload.to_vec(), + )]; + + let mut out: Vec = Vec::new(); + let err = pending + .write_stored_to(&volumes, &final_file, None, &mut out) + .unwrap_err(); + assert!( + matches!(err, Error::HashMismatch { hash_type: 0 }), + "expected hash mismatch, got {err:?}" + ); + } + + #[test] + fn decoded_data_unverified_returns_stored_payload_without_crc_check() { + let payload = b"decoded_data_unverified stored payload"; + let mut file = plain_file(b"a.txt", payload, None); + file.block.data_range = 0..payload.len(); + file.block.data_size = Some(payload.len() as u64); + file.unpacked_size = payload.len() as u64; + // Set wrong CRC — unverified path must not check it. + file.data_crc32 = Some(crc32(payload).wrapping_add(1)); + + let archive = archive_with_blocks(vec![Block::File(file.clone())], payload.to_vec()); + let decoded = file.decoded_data_unverified(&archive, None).unwrap(); + assert_eq!(decoded, payload); + } + + #[test] + fn decoded_data_unverified_accepts_empty_compressed_member() { + for crc in [None, Some(0)] { + let mut file = plain_file(b"empty.txt", b"", None); + file.compression_info = 5 << 7; + file.data_crc32 = crc; + let archive = archive_with_blocks(vec![Block::File(file.clone())], Vec::new()); + assert!(file + .decoded_data_unverified(&archive, None) + .unwrap() + .is_empty()); + for parallel in [false, true] { + let open = |_: &ExtractedEntryMeta| Ok(Box::new(std::io::sink()) as Box); + let result = if parallel { + archive.extract_to_parallel_buffered(crate::ArchiveReadOptions::default(), open) + } else { + archive.extract_to(crate::ArchiveReadOptions::default(), open) + }; + result.unwrap(); + } + } + // An empty logical member with a present stream must still validate + // that stream rather than taking the omitted-stream shortcut. + let mut file = plain_file(b"empty-with-stream.txt", b"", None); + file.compression_info = 5 << 7; + file.block.data_range = 0..1; + file.block.data_size = Some(1); + let archive = archive_with_blocks(vec![Block::File(file.clone())], vec![0]); + assert!(matches!( + file.decoded_data_unverified(&archive, None), + Err(Error::Codec(_)) + )); + } + + #[test] + fn dictionary_limit_checks_declared_sizes_before_opening_output() { + for info in [5 << 7, (5 << 7) | 1 | (3 << 15), (5 << 7) | (15 << 10)] { + let mut file = plain_file(b"limited", b"", None); + file.compression_info = info; + let required = file.decoded_compression_info().unwrap().dictionary_size; + for solid in [false, true] { + file.compression_info = info | if solid { 0x40 } else { 0 }; + let archive = archive_with_blocks(vec![Block::File(file.clone())], Vec::new()); + for limit in [None, Some(required), Some(required - 1), Some(0)] { + for parallel in [false, true] { + let options = crate::ArchiveReadOptions { + rar50_dictionary_size_limit: limit, + ..Default::default() + }; + let mut opened = false; + let open = |_: &ExtractedEntryMeta| { + opened = true; + Ok(Box::new(std::io::sink()) as Box) + }; + let result = if parallel { + archive.extract_to_parallel_buffered(options, open) + } else { + archive.extract_to(options, open) + }; + if let Some(limit) = limit.filter(|limit| *limit < required) { + let error = result.unwrap_err(); + assert!(!opened); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert!( + matches!(error.root_cause(), Error::Rar50DictionaryLimitExceeded { + limit: actual, required: size + } if *actual == limit && *size == required) + ); + assert_eq!(error.entry_context().unwrap().0, b"limited"); + } else { + result.unwrap(); + assert!(opened); + } + } + } + } + } + } + + #[test] + fn truncated_checksumless_members_fail_in_buffered_and_streaming_extraction() { + // A compressed member advertises output, but its packed stream is + // truncated to nothing. Without integrity records, decoding itself + // must still establish success; an empty result is not a substitute. + let mut file = plain_file(b"truncated", b"", None); + file.compression_info = 5 << 7; + file.unpacked_size = 16; + file.data_crc32 = None; + file.hash = None; + let archive = archive_with_blocks(vec![Block::File(file)], Vec::new()); + for limit in [0, 1024] { + let options = + crate::ArchiveReadOptions::default().with_rar50_buffered_decode_limit(limit); + for parallel in [false, true] { + let open = |_: &ExtractedEntryMeta| Ok(Box::new(std::io::sink()) as Box); + let result = if parallel { + archive.extract_to_parallel_buffered(options, open) + } else { + archive.extract_to(options, open) + }; + let error = result.expect_err("truncated member must not succeed"); + assert!(matches!( + error.root_cause(), + Error::Codec(crate::codec::Error::NeedMoreInput) + )); + } + } + } + + #[test] + fn encryption_iv_falls_back_to_encryption_record_and_errors_when_missing() { + let mut with_record = plain_file(b"a.txt", b"", None); + with_record.encrypted = true; + with_record.encryption = Some(FileEncryption { + version: 0, + flags: 0, + kdf_count: 0, + salt: [0u8; 16], + iv: [5u8; 16], + check_value: None, + }); + assert_eq!(with_record.encryption_iv().unwrap(), [5u8; 16]); + + let missing = plain_file(b"a.txt", b"", None); + assert!(matches!( + missing.encryption_iv(), + Err(Error::InvalidHeader(_)) + )); + } +} + +#[cfg(all(test, feature = "write"))] +#[path = "independent_history_tests.rs"] +mod independent_history_tests; diff --git a/arca-rar/vendor/rars/src/rar50/framing.rs b/arca-rar/vendor/rars/src/rar50/framing.rs new file mode 100644 index 00000000..a91ce9b2 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/framing.rs @@ -0,0 +1,173 @@ +//! Header framing shared by writers and recovery repair. + +#[cfg(feature = "encryption")] +use super::map_rar50_crypto_error; +use super::HFL_EXTRA; +#[cfg(feature = "encryption")] +use crate::crypto::rar50::Rar50Cipher; +use crate::crypto::rar50::Rar50Keys; +use crate::{crc32::crc32, Error, Result}; + +/// Bounded framing scratch; callers choose capacities from the on-disk fields. +pub(crate) struct HeaderScratch { + bytes: [u8; N], + len: usize, +} + +impl HeaderScratch { + pub(crate) fn new() -> Self { + Self { + bytes: [0; N], + len: 0, + } + } + pub(crate) fn extend_from_slice(&mut self, bytes: &[u8]) { + self.bytes[self.len..self.len + bytes.len()].copy_from_slice(bytes); + self.len += bytes.len(); + } + pub(crate) fn vint(&mut self, mut value: u64) { + loop { + self.extend_from_slice(&[(value as u8 & 0x7f) | if value >= 0x80 { 0x80 } else { 0 }]); + value >>= 7; + if value == 0 { + break; + } + } + } + pub(crate) fn as_slice(&self) -> &[u8] { + &self.bytes[..self.len] + } + pub(crate) fn len(&self) -> usize { + self.len + } +} + +impl std::ops::Deref for HeaderScratch { + type Target = [u8]; + fn deref(&self) -> &[u8] { + self.as_slice() + } +} + +pub(crate) fn image_size_error() -> Error { + Error::InvalidArgument("RAR 5 header size overflows") +} + +pub(crate) fn checked_image_len(parts: &[usize]) -> Result { + let len = parts + .iter() + .try_fold(0usize, |total, &size| total.checked_add(size)) + .ok_or_else(image_size_error)?; + if len > isize::MAX as usize { + return Err(image_size_error()); + } + Ok(len) +} + +/// Computes framing without copying variable-length fields. All header paths +/// render into their final allocation, including IV, padding and trailing data. +pub(crate) struct HeaderImage<'a> { + prefix: HeaderScratch<40>, + size: HeaderScratch<10>, + specific: &'a [u8], + extra: &'a [u8], + plain_len: usize, +} + +impl<'a> HeaderImage<'a> { + pub(crate) fn new( + kind: u64, + flags: u64, + data_size: Option, + specific: &'a [u8], + extra: &'a [u8], + ) -> Result { + let mut prefix = HeaderScratch::new(); + prefix.vint(kind); + prefix.vint(flags); + if flags & HFL_EXTRA != 0 { + prefix.vint(extra.len() as u64); + } + if let Some(data_size) = data_size { + prefix.vint(data_size); + } + let body_len = checked_image_len(&[prefix.len(), specific.len(), extra.len()])?; + let mut size = HeaderScratch::new(); + size.vint(body_len as u64); + let plain_len = checked_image_len(&[4, size.len(), body_len])?; + Ok(Self { + prefix, + size, + specific, + extra, + plain_len, + }) + } + + pub(crate) fn header_len(&self, encrypted: bool) -> Result { + if encrypted { + let padded = self + .plain_len + .checked_add(15) + .ok_or_else(image_size_error)? + & !15; + checked_image_len(&[16, padded]) + } else { + Ok(self.plain_len) + } + } + + pub(crate) fn image_len(&self, encrypted: bool, data_len: usize) -> Result { + checked_image_len(&[self.header_len(encrypted)?, data_len]) + } + + /// Render into a zeroed buffer of exactly `image_len` bytes. Allocation and + /// admission belong to the caller; salts, framing and encryption are shared. + pub(crate) fn render_into( + &self, + keys: Option<&Rar50Keys>, + data: &[u8], + out: &mut [u8], + ) -> Result<()> { + if keys.is_some() { + crate::crypto::require_encryption()?; + } + let header_len = self.header_len(keys.is_some())?; + let start = if keys.is_some() { 16 } else { 0 }; + let mut offset = start + 4; + for part in [ + self.size.as_slice(), + self.prefix.as_slice(), + self.specific, + self.extra, + ] { + out[offset..offset + part.len()].copy_from_slice(part); + offset += part.len(); + } + let crc = crc32(&out[start + 4..start + self.plain_len]); + out[start..start + 4].copy_from_slice(&crc.to_le_bytes()); + if let Some(keys) = keys { + #[cfg(not(feature = "encryption"))] + { + let _ = keys; + return Err(Error::FeatureDisabled { + feature: "encryption", + }); + } + #[cfg(feature = "encryption")] + { + let mut iv = [0; 16]; + crate::entropy::fill_entropy( + &mut iv, + "RAR 5 writer could not generate encryption IV", + )?; + out[..16].copy_from_slice(&iv); + Rar50Cipher::new(keys.key, iv) + .encrypt_in_place(&mut out[16..header_len]) + .map_err(map_rar50_crypto_error)?; + } + } + out[header_len..].copy_from_slice(data); + Ok(()) + } +} diff --git a/arca-rar/vendor/rars/src/rar50/independent_history_tests.rs b/arca-rar/vendor/rars/src/rar50/independent_history_tests.rs new file mode 100644 index 00000000..8a9e3735 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/independent_history_tests.rs @@ -0,0 +1,374 @@ +use super::super::{ArchiveEntry, Block, FilterKind, FilterPolicy, Rar50Writer, WriterOptions}; +use super::*; +use crate::{ArchiveVersion, FeatureSet}; +use std::cell::RefCell; +use std::rc::Rc; +use std::sync::Arc; + +type ExtractedFiles = Vec<(Vec, Vec)>; + +fn entry(name: &[u8], data: &[u8]) -> ArchiveEntry { + ArchiveEntry::new( + name.to_vec(), + crate::EntrySource::from_bytes(Arc::<[u8]>::from(data.to_vec())), + ) +} +#[derive(Clone)] +struct Sink(Rc>>); +impl Write for Sink { + fn write(&mut self, data: &[u8]) -> std::io::Result { + self.0.borrow_mut().extend_from_slice(data); + Ok(data.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} +fn archive(version: ArchiveVersion, filter: Option) -> (Archive, Vec) { + let data = b"independent buffered dictionary filter member repeated bytes\n".repeat(64); + let mut writer = Rar50Writer::new( + WriterOptions::new(version, FeatureSet::store_only()) + .with_compression_level(1) + .with_dictionary_size(if version == ArchiveVersion::Rar70 { + 192 * 1024 + } else { + 128 * 1024 + }), + ) + .entries([entry(b"first", &data), entry(b"second", &data)]); + if let Some(filter) = filter { + writer = writer.filter_policy(FilterPolicy::Explicit(crate::FilterSpec::whole(filter))); + } + let bytes = writer.finish().unwrap(); + let archive = Archive::parse_owned(bytes).unwrap(); + assert!(!archive.main.is_solid()); + assert!(archive.files().all(|file| !file.is_stored() + && !file.is_split_before() + && !file.is_split_after() + && !file.decoded_compression_info().unwrap().solid)); + assert!(archive.files().all(|file| { + file.decoded_compression_info().unwrap().algorithm_version + == u8::from(version == ArchiveVersion::Rar70) + })); + assert!(archive.files().all(|file| file + .hash + .as_ref() + .is_some_and(|hash| hash.hash_type == 0 && hash.data.len() == 32))); + (archive, data) +} +fn extract( + archive: &Archive, + parallel: bool, + options: crate::ArchiveReadOptions<'_>, +) -> (std::result::Result<(), String>, ExtractedFiles) { + let mut writers = Vec::new(); + let mut open = |meta: &ExtractedEntryMeta| { + let data = Rc::new(RefCell::new(Vec::new())); + writers.push((meta.name.clone(), data.clone())); + Ok(Box::new(Sink(data)) as Box) + }; + let result = if parallel { + archive.extract_to_parallel_buffered(options, &mut open) + } else { + archive.extract_to(options, &mut open) + }; + ( + result.map_err(|error| format!("{error:?}")), + writers + .into_iter() + .map(|(name, data)| (name, data.borrow().clone())) + .collect(), + ) +} +#[test] +fn independent_history_public_extraction_keeps_all_filter_bytes_and_bounded_routes() { + for version in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for filter in [ + None, + Some(FilterKind::Delta { channels: 2 }), + Some(FilterKind::E8), + Some(FilterKind::E8E9), + Some(FilterKind::Arm), + ] { + let (archive, data) = archive(version, filter); + for limit in [None, Some(64 * 1024 * 1024)] { + let mut options = + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(u64::MAX); + options.max_reader_workspace_bytes = limit; + let expected = extract(&archive, false, options); + let actual = extract(&archive, true, options); + assert_eq!(actual, expected); + assert!(actual.0.is_ok()); + assert_eq!( + actual.1, + [ + (b"first".to_vec(), data.clone()), + (b"second".to_vec(), data.clone()) + ] + ); + } + } + } +} +#[test] +fn independent_history_verification_keeps_only_the_ordered_verified_prefix() { + for filter in [None, Some(FilterKind::Delta { channels: 2 })] { + for hash_failure in [false, true] { + let (mut archive, data) = archive(ArchiveVersion::Rar50, filter); + for block in &mut archive.blocks { + if let Block::File(file) = block { + if file.name == b"second" { + if hash_failure { + file.hash.as_mut().unwrap().data[0] ^= 1; + } else { + file.hash = None; + file.data_crc32 = Some(0); + } + } + } + } + let options = + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(u64::MAX); + let expected = extract(&archive, false, options); + let actual = extract(&archive, true, options); + assert_eq!(actual.0, expected.0); + assert!(actual.0.as_ref().unwrap_err().contains(if hash_failure { + "HashMismatch" + } else { + "Crc32Mismatch" + })); + assert_eq!(actual.1, [(b"first".to_vec(), data.clone())]); + // Existing sequential direct sinks open before verification; + // independent publication opens only the verified prefix. + assert_eq!( + expected.1, + [(b"first".to_vec(), data), (b"second".to_vec(), Vec::new())] + ); + } + } +} + +#[cfg(feature = "encryption")] +#[test] +fn independent_history_encrypted_digest_and_password_errors_match_stateful_decode() { + let data = b"encrypted independent Delta and BLAKE2sp MAC bytes\n".repeat(64); + for filter in [None, Some(FilterKind::Delta { channels: 2 })] { + let mut writer = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1), + ) + .entry(entry(b"encrypted", &data).with_password(b"password".to_vec())); + if let Some(filter) = filter { + writer = writer.filter_policy(FilterPolicy::Explicit(crate::FilterSpec::whole(filter))); + } + let bytes = writer.finish().unwrap(); + let archive = Archive::parse_owned(bytes).unwrap(); + assert!(archive + .files() + .all(|file| file.encrypted && !file.is_stored() && file.hash.is_some())); + for password in [ + None, + Some(b"wrong".as_slice()), + Some(b"password".as_slice()), + ] { + let mut options = + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(u64::MAX); + options.password = password; + let expected = extract(&archive, false, options); + let actual = extract(&archive, true, options); + assert_eq!(actual.0, expected.0); + if password == Some(b"password".as_slice()) { + assert!(actual.0.is_ok()); + assert_eq!(actual.1, expected.1); + assert_eq!(actual.1, [(b"encrypted".to_vec(), data.clone())]); + } else { + assert!(actual.0.is_err()); + assert!(actual.1.is_empty()); + } + } + } +} + +fn entry_result( + value: Result>, +) -> std::result::Result<(String, Vec), String> { + value + .map(|entry| match entry { + ParallelExtractedEntry::File { meta, data } => (format!("{meta:?}"), data.to_vec()), + ParallelExtractedEntry::Directory(meta) | ParallelExtractedEntry::Verified(meta) => { + (format!("{meta:?}"), Vec::new()) + } + ParallelExtractedEntry::Redirection { meta, redirection } => { + (format!("{meta:?} {redirection:?}"), Vec::new()) + } + }) + .map_err(|error| format!("{error:?}")) +} +#[test] +fn independent_history_worker_limited_keeps_original_attempts_callbacks_and_errors() { + use crate::codec::workspace::RefusingBudget; + for filter in [None, Some(FilterKind::Delta { channels: 2 })] { + let (archive, _) = archive(ArchiveVersion::Rar50, filter); + let file = archive.files().next().unwrap(); + let options = crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(u64::MAX); + let baseline = RefusingBudget::new(usize::MAX); + drop( + reference_decode_parallel_entry(&archive, file, None, u64::MAX, options, &baseline) + .unwrap(), + ); + assert_eq!(baseline.used(), 0); + for fail_at in 0..=baseline.attempts() { + for cancelled in [false, true] { + let old = RefusingBudget::new(fail_at); + let actual = RefusingBudget::new(fail_at); + let old_token = crate::ReadCancellation::new(); + let actual_token = crate::ReadCancellation::new(); + // Use identical upfront cancellation, plus the decoder-level + // checkpoint controls in codec/history_retention_tests.rs. + if cancelled { + old_token.cancel(); + actual_token.cancel(); + } + let mut old_options = options; + old_options.cancellation = Some(&old_token); + let mut actual_options = options; + actual_options.cancellation = Some(&actual_token); + let expected = entry_result(reference_decode_parallel_entry( + &archive, + file, + None, + u64::MAX, + old_options, + &old, + )); + let output = entry_result(decode_parallel_entry_with_allowance( + &archive, + file, + None, + u64::MAX, + actual_options, + false, + &actual, + )); + assert_eq!(output, expected, "filter={filter:?}, fail_at={fail_at}"); + assert_eq!(actual.attempts(), old.attempts()); + assert_eq!(actual.used(), 0); + assert_eq!(old.used(), 0); + assert_eq!(actual_token.is_cancelled(), old_token.is_cancelled()); + } + } + } +} + +#[test] +fn independent_history_public_stream_and_scratch_fallbacks_keep_existing_results() { + let dir = crate::scratch::case("independent-history-fallbacks"); + let scratch = crate::Rar50Scratch::new(&*dir, 64 * 1024); + for filter in [None, Some(FilterKind::Delta { channels: 2 })] { + let (archive, data) = archive(ArchiveVersion::Rar50, filter); + for use_scratch in [false, true] { + let mut options = crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(1); + if use_scratch { + options.rar50_scratch = Some(&scratch); + } + let expected = extract(&archive, false, options); + let actual = extract(&archive, true, options); + assert_eq!(actual, expected); + if filter.is_some() && !use_scratch { + assert!(actual + .0 + .as_ref() + .unwrap_err() + .contains("Rar50BufferedDecodeLimitExceeded")); + } else { + assert!(actual.0.is_ok()); + assert_eq!( + actual.1, + [ + (b"first".to_vec(), data.clone()), + (b"second".to_vec(), data.clone()) + ] + ); + } + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + } + } +} + +#[test] +fn independent_history_late_publication_cancellation_keeps_the_verified_prefix() { + let (archive, data) = archive( + ArchiveVersion::Rar50, + Some(FilterKind::Delta { channels: 2 }), + ); + for parallel in [false, true] { + let token = crate::ReadCancellation::new(); + let mut options = + crate::ArchiveReadOptions::new().with_rar50_buffered_decode_limit(u64::MAX); + options.cancellation = Some(&token); + let mut writers = Vec::new(); + let mut open = |meta: &ExtractedEntryMeta| { + let bytes = Rc::new(RefCell::new(Vec::new())); + writers.push((meta.name.clone(), bytes.clone())); + if meta.name == b"second" { + token.cancel(); + } + Ok(Box::new(Sink(bytes)) as Box) + }; + let error = if parallel { + archive.extract_to_parallel_buffered(options, &mut open) + } else { + archive.extract_to(options, &mut open) + } + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled); + let output: Vec<_> = writers + .into_iter() + .map(|(name, bytes)| { + let data = bytes.borrow().clone(); + (name, data) + }) + .collect(); + assert_eq!( + output, + [ + (b"first".to_vec(), data.clone()), + (b"second".to_vec(), Vec::new()) + ] + ); + } +} + +// Original d2 private-worker pipeline, independent of the history selection. +fn reference_decode_parallel_entry( + archive: &Archive, + file: &FileHeader, + password: Option<&[u8]>, + buffered_decode_limit: u64, + options: crate::ArchiveReadOptions<'_>, + allowance: &B, +) -> Result> { + options.check_cancelled()?; + let mut budget = crate::output_limit::OutputBudget::new(options); + file.check_dictionary_limit(options.rar50_dictionary_size_limit)?; + file.check_output_limit(&budget)?; + if let Some(redirection) = &file.redirection { + return Ok(ParallelExtractedEntry::Redirection { + meta: file.metadata(), + redirection: redirection.clone(), + }); + } + // The only caller dispatches workers after excluding split members. + let meta = file.metadata(); + if meta.is_directory { + return Ok(ParallelExtractedEntry::Directory(meta)); + } + let mut data = Buffer::new(allowance); + let mut session = DecoderSession::with_allowance(password, buffered_decode_limit, allowance); + session.decoder.read_control = budget.control.clone(); + session.scratch = options.rar50_scratch; + budget.run(&file.name, &mut data, |writer| { + session.write_file_to(archive, file, writer) + })?; + Ok(ParallelExtractedEntry::File { meta, data }) +} diff --git a/arca-rar/vendor/rars/src/rar50/scratch.rs b/arca-rar/vendor/rars/src/rar50/scratch.rs new file mode 100644 index 00000000..5fd6181c --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/scratch.rs @@ -0,0 +1,387 @@ +use super::*; +use crate::codec::rar50::{apply_filter_data_with_allowance, FilterType, PendingFilter}; +use crate::temp_file::TemporaryFile; +use std::cell::RefCell; +use std::io::{Seek, SeekFrom}; +use std::rc::Rc; + +struct DiskBudget { + used: u64, + limit: u64, +} +struct ScratchFile { + spool: TemporaryFile, + budget: Rc>, + pos: u64, + len: u64, +} + +impl ScratchFile { + fn create(policy: &crate::Rar50Scratch, budget: &Rc>) -> Result { + Ok(Self { + spool: TemporaryFile::create(&policy.directory)?, + budget: budget.clone(), + pos: 0, + len: 0, + }) + } + fn rewind(&mut self) -> Result<()> { + self.seek(SeekFrom::Start(0))?; + Ok(()) + } +} +impl Read for ScratchFile { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + let count = self.spool.read(bytes)?; + self.pos += count as u64; + Ok(count) + } +} +impl Write for ScratchFile { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + // Decoder output and admitted record writes are bounded before dispatch; + // filter overwrites stay within their validated payload range. + let end = self.pos + bytes.len() as u64; + let mut budget = self.budget.borrow_mut(); + let additional = end.saturating_sub(self.len); + if additional > budget.limit - budget.used { + return Err(std::io::Error::other(Error::Rar50ScratchLimitExceeded { + limit: budget.limit, + required: budget.used.saturating_add(additional), + })); + } + let count = self.spool.write(bytes)?; + self.pos += count as u64; + budget.used += self.pos.saturating_sub(self.len); + self.len = self.len.max(self.pos); + Ok(count) + } + fn flush(&mut self) -> std::io::Result<()> { + self.spool.flush() + } +} +impl Seek for ScratchFile { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.pos = self.spool.seek(from)?; + Ok(self.pos) + } +} + +fn copy( + source: &mut ScratchFile, + mut destination: &mut dyn Write, + control: &crate::read_control::ReadControl, +) -> Result<()> { + source.rewind()?; + let mut buffer = [0; 64 * 1024]; + loop { + control.check()?; + let count = source.read(&mut buffer)?; + if count == 0 { + break; + } + control.write_all(&mut destination, &buffer[..count])?; + } + control.check() +} + +fn verify( + file: &FileHeader, + data: &mut ScratchFile, + keys: Option<&Rar50Keys>, + control: &crate::read_control::ReadControl, +) -> Result<()> { + data.rewind()?; + let mut crc = Crc32::new(); + let mut hash = streaming_hash_verifier(file)?; + let mut buffer = [0; 64 * 1024]; + loop { + control.check()?; + let count = data.read(&mut buffer)?; + if count == 0 { + break; + } + crc.update(&buffer[..count]); + if let Some((_, hasher)) = &mut hash { + hasher.update(&buffer[..count]); + } + } + file.verify_streaming_integrity(crc, hash, keys) +} + +fn encode_filter(filter: PendingFilter) -> [u8; 24] { + let mut bytes = [0; 24]; + bytes[..8].copy_from_slice(&(filter.start as u64).to_le_bytes()); + bytes[8..16].copy_from_slice(&(filter.length as u64).to_le_bytes()); + bytes[16] = match filter.filter_type { + FilterType::Delta => 0, + FilterType::E8 => 1, + FilterType::E8E9 => 2, + FilterType::Arm => 3, + }; + bytes[17] = filter.channels as u8; + bytes +} + +fn decode_filter( + bytes: [u8; 24], + output_size: usize, + filter_memory_limit: u64, +) -> Result { + let start = usize::try_from(u64::from_le_bytes(bytes[..8].try_into().unwrap())) + .map_err(|_| Error::InvalidHeader("scratch filter offset overflows"))?; + let length = usize::try_from(u64::from_le_bytes(bytes[8..16].try_into().unwrap())) + .map_err(|_| Error::InvalidHeader("scratch filter length overflows"))?; + let filter_type = match bytes[16] { + 0 => FilterType::Delta, + 1 => FilterType::E8, + 2 => FilterType::E8E9, + 3 => FilterType::Arm, + _ => return Err(Error::InvalidHeader("scratch filter type changed")), + }; + let required = (length as u64).saturating_mul(2); + if required > filter_memory_limit { + return Err(Error::Rar50FilterMemoryLimitExceeded { + limit: filter_memory_limit, + required, + }); + } + if start + .checked_add(length) + .is_none_or(|end| end > output_size) + { + return Err(Error::InvalidHeader("scratch filter range exceeds output")); + } + Ok(PendingFilter { + start, + length, + filter_type, + channels: bytes[17] as usize, + }) +} + +pub(super) fn decode( + file: &FileHeader, + packed: &mut R, + keys: Option<&Rar50Keys>, + decoder: &mut ReaderState, + policy: &crate::Rar50Scratch, + writer: &mut dyn Write, +) -> Result<()> { + if cfg!(all(target_arch = "wasm32", target_os = "unknown")) { + return Err(Error::UnsupportedFamilyFeature { + family: crate::ArchiveFamily::Rar50Plus, + feature: "disk-backed reader scratch on bare WebAssembly", + }); + } + let control = decoder.read_control.clone(); + control.check()?; + // Reserve the known payload storage before creating any temporary files. + let required = file + .unpacked_size + .checked_mul(2) + .ok_or(Error::Rar50ScratchLimitExceeded { + limit: policy.max_bytes, + required: u64::MAX, + })?; + if required > policy.max_bytes { + return Err(Error::Rar50ScratchLimitExceeded { + limit: policy.max_bytes, + required, + }); + } + let payload_reservation = required; + let budget = Rc::new(RefCell::new(DiskBudget { + used: 0, + limit: policy.max_bytes, + })); + let mut raw = ScratchFile::create(policy, &budget)?; + let mut records = ScratchFile::create(policy, &budget)?; + let info = file.decoded_compression_info()?; + let output_size = checked_unpacked_size(file.unpacked_size)?; + let dictionary_size = usize::try_from(info.dictionary_size) + .map_err(|_| Error::InvalidHeader("RAR 5 dictionary size overflows host address size"))?; + decoder + .decode_to_sink_with_filters( + packed, + info.algorithm_version, + output_size, + dictionary_size, + info.solid, + |chunk| -> Result<()> { + control.check()?; + match chunk { + DecodedChunk::Bytes(bytes) => raw.write_all(bytes)?, + DecodedChunk::Repeated { byte, len } => { + let buffer = [byte; 64 * 1024]; + let mut remaining = len; + while remaining != 0 { + control.check()?; + let count = remaining.min(buffer.len()); + raw.write_all(&buffer[..count])?; + remaining -= count; + } + } + } + Ok(()) + }, + Some(&mut |filter: PendingFilter| -> Result<()> { + control.check()?; + let required = (filter.length as u64).saturating_mul(2); + if required > policy.filter_memory_limit { + return Err(Error::Rar50FilterMemoryLimitExceeded { + limit: policy.filter_memory_limit, + required, + }); + } + // Records may arrive before payload bytes: retain the payload + // reservation rather than letting records spend that space. + let disk_required = payload_reservation + .checked_add(records.len) + .and_then(|bytes| bytes.checked_add(24)) + .ok_or(Error::Rar50ScratchLimitExceeded { + limit: policy.max_bytes, + required: u64::MAX, + })?; + if disk_required > policy.max_bytes { + return Err(Error::Rar50ScratchLimitExceeded { + limit: policy.max_bytes, + required: disk_required, + }); + } + records.write_all(&encode_filter(filter))?; + Ok(()) + }), + ) + .map_err(|error| match error { + StreamDecodeError::Decode(error) => Error::from(error), + StreamDecodeError::Sink(error) => error, + StreamDecodeError::FilteredMember => unreachable!("scratch supplies a filter handler"), + })?; + if records.len == 0 { + verify(file, &mut raw, keys, &control)?; + return copy(&mut raw, writer, &control); + } + let mut transformed = ScratchFile::create(policy, &budget)?; + copy(&mut raw, &mut transformed, &control)?; + records.rewind()?; + while records.pos < records.len { + control.check()?; + let mut bytes = [0; 24]; + records.read_exact(&mut bytes)?; + // These bytes came back from disk. Revalidate them before allocating + // or seeking, even though the codec admitted the original record. + let filter = decode_filter(bytes, output_size, policy.filter_memory_limit)?; + transformed.seek(SeekFrom::Start(filter.start as u64))?; + let mut data = Buffer::filled(filter.length, 0, &decoder.allowance())?; + control.reader(&mut transformed).read_exact(&mut data)?; + apply_filter_data_with_allowance(&mut data, &filter, &control, &decoder.allowance())?; + transformed.seek(SeekFrom::Start(filter.start as u64))?; + control.write_all(&mut transformed, &data)?; + } + verify(file, &mut transformed, keys, &control)?; + copy(&mut transformed, writer, &control) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn scratch_files_share_disk_quota_and_overwrites_do_not_spend_it_twice() { + let dir = crate::scratch::case("reader-scratch-shared-quota"); + let policy = crate::Rar50Scratch::new(&*dir, 8); + let budget = Rc::new(RefCell::new(DiskBudget { used: 0, limit: 8 })); + { + let mut first = ScratchFile::create(&policy, &budget).unwrap(); + let mut second = ScratchFile::create(&policy, &budget).unwrap(); + first.write_all(b"abcd").unwrap(); + second.write_all(b"efgh").unwrap(); + first.rewind().unwrap(); + first.write_all(b"ABCD").unwrap(); + first.flush().unwrap(); + assert_eq!(budget.borrow().used, 8); + let error = second.write_all(b"i").unwrap_err(); + assert!(matches!( + error.get_ref().unwrap().downcast_ref::(), + Some(Error::Rar50ScratchLimitExceeded { + limit: 8, + required: 9 + }) + )); + first.rewind().unwrap(); + let mut data = Vec::new(); + first.read_to_end(&mut data).unwrap(); + assert_eq!(data, b"ABCD"); + } + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + } + + #[test] + fn scratch_filter_records_reject_corrupt_tags_and_preserve_offsets() { + for filter_type in [ + FilterType::Delta, + FilterType::E8, + FilterType::E8E9, + FilterType::Arm, + ] { + let filter = PendingFilter { + start: usize::MAX - 17, + length: 17, + filter_type, + channels: 3, + }; + let mut bytes = encode_filter(filter); + let decoded = decode_filter(bytes, usize::MAX, 34).unwrap(); + assert_eq!(decoded.start, filter.start); + assert_eq!(decoded.length, filter.length); + assert_eq!(decoded.filter_type, filter.filter_type); + assert_eq!(decoded.channels, filter.channels); + bytes[16] = 4; + assert!(matches!( + decode_filter(bytes, usize::MAX, 34), + Err(Error::InvalidHeader("scratch filter type changed")) + )); + bytes[16] = 0; + bytes[8..16].copy_from_slice(&18u64.to_le_bytes()); + assert!(matches!( + decode_filter(bytes, usize::MAX, 34), + Err(Error::Rar50FilterMemoryLimitExceeded { + limit: 34, + required: 36 + }) + )); + bytes[8..16].copy_from_slice(&17u64.to_le_bytes()); + bytes[..8].copy_from_slice(&(usize::MAX as u64).to_le_bytes()); + assert!(matches!( + decode_filter(bytes, usize::MAX, 34), + Err(Error::InvalidHeader("scratch filter range exceeds output")) + )); + bytes[..8].copy_from_slice(&1u64.to_le_bytes()); + assert!(matches!( + decode_filter(bytes, 17, 34), + Err(Error::InvalidHeader("scratch filter range exceeds output")) + )); + } + + if usize::BITS < 64 { + let mut bytes = encode_filter(PendingFilter { + start: 0, + length: 1, + filter_type: FilterType::Delta, + channels: 1, + }); + bytes[..8].copy_from_slice(&u64::MAX.to_le_bytes()); + assert!(matches!( + decode_filter(bytes, usize::MAX, u64::MAX), + Err(Error::InvalidHeader("scratch filter offset overflows")) + )); + bytes[..8].copy_from_slice(&0u64.to_le_bytes()); + bytes[8..16].copy_from_slice(&u64::MAX.to_le_bytes()); + assert!(matches!( + decode_filter(bytes, usize::MAX, u64::MAX), + Err(Error::InvalidHeader("scratch filter length overflows")) + )); + } + } +} diff --git a/arca-rar/vendor/rars/src/rar50/streaming_checks_tests.rs b/arca-rar/vendor/rars/src/rar50/streaming_checks_tests.rs new file mode 100644 index 00000000..52caf3d4 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/streaming_checks_tests.rs @@ -0,0 +1,531 @@ +use super::*; +use crate::rar50::{ + ArchiveEntry, Block, FileHash, FilterPolicy, Rar50Writer, WriterOptions, HFL_SPLIT_AFTER, + HFL_SPLIT_BEFORE, +}; +use crate::{ArchiveVersion, EntrySource, FeatureSet}; +use std::cell::Cell; + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +struct Work { + bytes: usize, + zeroes: usize, + repeated_bytes: usize, + repeated_zeroes: usize, +} + +std::thread_local! { + static WORK: Cell = const { Cell::new(Work { + bytes: 0, zeroes: 0, repeated_bytes: 0, repeated_zeroes: 0, + }) }; +} + +pub(super) fn record_crc_work(len: usize, zeroes: bool) { + WORK.with(|work| { + let mut value = work.get(); + if zeroes { + value.zeroes += len; + } else { + value.bytes += len; + } + work.set(value); + }); +} + +pub(super) fn record_repeated_output(len: usize, zeroes: bool) { + WORK.with(|work| { + let mut value = work.get(); + value.repeated_bytes += len; + if zeroes { + value.repeated_zeroes += len; + } + work.set(value); + }); +} + +fn measured(run: impl FnOnce() -> T) -> (T, Work) { + WORK.with(|work| work.set(Work::default())); + let value = run(); + (value, WORK.with(Cell::get)) +} + +fn fixture(data: &[u8], stored: bool, encrypted: bool) -> (Archive, FileHeader) { + let mut input = ArchiveEntry::new(b"payload".to_vec(), EntrySource::from_bytes(data.to_vec())); + if encrypted { + input = input.with_password(b"password".to_vec()); + } + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(if stored { 0 } else { 1 }) + .with_dictionary_size(128 * 1024), + ) + .entry(input) + .filter_policy(FilterPolicy::None) + .finish() + .unwrap(); + let archive = Archive::parse_with_password(&bytes, Some(b"password")).unwrap(); + let file = archive.files().next().unwrap().clone(); + assert_eq!(file.is_stored(), stored); + (archive, file) +} + +fn ordinary(archive: &Archive, file: &FileHeader) -> (Result>, Work) { + measured(|| { + let mut session = + DecoderSession::with_allowance(Some(b"password"), 0, &Allowance::default()); + let mut output = Vec::new(); + session.write_file_to(archive, file, &mut output)?; + Ok(output) + }) +} + +#[test] +fn ordinary_streaming_skips_crc_work_only_when_integrity_does_not_use_it() { + let data = b"ordinary streaming integrity bytes\n".repeat(4096); + for stored in [false, true] { + let (archive, original) = fixture(&data, stored, false); + for layout in ["hash", "none", "crc", "unknown"] { + let mut file = original.clone(); + match layout { + "hash" => file.data_crc32 = Some(crc32(&data) ^ 1), + "none" => { + file.data_crc32 = None; + file.hash = None; + } + "crc" => file.hash = None, + "unknown" => { + file.hash = Some(FileHash { + hash_type: 7, + data: vec![1], + }); + } + _ => unreachable!(), + } + let (result, work) = ordinary(&archive, &file); + assert_eq!(result.unwrap(), data); + assert_eq!( + work.bytes + work.zeroes, + if matches!(layout, "crc" | "unknown") { + data.len() + } else { + 0 + }, + "stored={stored}, layout={layout}, work={work:?}", + ); + } + } +} + +#[test] +fn optional_repeated_output_keeps_hash_and_real_zero_run_delivery() { + let data = vec![0; 200 * 1024]; + let (archive, mut file) = fixture(&data, false, false); + file.data_crc32 = Some(1); + let (result, work) = ordinary(&archive, &file); + assert_eq!(result.unwrap(), data); + assert!( + work.repeated_zeroes > 64 * 1024, + "must use actual codec zero runs" + ); + assert_eq!(work.bytes + work.zeroes, 0, "{work:?}"); +} + +#[test] +fn optional_repeated_output_preserves_nonzero_hash_and_sink_failure_order() { + let data = vec![0xff; 140_000]; + let mut output = Vec::new(); + let expected = blake2sp::hash(&data); + let mut hash = Some((expected, blake2sp::Hasher::new())); + let (result, work) = measured(|| { + write_repeated_chunk_with_optional_crc(&mut output, None, &mut hash, 0xff, data.len()) + }); + result.unwrap(); + assert_eq!(output, data); + assert_eq!(hash.unwrap().1.finalize(), expected); + assert_eq!(work.bytes + work.zeroes, 0); + assert_eq!(work.repeated_bytes, data.len()); + + let mut crc = Crc32::new(); + let mut hash = Some((expected, blake2sp::Hasher::new())); + let (result, work) = + measured(|| write_repeated_chunk(&mut RejectWrite, &mut crc, &mut hash, 0, 100_000)); + assert!(result.is_err()); + assert_eq!(crc.finish(), Crc32::new().finish()); + assert_eq!(hash.unwrap().1.finalize(), blake2sp::hash(b"")); + assert_eq!(work, Work::default()); +} + +#[test] +fn ordinary_streaming_keeps_checksum_authority_and_malformed_hash_precedence() { + let data = b"checksum authority\n".repeat(8192); + for stored in [false, true] { + let (archive, original) = fixture(&data, stored, false); + for layout in ["bad hash", "bad crc", "unknown hash", "malformed hash"] { + let mut file = original.clone(); + match layout { + "bad hash" => file.hash.as_mut().unwrap().data[0] ^= 1, + "bad crc" => { + file.hash = None; + file.data_crc32 = Some(crc32(&data) ^ 1); + } + "unknown hash" => { + file.hash = Some(FileHash { + hash_type: 99, + data: vec![1], + }); + file.data_crc32 = Some(crc32(&data) ^ 1); + } + "malformed hash" => { + file.hash.as_mut().unwrap().data.pop(); + file.data_crc32 = Some(crc32(&data) ^ 1); + } + _ => unreachable!(), + } + let (result, work) = ordinary(&archive, &file); + let error = result.unwrap_err(); + match layout { + "bad hash" => { + assert!(matches!( + error.root_cause(), + Error::HashMismatch { hash_type: 0 } + )); + assert_eq!(work.bytes + work.zeroes, 0); + } + "bad crc" | "unknown hash" => { + assert!(matches!(error.root_cause(), Error::Crc32Mismatch { .. })); + assert_eq!(work.bytes + work.zeroes, data.len()); + } + "malformed hash" => { + assert!(matches!( + error.root_cause(), + Error::InvalidHeader("RAR 5 BLAKE2sp hash record has invalid length") + )); + assert_eq!(work, Work::default()); + } + _ => unreachable!(), + } + } + } +} + +struct RejectWrite; +impl Write for RejectWrite { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::other("ordinary streaming sink failed")) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +#[test] +fn ordinary_streaming_preserves_sink_error_context_before_hash_failure() { + let data = b"sink failure must precede final checksum\n".repeat(4096); + for stored in [false, true] { + let (archive, mut file) = fixture(&data, stored, false); + file.hash.as_mut().unwrap().data[0] ^= 1; + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + let (result, work) = measured(|| session.write_file_to(&archive, &file, &mut RejectWrite)); + let error = result.unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context().unwrap().1, + if stored { "writing" } else { "decoding" }, + ); + assert_eq!(work.bytes + work.zeroes, 0); + } +} + +#[test] +#[cfg(feature = "encryption")] +fn ordinary_encrypted_streaming_preserves_crc_mac_hash_mac_padding_and_truncation() { + let data = b"encrypted MAC payload!".repeat(4097); + for stored in [false, true] { + let (archive, original) = fixture(&data, stored, true); + assert!(original.uses_hash_mac()); + let (result, work) = ordinary(&archive, &original); + assert_eq!(result.unwrap(), data); + assert_eq!(work.bytes + work.zeroes, 0); + let mut crc_only = original.clone(); + crc_only.hash = None; + let (result, work) = ordinary(&archive, &crc_only); + assert_eq!(result.unwrap(), data); + assert_eq!(work.bytes + work.zeroes, data.len()); + crc_only.data_crc32 = Some(crc_only.data_crc32.unwrap() ^ 1); + assert!(matches!( + ordinary(&archive, &crc_only).0.unwrap_err().root_cause(), + Error::Crc32Mismatch { .. }, + )); + let mut bad_hash = original.clone(); + bad_hash.hash.as_mut().unwrap().data[0] ^= 1; + assert!(matches!( + ordinary(&archive, &bad_hash).0.unwrap_err().root_cause(), + Error::HashMismatch { hash_type: 0 }, + )); + let mut truncated = original.clone(); + truncated.block.data_range.end -= 1; + truncated.block.data_size = Some(truncated.block.data_range.len() as u64); + let error = ordinary(&archive, &truncated).0.unwrap_err(); + // Compare the complete legacy path, including reader admission. + // Shortening the declared cipher payload fails its alignment check + // before either stored or compressed decoding can read it. + let mut decoder = ReaderState::new(&Allowance::default()); + let expected = (|| { + let (mut packed, keys) = truncated.packed_reader_with_allowance( + &archive, + Some(b"password"), + &Allowance::default(), + )?; + truncated.stream_packed_with_decoder( + &mut packed, + keys.as_ref(), + &mut decoder, + 0, + None, + &mut std::io::sink(), + ) + })() + .unwrap_err(); + assert_eq!(error.root_cause(), expected.root_cause()); + assert!(matches!( + expected.root_cause(), + Error::InvalidHeader("RAR 5 encrypted file payload is not block aligned") + )); + if stored { + let mut padding = bad_hash; + padding.unpacked_size -= 1; + let error = ordinary(&archive, &padding).0.unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::InvalidHeader("RAR 5 encrypted stored file has non-zero padding") + )); + } + } +} + +#[test] +fn ordinary_streaming_admission_and_source_open_precede_malformed_hash() { + let dir = crate::scratch::case("ordinary-streaming-precedence"); + let path = dir.join("removed.rar"); + for stored in [false, true] { + let data = b"header resource admission".repeat(4096); + let (original, _) = fixture(&data, stored, false); + let crate::source::ArchiveSource::Memory(bytes) = &original.source else { + unreachable!() + }; + std::fs::write(&path, bytes).unwrap(); + let mut archive = Archive::parse_path(&path).unwrap(); + std::fs::remove_file(&path).unwrap(); + let Block::File(file) = archive + .blocks + .iter_mut() + .find(|b| matches!(b, Block::File(_))) + .unwrap() + else { + unreachable!() + }; + file.hash.as_mut().unwrap().data.pop(); + let mut opened = 0; + let limit = data.len() as u64 - 1; + for options in [ + crate::ArchiveReadOptions::new().with_max_member_output_bytes(limit), + crate::ArchiveReadOptions::new().with_max_total_output_bytes(limit), + ] { + let error = archive + .extract_to(options.with_rar50_buffered_decode_limit(0), |_| { + opened += 1; + Ok(Box::new(std::io::sink()) as Box) + }) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + } + assert_eq!(opened, 0); + let file = archive.files().next().unwrap(); + if !stored { + let error = archive + .extract_to( + crate::ArchiveReadOptions::new() + .with_rar50_buffered_decode_limit(0) + .with_rar50_dictionary_size_limit(0), + |_| { + opened += 1; + Ok(Box::new(std::io::sink()) as Box) + }, + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(opened, 0); + } + let (result, work) = ordinary(&archive, file); + let error = result.unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!(work, Work::default()); + } +} + +#[test] +fn split_compressed_members_retain_always_crc_work() { + let data = b"split compressed hash and crc\n".repeat(8192); + let (archive, original) = fixture(&data, false, false); + let middle = original.block.data_range.start + original.packed_size() as usize / 2; + let mut first = original.clone(); + first.block.flags |= HFL_SPLIT_AFTER; + first.block.data_range.end = middle; + first.block.data_size = Some(first.block.data_range.len() as u64); + let mut last = original; + last.block.flags |= HFL_SPLIT_BEFORE; + last.block.data_range.start = middle; + last.block.data_size = Some(last.block.data_range.len() as u64); + last.data_crc32 = Some(1); // Its valid BLAKE remains authoritative. + let mut volume1 = archive.clone(); + volume1.blocks = vec![Block::File(first.clone())]; + let mut volume2 = archive; + volume2.blocks = vec![Block::File(last.clone())]; + let volumes = [volume1, volume2]; + let mut split = PendingSplitRefs::with_allowance(&first, 0, 0, &Allowance::default()).unwrap(); + split.append(1, 0).unwrap(); + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + let mut output = Vec::new(); + let (result, work) = + measured(|| session.stream_split_to(&volumes, &split, &last, None, &mut output)); + result.unwrap(); + assert_eq!(output, data); + assert_eq!(work.bytes + work.zeroes, data.len()); +} + +#[test] +fn optional_crc_policy_keeps_scratch_dispatch_before_hash_initialization() { + let dir = crate::scratch::case("ordinary-streaming-scratch-policy"); + let policy = crate::Rar50Scratch::new(&*dir, 1024 * 1024); + let data = b"scratch route bytes\n".repeat(4096); + let (archive, mut file) = fixture(&data, false, false); + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + session.scratch = Some(&policy); + let mut output = Vec::new(); + session.write_file_to(&archive, &file, &mut output).unwrap(); + assert_eq!(output, data); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + file.hash.as_mut().unwrap().data.pop(); + file.block.data_range.end = file.block.data_range.start; + file.block.data_size = Some(0); + let error = session + .write_file_to(&archive, &file, &mut std::io::sink()) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + Error::Codec(crate::codec::Error::NeedMoreInput) + )); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); +} + +#[test] +fn optional_crc_keeps_limited_growth_and_refusals_identical_to_legacy_streaming() { + use crate::codec::workspace::RefusingBudget; + let data = b"limited CRC policy bytes\n".repeat(4096); + let (archive, file) = fixture(&data, false, false); + let run = |budget: &RefusingBudget, optional| { + let mut session = DecoderSession::with_allowance(None, 0, budget); + let mut output = Buffer::new(budget); + if optional { + session.write_file_to(&archive, &file, &mut output)?; + } else { + let mut decoder = session.decoder.try_clone()?; + let (mut packed, keys) = file.packed_reader_with_allowance(&archive, None, budget)?; + file.stream_packed_with_decoder( + &mut packed, + keys.as_ref(), + &mut decoder, + 0, + None, + &mut output, + )?; + } + assert_eq!(&output[..], &data); + Ok::<(), Error>(()) + }; + let baseline = RefusingBudget::new(usize::MAX); + run(&baseline, false).unwrap(); + let attempts = baseline.attempts(); + assert!(attempts > 0); + assert_eq!(baseline.used(), 0); + for fail_at in 0..=attempts { + let old = RefusingBudget::new(fail_at); + let new = RefusingBudget::new(fail_at); + let expected = run(&old, false); + let actual = run(&new, true); + assert_eq!( + actual.as_ref().err().map(Error::kind), + expected.as_ref().err().map(Error::kind), + "allocation {fail_at}" + ); + assert_eq!(new.attempts(), old.attempts(), "allocation {fail_at}"); + assert_eq!(new.used(), 0); + assert_eq!(old.used(), 0); + } +} + +#[test] +fn optional_crc_preserves_bad_hash_checkpoint_for_a_history_dependent_successor() { + let mut random = 0x1234_5678u32; + let seed: Vec<_> = (0..32749) + .map(|_| { + random ^= random << 13; + random ^= random >> 17; + random ^= random << 5; + random as u8 + }) + .collect(); + let first = seed.repeat(4); + let next = first[127..4224].to_vec(); + let mut builder = crate::Builder::new(ArchiveVersion::Rar50) + .store(false) + .solid(true) + .compression_level(Some(1)); + builder + .add_bytes(b"first".to_vec(), first, None, None) + .unwrap(); + builder + .add_bytes(b"next".to_vec(), next.clone(), None, None) + .unwrap(); + let archive = Archive::parse_owned(builder.to_bytes().unwrap()).unwrap(); + let files: Vec<_> = archive.files().collect(); + assert!(files[1].decoded_compression_info().unwrap().solid); + assert!( + files[1].packed_size() < 128, + "successor must use predecessor history" + ); + + let different = b"failed member replaces the old raw dictionary\n".repeat(4096); + let (failed_archive, valid) = fixture(&different, false, false); + let mut corrupt = valid.clone(); + corrupt.hash.as_mut().unwrap().data[0] ^= 1; + let mut session = DecoderSession::with_allowance(None, 0, &Allowance::default()); + session + .write_file_to(&archive, files[0], &mut std::io::sink()) + .unwrap(); + let (result, work) = + measured(|| session.write_file_to(&failed_archive, &corrupt, &mut std::io::sink())); + assert!(matches!( + result.unwrap_err().root_cause(), + Error::HashMismatch { hash_type: 0 } + )); + assert_eq!( + work.bytes + work.zeroes, + 0, + "bad digest does not change hash authority" + ); + let mut output = Vec::new(); + session + .write_file_to(&archive, files[1], &mut output) + .unwrap(); + assert_eq!(output, next); + + // Prove a mistakenly committed failed dictionary cannot pass the fixture. + session + .write_file_to(&failed_archive, &valid, &mut std::io::sink()) + .unwrap(); + let error = session + .write_file_to(&archive, files[1], &mut std::io::sink()) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ChecksumMismatch); +} diff --git a/arca-rar/vendor/rars/src/rar50/write/compress.rs b/arca-rar/vendor/rars/src/rar50/write/compress.rs new file mode 100644 index 00000000..8d68f48a --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/compress.rs @@ -0,0 +1,3235 @@ +//! Turning member sources into packed payloads with workspace admission. +//! +//! RAR 5 compresses in independent blocks: a block depends only on its own +//! bytes and on up to a dictionary's worth of the raw input that precedes it. +//! Since that preceding input is just the file being read, the history a block +//! needs is known before any compression happens, and blocks can be compressed +//! in parallel while their packed output is written back in order. +//! +//! Non-solid members each carry their own history and are interleaved so that +//! several small members keep every core busy. Solid members share one history +//! chain that runs across member boundaries, so their blocks are produced by a +//! single walk through the members in order — the walk is just reading, which +//! is cheap, so waves of blocks still compress in parallel. + +#[cfg(test)] +use super::filter_policy::encode_member_with_filter_policy_candidates_and_progress; +use super::filter_policy::{ + candidates_with_allowance, compression_info, should_store_compressed_payload, +}; +use super::FilterPolicy; +#[cfg(test)] +use crate::codec::rar50::EncodeOptions; +use crate::codec::rar50::{streaming_blocks_with_allowance, BlockSplitter}; +use crate::codec::workspace::{Allowance, Budget, Buffer}; +use crate::crc32::Crc32; +use crate::rar50::blake2sp; +use crate::streaming::preparation::Records; +use crate::streaming::Spool; +use crate::{EntrySource, Error, Result, WriterResources}; +use std::io::{Read, Write}; +use std::sync::atomic::{AtomicBool, Ordering}; + +/// Compression work and member lifecycle, independent of presentation. +pub(super) trait CompressionProgress: Sync { + fn advance(&self, bytes: u64) -> bool; + fn is_cancelled(&self) -> bool { + false + } + fn started(&self, _member: usize, _size: u64) {} + fn finished(&self, _member: usize, _size: u64) {} +} +impl bool + Sync> CompressionProgress for F { + fn advance(&self, bytes: u64) -> bool { + self(bytes) + } +} + +/// Batch-local cancellation joins already admitted workers and prevents queued +/// work from opening a source after a sibling has failed. The caller's token is +/// never changed, so the same resources can be reused after an ordinary error. +struct BatchProgress<'a> { + progress: &'a dyn CompressionProgress, + resources: &'a WriterResources, + stopped: AtomicBool, +} +impl CompressionProgress for BatchProgress<'_> { + fn advance(&self, bytes: u64) -> bool { + if self.is_cancelled() { + return false; + } + if !self.progress.advance(bytes) { + self.stopped.store(true, Ordering::Release); + return false; + } + !self.is_cancelled() + } + fn is_cancelled(&self) -> bool { + self.stopped.load(Ordering::Acquire) + || self.resources.is_cancelled() + || self.progress.is_cancelled() + } + fn started(&self, member: usize, size: u64) { + self.progress.started(member, size); + } + fn finished(&self, member: usize, size: u64) { + self.progress.finished(member, size); + } +} + +/// Slots are admitted before dispatch. Both input and result descriptor storage +/// stay owned until all callbacks join, even if one callback fails. The caller +/// retains its workspace reservation through consumption of returned results. +fn run_jobs( + jobs: Records, + resources: &WriterResources, + progress: &dyn CompressionProgress, + map: impl Fn(T, &dyn CompressionProgress) -> Result + Sync + Send, +) -> Result> { + let output = Records::new(jobs.len(), resources)?; + let slots = Records::collect(jobs.into_iter().map(|job| Ok((Some(job), None))), resources)?; + complete_jobs(slots, output, resources, progress, |_, job, progress| { + map(job, progress) + }) +} + +type JobSlot = (Option, Option>); + +fn complete_jobs( + mut slots: Records>, + mut output: Records, + resources: &WriterResources, + progress: &dyn CompressionProgress, + map: impl Fn(usize, T, &dyn CompressionProgress) -> Result + Sync + Send, +) -> Result> { + let batch = BatchProgress { + progress, + resources, + stopped: AtomicBool::new(false), + }; + crate::parallel::for_each_mut(&mut slots, |index, (job, result)| { + if batch.is_cancelled() { + return; + } + let mapped = map(index, job.take().expect("one callback per slot"), &batch); + if mapped.is_err() { + batch.stopped.store(true, Ordering::Release); + } + *result = Some(mapped); + }); + // Prefer the source/codec failure over cancellation caused by that failure. + // Scan in job order, so scheduling does not choose which error we report. + let mut failure = None; + for (_, result) in slots.iter_mut() { + if result.as_ref().is_some_and(Result::is_err) { + let error = result.take().unwrap().err().unwrap(); + if failure + .as_ref() + .is_none_or(|error: &Error| error.kind() == crate::ErrorKind::Cancelled) + { + failure = Some(error); + } + } + } + if let Some(error) = failure { + return Err(error); + } + if batch.is_cancelled() { + return Err(Error::Cancelled); + } + for (_, result) in slots { + output.push(result.expect("all jobs completed")?)?; + } + Ok(output) +} + +/// Admit fixed worker scopes only after coordinator slots have capacity. Keep +/// every reservation until all callbacks join, then retire unused capacity; +/// output owners remain charged after return. No worker can extend its scope. +fn run_jobs_admitted( + jobs: Records, + resources: &WriterResources, + progress: &dyn CompressionProgress, + required: impl Fn(&T) -> u64, + map: impl Fn( + T, + &WriterResources, + &dyn CompressionProgress, + &crate::codec::workspace::Limited, + ) -> Result + + Sync + + Send, +) -> Result> { + let ledger = resources + .execution + .as_ref() + .expect("admitted execution ledger"); + let output = Records::new(jobs.len(), resources)?; + let slots = Records::collect(jobs.into_iter().map(|job| Ok((Some(job), None))), resources)?; + let mut reservations = Records::new(slots.len(), resources)?; + for (job, _) in slots.iter() { + if progress.is_cancelled() || resources.is_cancelled() { + return Err(Error::Cancelled); + } + reservations.push(ledger.reserve(required(job.as_ref().unwrap()))?)?; + } + for reservation in reservations.iter_mut() { + reservation.start(); + } + let result = complete_jobs( + slots, + output, + resources, + progress, + |index, job, progress| { + let allowance = reservations[index].allowance(); + let worker = resources + .clone() + .with_execution_allowance(allowance.clone()); + map(job, &worker, progress, &allowance) + }, + ); + for reservation in reservations { + reservation.retire(); + } + result +} + +/// A member that has been compressed and is waiting to be framed. +pub(super) struct CompressedMember { + pub(super) input_size: u64, + pub(super) crc32: u32, + pub(super) hash: [u8; 32], + pub(super) packed: Spool, + /// True when the payload should be written as-is from the source because + /// compressing it did not pay. + pub(super) store: bool, + /// True when this member continues the previous member's dictionary. + pub(super) solid_continuation: bool, +} + +#[cfg(test)] +use super::plan::whole_member_workspace; +pub(super) use super::plan::CompressPlan; +use super::plan::{Execution, ExecutionPlan, MemberPlan}; + +/// A bounded run of adjacent blocks, sharing one copy of the preceding input. +struct BlockJob { + data: Buffer, + history: Buffer, + /// Member index, end within `data`, and final-block flag. + blocks: Records<(usize, usize, bool)>, +} + +impl BlockJob { + fn append(&mut self, data: Buffer) -> Result<()> { + if self.data.is_empty() { + self.data = data; + } else { + self.data + .extend_from_slice(&data) + .map_err(Into::::into)?; + } + Ok(()) + } +} + +fn run_size(plan: &CompressPlan) -> usize { + plan.encode_options + .max_match_distance + .max(crate::codec::rar50::MAX_LZ_BLOCK_SIZE) +} + +/// A member being read, and the packed bytes it has produced so far. +struct MemberStream { + member: usize, + input_size: u64, + started: bool, + source: EntrySource, + reader: Option>, + remaining: u64, + packed: Spool, + /// A chunk read to decide a block boundary and not used by that block. + pushback: Buffer, + crc: Crc32, + hash: blake2sp::Hasher, +} + +impl MemberStream { + fn new( + member: usize, + source: &EntrySource, + size: u64, + resources: &WriterResources, + progress: &dyn CompressionProgress, + allowance: &B, + ) -> Result { + if size == 0 { + progress.started(member, size); + if progress.is_cancelled() { + return Err(Error::Cancelled); + } + check_source_end(&mut *source.open()?)?; + progress.finished(member, size); + } + Ok(Self { + member, + input_size: size, + started: size == 0, + source: source.clone(), + reader: None, + remaining: size, + packed: Spool::create_parked(resources)?, + pushback: Buffer::new(allowance), + crc: Crc32::new(), + hash: blake2sp::Hasher::new(), + }) + } + + /// Whether this member has anything left, read or unread. + fn has_more(&self) -> bool { + self.remaining != 0 || !self.pushback.is_empty() + } +} + +/// `advance` is called with each newly completed chunk of work and returns +/// false when the caller wants to stop. +pub(super) fn compress_members_with_context( + sources: &[EntrySource], + plan: &CompressPlan, + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result> { + if advance.is_cancelled() || resources.is_cancelled() { + return Err(Error::Cancelled); + } + let mut integrity = Records::new(sources.len(), resources)?; + for (index, source) in sources.iter().enumerate() { + let input_size = source.len().map_err(|error| error_context(index, error))?; + // Compression fills these checksums while consuming the source. + integrity.push((input_size, 0, [0; 32]))?; + } + + let execution = + ExecutionPlan::with_resources(plan, integrity.iter().map(|entry| entry.0), resources)?; + let packed = match execution { + ExecutionPlan::IndependentMembers(members) => { + return compress_members_whole( + sources, + &integrity, + plan, + &members, + resources, + advance, + error_context, + ); + } + // Storing is not "compress and hope it does not help": the header + // records method zero, so the payload must be the source bytes. + ExecutionPlan::Stored => { + for (index, (source, (input_size, crc, hash))) in + sources.iter().zip(&mut integrity).enumerate() + { + advance.started(index, *input_size); + (*crc, *hash) = super::source_integrity( + source, + *input_size, + plan.block_size, + advance, + resources, + ) + .map_err(|error| error_context(index, error))?; + if !advance.advance(*input_size) { + return Err(Error::Cancelled); + } + advance.finished(index, *input_size); + } + Records::collect( + integrity.iter().map(|_| Spool::create_parked(resources)), + resources, + )? + } + ExecutionPlan::Blocks { workspace } => compress_streaming_members( + sources, + &mut integrity, + plan, + workspace, + resources, + advance, + error_context, + )?, + }; + + Records::collect( + packed.into_iter().zip(&integrity).enumerate().map( + |(member, (packed, &(input_size, crc32, hash)))| { + Ok(CompressedMember { + input_size, + crc32, + hash, + // One rule, shared with the whole-member path and the legacy + // writers, plus the two cases that are not really fallbacks: + // storing was asked for, and an empty member has nothing to + // pack. `StoreFallback` refuses to store a solid member, whose + // successors decode against the dictionary it fills. + store: plan.method == 0 + || input_size == 0 + || should_store_compressed_payload( + input_size, + packed.len(), + plan.solid, + &plan.filter_policy, + ), + packed, + solid_continuation: plan.solid && member > 0, + }) + }, + ), + resources, + ) +} + +#[allow(clippy::too_many_arguments)] +fn compress_streaming_members( + sources: &[EntrySource], + integrity: &mut [(u64, u32, [u8; 32])], + plan: &CompressPlan, + required: u64, + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result> { + let max_jobs_by_memory = resources.memory_limit() / required; + if max_jobs_by_memory == 0 { + resources + .acquire_cancellable(required, plan.dictionary_size, &|| advance.is_cancelled())?; + unreachable!("oversized workspace acquisition must fail"); + } + let batch_capacity = usize::try_from(max_jobs_by_memory) + .unwrap_or(usize::MAX) + .min(crate::parallel::threads()) + .max(1); + + if let Some(allowance) = &resources.execution { + let encode = if plan.solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + return encode( + sources, + integrity, + plan, + batch_capacity, + required, + resources, + advance, + error_context, + allowance, + ); + } + + if plan.solid { + compress_solid_chain( + sources, + integrity, + plan, + batch_capacity, + required, + resources, + advance, + error_context, + &Allowance::default(), + ) + } else { + compress_independent_members( + sources, + integrity, + plan, + batch_capacity, + required, + resources, + advance, + error_context, + &Allowance::default(), + ) + } +} + +/// Keep estimated codec admission separate from actual coordinator capacity. +/// Assembly runs on the coordinator; workers receive only their fixed scopes. +/// Retained history and spool capacity reduce the next wave's available space. +fn streaming_wave_capacity( + maximum: usize, + _required: u64, + _plan: &CompressPlan, + _resources: &WriterResources, +) -> usize { + if let Some(ledger) = &_resources.execution { + // Run growth/replacement, block assembly and history copies coexist. + // Descriptor capacity is still checked by its owners before dispatch. + let assembly = (run_size(_plan) as u64) + .saturating_mul(8) + .saturating_add((_plan.block_size as u64).saturating_mul(4)); + let per_job = _required + .saturating_add(assembly) + .saturating_add(crate::codec::workspace::RESERVATION_BYTES); + return maximum + .min(usize::try_from(ledger.available() / per_job.max(1)).unwrap_or(usize::MAX)) + .max(1); + } + maximum +} + +/// Compresses independent whole members concurrently, with each workspace +/// admitted against the shared budget before its input is loaded. +/// +/// The resolved plan schedules automatic-filter fallback outside whole-member +/// batches. Explicit filters retain their whole-member requirement and fail +/// admission when their workspace exceeds the budget. +#[allow(clippy::too_many_arguments)] +fn compress_members_whole( + sources: &[EntrySource], + integrity: &[(u64, u32, [u8; 32])], + plan: &CompressPlan, + members: &[MemberPlan], + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result> { + let mut results = Records::new(sources.len(), resources)?; + let mut start = 0; + while start < sources.len() { + if advance.is_cancelled() || resources.is_cancelled() { + return Err(Error::Cancelled); + } + if members[start].execution != Execution::WholeMember { + results + .push( + compress_fallback_member( + start, + &sources[start], + integrity[start], + plan, + members[start].workspace, + resources, + advance, + error_context, + ) + .map_err(|error| error_context(start, error))?, + ) + .expect("one compression result per source was admitted"); + start += 1; + continue; + } + let (end, reserved) = whole_member_wave( + members, + start, + crate::parallel::threads(), + resources.memory_limit(), + ); + let (end, reserved) = if let Some(ledger) = &resources.execution { + let slot_bytes = std::mem::size_of::() + + std::mem::size_of::() + + std::mem::size_of::>() + + std::mem::size_of::(); + whole_member_wave_with_slots( + members, + start, + crate::parallel::threads(), + resources.memory_limit(), + slot_bytes as u64 + crate::codec::workspace::RESERVATION_BYTES, + ledger.available(), + ) + } else { + (end, reserved) + }; + // Acquire the entire wave on the coordinator. No dispatched worker + // waits for workspace held by another worker in the same pool. + let _permit = resources + .acquire_cancellable(reserved, plan.dictionary_size, &|| advance.is_cancelled()) + .map_err(|error| error_context(start, error))?; + let jobs = Records::collect((start..end).map(Ok), resources)?; + let unlimited = |jobs| { + run_jobs(jobs, resources, advance, |index, progress| { + compress_whole_member( + index, + &sources[index], + integrity[index], + plan, + resources, + progress, + &Allowance::default(), + ) + .map_err(|error| error_context(index, error)) + }) + }; + let completed = if resources.execution.is_some() { + run_jobs_admitted( + jobs, + resources, + advance, + |index| members[*index].workspace, + |index, worker, progress, allowance| { + compress_whole_member( + index, + &sources[index], + integrity[index], + plan, + worker, + progress, + allowance, + ) + .map_err(|error| error_context(index, error)) + }, + )? + } else { + unlimited(jobs)? + }; + for member in completed { + results.push(member)?; + } + start = end; + } + Ok(results) +} + +/// A contiguous wave fitting both the configured estimate and the worker count. +/// Include an oversized first job so admission reports its real requirement. +fn whole_member_wave( + members: &[MemberPlan], + start: usize, + threads: usize, + limit: u64, +) -> (usize, u64) { + whole_member_wave_with_slots(members, start, threads, limit, 0, u64::MAX) +} + +fn whole_member_wave_with_slots( + members: &[MemberPlan], + start: usize, + max_jobs: usize, + limit: u64, + slot_bytes: u64, + capacity: u64, +) -> (usize, u64) { + let mut reserved = members[start].workspace; + let mut end = start + 1; + while end < members.len() && end - start < max_jobs.max(1) { + if members[end].execution != Execution::WholeMember { + break; + } + let Some(total) = reserved.checked_add(members[end].workspace) else { + break; + }; + if total > limit + || total.saturating_add(slot_bytes.saturating_mul((end - start + 1) as u64)) > capacity + { + break; + } + reserved = total; + end += 1; + } + (end, reserved) +} + +fn compress_whole_member( + index: usize, + source: &EntrySource, + integrity: (u64, u32, [u8; 32]), + plan: &CompressPlan, + resources: &WriterResources, + advance: &dyn CompressionProgress, + allowance: &B, +) -> Result { + let (input_size, _, _) = integrity; + let mut crc = Crc32::new(); + let mut hasher = blake2sp::Hasher::new(); + + let mut packed_spool = Spool::create(resources)?; + let mut stored = input_size == 0; + if !stored { + advance.started(index, input_size); + if advance.is_cancelled() { + return Err(Error::Cancelled); + } + let size = usize::try_from(input_size) + .map_err(|_| Error::InvalidArgument("entry size overflows usize"))?; + let mut data = Buffer::filled(size, 0, allowance)?; + let mut reader = source.open()?; + for chunk in data.chunks_mut(plan.block_size.max(1)) { + if advance.is_cancelled() { + return Err(Error::Cancelled); + } + reader.read_exact(chunk)?; + crc.update(chunk); + hasher.update(chunk); + } + check_source_end(&mut *reader)?; + // The filter search walks the member many times over, so + // encoder positions are scaled down to the member's share + // of that total: many passes, one member's worth of + // progress. + let walk = super::filter_policy_walk_bytes( + &data, + &plan.filter_policy, + plan.algorithm_version, + plan.candidates.len(), + ) + .max(input_size) + .max(1); + let share = + |bytes: u64| (u128::from(bytes) * u128::from(input_size) / u128::from(walk)) as u64; + let mut reported = 0u64; + let mut charged = 0u64; + let mut report = |event| { + let position = match event { + crate::filter_search::EncodeProgress::PassStarted => { + reported = 0; + return !advance.is_cancelled(); + } + crate::filter_search::EncodeProgress::Advanced(position) => position as u64, + }; + let delta = position.saturating_sub(reported); + reported = position; + let target = (charged + delta).min(walk); + let scaled = share(target) - share(charged); + charged = target; + advance.advance(scaled) + }; + let packed = candidates_with_allowance( + &data, + plan.algorithm_version, + &plan.filter_policy, + &plan.candidates, + Some(&mut report), + allowance, + )?; + // An explicitly requested filter is not discarded just + // because the result did not shrink. + stored = should_store_compressed_payload( + data.len() as u64, + packed.len() as u64, + plan.solid, + &plan.filter_policy, + ); + if !stored { + packed_spool.write_all(&packed)?; + } + } + + if input_size == 0 { + advance.started(index, input_size); + if advance.is_cancelled() { + return Err(Error::Cancelled); + } + check_source_end(&mut *source.open()?)?; + } + packed_spool.park(); + if !stored { + source.release(); + } + advance.finished(index, input_size); + Ok(CompressedMember { + input_size, + crc32: crc.finish(), + hash: hasher.finalize(), + store: stored, + packed: packed_spool, + solid_continuation: false, + }) +} + +/// Execute the planned automatic-filter fallback without re-entering planning. +/// Block execution uses only `encode_options`; filter search and the candidate +/// list belong to whole-member execution. Store fallback follows that unfiltered +/// base encoding, while the shared codec settings remain intact. +#[allow(clippy::too_many_arguments)] +fn compress_fallback_member( + index: usize, + source: &EntrySource, + integrity: (u64, u32, [u8; 32]), + plan: &CompressPlan, + required: u64, + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result { + struct Remapped<'a> { + index: usize, + progress: &'a dyn CompressionProgress, + } + impl CompressionProgress for Remapped<'_> { + fn is_cancelled(&self) -> bool { + self.progress.is_cancelled() + } + fn advance(&self, bytes: u64) -> bool { + self.progress.advance(bytes) + } + fn started(&self, _: usize, size: u64) { + self.progress.started(self.index, size); + } + fn finished(&self, _: usize, size: u64) { + self.progress.finished(self.index, size); + } + } + if advance.is_cancelled() || resources.is_cancelled() { + return Err(Error::Cancelled); + } + let mut integrity = [integrity]; + let mut packed = compress_streaming_members( + std::slice::from_ref(source), + &mut integrity, + plan, + required, + resources, + &Remapped { + index, + progress: advance, + }, + &|_, error| error_context(index, error), + )?; + let packed = packed.pop().expect("one fallback member"); + let (input_size, crc32, hash) = integrity[0]; + Ok(CompressedMember { + input_size, + crc32, + hash, + store: should_store_compressed_payload( + input_size, + packed.len(), + false, + &FilterPolicy::None, + ), + packed, + solid_continuation: false, + }) +} + +/// Members with independent dictionaries, interleaved so a batch of small +/// members can still saturate the machine. +#[allow(clippy::too_many_arguments)] +fn compress_independent_members( + sources: &[EntrySource], + integrity: &mut [(u64, u32, [u8; 32])], + plan: &CompressPlan, + batch_capacity: usize, + required: u64, + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), + allowance: &B, +) -> Result> +where + B::Charge: Send, +{ + let mut packed = Records::new(sources.len(), resources)?; + let mut group_start = 0; + while group_start < sources.len() { + let group_capacity = streaming_wave_capacity(batch_capacity, required, plan, resources); + let group_end = group_start + .saturating_add(group_capacity) + .min(sources.len()); + let group = &sources[group_start..group_end]; + let mut streams = Records::collect( + group.iter().enumerate().map(|(offset, source)| { + MemberStream::new( + group_start + offset, + source, + integrity[group_start + offset].0, + resources, + advance, + allowance, + ) + .map_err(|error| error_context(group_start + offset, error)) + }), + resources, + )?; + + let mut histories = Records::collect( + (0..streams.len()).map(|_| Ok(Buffer::new(allowance))), + resources, + )?; + let mut cursor = 0usize; + while streams.iter().any(MemberStream::has_more) { + let wave_capacity = streaming_wave_capacity(batch_capacity, required, plan, resources); + let reserved = required.saturating_mul(wave_capacity as u64); + let _permit = resources + .acquire_cancellable(reserved, plan.dictionary_size, &|| advance.is_cancelled())?; + + let mut jobs = Records::new(wave_capacity, resources)?; + let mut misses = 0usize; + while jobs.len() < wave_capacity && misses < streams.len() { + let stream_count = streams.len(); + let member = cursor; + let stream = &mut streams[member]; + cursor = (cursor + 1) % stream_count; + if !stream.has_more() { + misses += 1; + continue; + } + misses = 0; + + let mut job = BlockJob { + data: Buffer::new(allowance), + history: Buffer::copied(&histories[member], allowance)?, + blocks: Records::new(0, resources)?, + }; + while stream.has_more() && job.data.len() < run_size(plan) { + job.append( + read_block(stream, plan.block_size, advance) + .map_err(|error| error_context(stream.member, error))?, + )?; + job.blocks + .push_growing((member, job.data.len(), !stream.has_more()))?; + } + histories[member].remember(&job.data, plan.encode_options.max_match_distance)?; + jobs.push(job)?; + } + + compress_wave( + jobs, + plan, + required, + &mut streams, + resources, + advance, + error_context, + )?; + } + + for stream in streams { + let slot = &mut integrity[stream.member]; + slot.1 = stream.crc.finish(); + slot.2 = stream.hash.finalize(); + packed.push(stream.packed)?; + } + group_start = group_end; + } + Ok(packed) +} + +/// One dictionary running through every member in order. +#[allow(clippy::too_many_arguments)] +fn compress_solid_chain( + sources: &[EntrySource], + integrity: &mut [(u64, u32, [u8; 32])], + plan: &CompressPlan, + batch_capacity: usize, + required: u64, + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), + allowance: &B, +) -> Result> +where + B::Charge: Send, +{ + let mut streams = Records::collect( + sources.iter().enumerate().map(|(member, source)| { + MemberStream::new( + member, + source, + integrity[member].0, + resources, + advance, + allowance, + ) + .map_err(|error| error_context(member, error)) + }), + resources, + )?; + + let mut history = Buffer::new(allowance); + let mut next = 0usize; + loop { + let wave_capacity = streaming_wave_capacity(batch_capacity, required, plan, resources); + let reserved = required.saturating_mul(wave_capacity as u64); + let _permit = resources + .acquire_cancellable(reserved, plan.dictionary_size, &|| advance.is_cancelled())?; + + // Run boundaries depend on input and dictionary size, never on the + // worker count. Adjacent blocks amortize history copies and seeding. + let mut jobs = Records::new(wave_capacity, resources)?; + while jobs.len() < wave_capacity { + while next < streams.len() && !streams[next].has_more() { + next += 1; + } + if next == streams.len() { + break; + } + let mut job = BlockJob { + data: Buffer::new(allowance), + history: Buffer::copied(&history, allowance)?, + blocks: Records::new(0, resources)?, + }; + while job.data.len() < run_size(plan) { + while next < streams.len() && !streams[next].has_more() { + next += 1; + } + let Some(stream) = streams.get_mut(next) else { + break; + }; + job.append( + read_block(stream, plan.block_size, advance) + .map_err(|error| error_context(stream.member, error))?, + )?; + job.blocks + .push_growing((stream.member, job.data.len(), !stream.has_more()))?; + } + // The outer loop found a stream with data, so this job contains + // at least that stream's next block. + history.remember(&job.data, plan.encode_options.max_match_distance)?; + jobs.push(job)?; + } + + if jobs.is_empty() { + break; + } + compress_wave( + jobs, + plan, + required, + &mut streams, + resources, + advance, + error_context, + )?; + } + + Records::collect( + streams.into_iter().map(|stream| { + let slot = &mut integrity[stream.member]; + slot.1 = stream.crc.finish(); + slot.2 = stream.hash.finalize(); + Ok(stream.packed) + }), + resources, + ) +} + +/// Reads the next block from `stream`, checking the source has not grown. +/// +/// One chunk, then further chunks while the data is not moving, which is the +/// same question [`BlockSplitter`] answers for the buffered writer. Both have +/// to reach the same answer or the same input packs to two different archives. +fn read_block( + stream: &mut MemberStream, + block_size: usize, + progress: &dyn CompressionProgress, +) -> Result> { + if !stream.started { + progress.started(stream.member, stream.input_size); + stream.started = true; + } + let mut data = read_chunk(stream, block_size, progress)?; + let mut splitter = BlockSplitter::new(); + splitter.accept(&data); + while stream.has_more() { + let next = read_chunk(stream, block_size, progress)?; + if !splitter.try_extend(&next) { + // Deciding needs the chunk in hand, so this reads one further than + // it keeps. Hand it back for the next block rather than seeking + // backwards, which an `EntryReader` cannot always do. + stream.pushback = next; + break; + } + data.extend_from_slice(&next) + .map_err(Into::::into)?; + } + Ok(data) +} + +/// Reads one chunk, preferring anything a previous read put back. +fn read_chunk( + stream: &mut MemberStream, + block_size: usize, + progress: &dyn CompressionProgress, +) -> Result> { + if progress.is_cancelled() { + return Err(Error::Cancelled); + } + if !stream.pushback.is_empty() { + return Ok({ + let empty = Buffer::new(&stream.pushback.allowance()); + std::mem::replace(&mut stream.pushback, empty) + }); + } + let wanted = usize::try_from(stream.remaining.min(block_size as u64)) + .map_err(|_| Error::InvalidArgument("RAR 5 block size overflows usize"))?; + let mut data = Buffer::filled(wanted, 0u8, &stream.pushback.allowance())?; + // Solid planning can retain every member, but only the current input + // needs a reader. Release it at EOF, even when a block has pushback. + if stream.reader.is_none() { + stream.reader = Some(stream.source.open()?); + } + let reader = stream.reader.as_mut().expect("opened above"); + reader.read_exact(&mut data)?; + stream.crc.update(&data); + stream.hash.update(&data); + stream.remaining -= wanted as u64; + if stream.remaining == 0 { + check_source_end(&mut **reader)?; + stream.reader = None; + } + Ok(data) +} + +fn check_source_end(reader: &mut dyn Read) -> Result<()> { + let mut trailing = [0u8; 1]; + if reader.read(&mut trailing)? != 0 { + return Err(Error::SourceChanged( + "entry source size changed while compressing", + )); + } + Ok(()) +} + +/// Compresses a wave of blocks in parallel, then appends the results to their +/// members in job order so output does not depend on scheduling. +fn compress_wave( + jobs: Records>, + plan: &CompressPlan, + _required: u64, + streams: &mut [MemberStream], + resources: &WriterResources, + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result<()> +where + B::Charge: Send, +{ + if resources.execution.is_some() { + let jobs = prepare_block_jobs::(jobs, resources)?; + let packed_runs = run_jobs_admitted( + jobs, + resources, + advance, + |_| _required, + |job, _, progress, allowance| encode_block_job(job, plan, progress, allowance), + )?; + return append_packed_runs(packed_runs, plan, streams, advance, error_context); + } + let jobs = prepare_block_jobs::(jobs, resources)?; + let packed_runs = run_jobs(jobs, resources, advance, |job, progress| { + let allowance = job.0.data.allowance(); + encode_block_job(job, plan, progress, &allowance) + })?; + append_packed_runs(packed_runs, plan, streams, advance, error_context) +} + +type PackedBlocks = Records<(usize, Buffer, bool)>; +type PreparedBlockJob = (BlockJob, Records<(usize, bool)>, PackedBlocks); + +fn prepare_block_jobs( + jobs: Records>, + resources: &WriterResources, +) -> Result>> { + // Allocate boundary and result descriptors before dispatch. Worker outputs + // carry their scoped codec charge; descriptor arrays keep the root charge. + Records::collect( + jobs.into_iter().map(|job| { + let boundaries = Records::collect( + job.blocks.iter().map(|&(_, end, last)| Ok((end, last))), + resources, + )?; + let output = Records::new(job.blocks.len(), resources)?; + Ok((job, boundaries, output)) + }), + resources, + ) +} + +fn encode_block_job( + (job, boundaries, mut output): PreparedBlockJob, + plan: &CompressPlan, + progress: &dyn CompressionProgress, + allowance: &C, +) -> Result> { + let mut block_done = |bytes: usize| progress.advance(bytes as u64); + let packed = streaming_blocks_with_allowance( + &job.data, + &job.history, + &boundaries, + plan.algorithm_version, + plan.encode_options, + Some(&mut block_done), + allowance, + )?; + for ((member, _, last), packed) in job.blocks.into_iter().zip(packed) { + output.push((member, packed, last))?; + } + Ok(output) +} + +fn append_packed_runs( + packed_runs: Records>, + plan: &CompressPlan, + streams: &mut [MemberStream], + advance: &dyn CompressionProgress, + error_context: &(dyn Fn(usize, Error) -> Error + Sync), +) -> Result<()> { + // A solid wave can cover thousands of tiny members. Keep only the spool + // currently being appended open, rather than one descriptor per member. + let mut previous: Option = None; + for (member, packed, last) in packed_runs.into_iter().flatten() { + if previous != Some(member) { + if let Some(previous) = previous { + streams[previous].packed.park(); + } + previous = Some(member); + } + streams[member] + .packed + .write_all(&packed) + .map_err(|error| error_context(streams[member].member, error.into()))?; + if last { + let stream = &streams[member]; + // A completed block run always came from `has_more`, so an empty + // member cannot reach this branch. + if !should_store_compressed_payload( + stream.input_size, + stream.packed.len(), + plan.solid, + &plan.filter_policy, + ) { + stream.source.release(); + } + advance.finished(stream.member, stream.input_size); + } + } + // Both wave builders dispatch only non-empty jobs, and every job emits + // one packed block for each recorded boundary. + let previous = previous.expect("compression wave contains a packed block"); + streams[previous].packed.park(); + Ok(()) +} + +/// The compression-info vint for a member, including its solid flag. +pub(super) fn member_compression_info( + plan: &CompressPlan, + member: &CompressedMember, +) -> Result { + compression_info( + plan.algorithm_version, + if member.store { 0 } else { plan.method }, + plan.dictionary_size, + member.solid_continuation, + ) +} + +#[cfg(test)] +pub(super) fn compress_members_reporting( + sources: &[EntrySource], + plan: CompressPlan, + resources: &WriterResources, + advance: &dyn CompressionProgress, +) -> Result> { + compress_members_with_context(sources, &plan, resources, advance, &|_, error| error) + .map(|members| members.into_iter().collect()) +} + +#[cfg(test)] +mod tests { + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn stream_creation_failure_keeps_member_context_before_opening_source() { + let scratch = crate::scratch::case("stream-creation-context"); + for solid in [false, true] { + let resources = WriterResources::new(128 * 1024 * 1024) + .with_max_memory_bytes(128 * 1024 * 1024) + .with_temp_dir(scratch.join("missing-directory")); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let source = EntrySource::from_opener(1, || { + panic!("spool creation must fail before opening the source") + }); + let error = compress_members_with_context( + &[source], + &plan, + &resources, + &|_| true, + &|index, error| { + assert_eq!(index, 0); + error.at_entry(b"unopened.bin".to_vec(), "compressing") + }, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context(), + Some((b"unopened.bin".as_slice(), "compressing")) + ); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(resources.managed_memory_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn cancellation_after_wave_check_keeps_admission_error_context() { + struct CancelAfterObservation(crate::WriteCancellation); + impl CompressionProgress for CancelAfterObservation { + fn advance(&self, _: u64) -> bool { + !self.0.is_cancelled() + } + fn is_cancelled(&self) -> bool { + // Model cancellation arriving just after the observation. + let observed = self.0.is_cancelled(); + self.0.cancel(); + observed + } + } + let scratch = crate::scratch::case("wave-admission-context"); + let resources = WriterResources::new(128 * 1024 * 1024).with_temp_dir(&*scratch); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let execution = ExecutionPlan::with_resources(&plan, [32].into_iter(), &resources).unwrap(); + let ExecutionPlan::IndependentMembers(members) = execution else { + panic!("expected whole-member plan"); + }; + assert_eq!(members[0].execution, Execution::WholeMember); + let source = EntrySource::from_opener(32, || { + panic!("cancelled admission must precede source opening") + }); + let progress = CancelAfterObservation(crate::WriteCancellation::new()); + let error = compress_members_whole( + &[source], + &[(32, 0, [0; 32])], + &plan, + &members, + &resources, + &progress, + &|index, error| { + assert_eq!(index, 0); + error.at_entry(b"waiting.bin".to_vec(), "compressing") + }, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled); + assert_eq!( + error.entry_context(), + Some((b"waiting.bin".as_slice(), "compressing")) + ); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[test] + fn streaming_compression_releases_each_refused_preparation_allocation() { + use std::sync::atomic::Ordering; + + let scratch = crate::scratch::case("streaming-preparation-refusals"); + let sources = [EntrySource::from_bytes(vec![b'A'; 2048])]; + let options = EncodeOptions::new(8); + for solid in [false, true] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 1024, + solid, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let run = |resources: &WriterResources| -> Result<()> { + let packed = + compress_members_reporting(&sources, plan.clone(), resources, &|_| true)?; + assert_eq!(packed.len(), 1); + Ok(()) + }; + let (resources, attempts) = WriterResources::default() + .with_temp_dir(&*scratch) + .refuse_preparation_growth_at(usize::MAX); + run(&resources).unwrap(); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 5); + assert!(count < 100); + assert_eq!(resources.preparation_in_use(), 0); + + for index in 0..count { + let (resources, _) = WriterResources::default() + .with_temp_dir(&*scratch) + .refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "solid mode {solid}, admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + } + + #[test] + fn admitted_whole_member_worker_propagates_source_failure() { + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 1024, + solid: false, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options, options].into(), + }; + let source = EntrySource::from_opener(1024, || { + Err(std::io::Error::other("injected worker source failure").into()) + }); + let resources = + WriterResources::new(70 * 1024 * 1024).with_max_memory_bytes(70 * 1024 * 1024); + let error = compress_members_reporting(&[source], plan, &resources, &|_| true) + .err() + .expect("the admitted worker must report its source failure"); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(resources.execution.as_ref().unwrap().used(), 0); + } + + #[test] + fn stored_member_descriptor_refusal_releases_preparation_charge() { + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 128 * 1024, + block_size: 4096, + solid: false, + method: 0, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let source = EntrySource::from_bytes(b"payload".to_vec()); + let limit = std::mem::size_of::<(u64, u32, [u8; 32])>() as u64; + let resources = WriterResources::default().with_max_preparation_bytes(limit); + let error = compress_members_reporting(&[source], plan, &resources, &|_| true) + .err() + .expect("the stored spool descriptors must exceed the integrity record"); + assert!(matches!( + error, + Error::WriterPreparationLimitExceeded { + limit: actual_limit, + used, + .. + } if actual_limit == limit && used == limit + )); + drop(Records::::new(limit as usize, &resources).unwrap()); + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_member_cancellation_after_start_does_not_open_source() { + use std::sync::atomic::{AtomicBool, Ordering}; + + struct StopAfterStart(AtomicBool); + impl CompressionProgress for StopAfterStart { + fn advance(&self, _: u64) -> bool { + !self.is_cancelled() + } + fn is_cancelled(&self) -> bool { + self.0.load(Ordering::SeqCst) + } + fn started(&self, _: usize, _: u64) { + self.0.store(true, Ordering::SeqCst); + } + } + + let scratch = crate::scratch::case("whole-member-cancel-after-start"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 128 * 1024, + block_size: 4096, + solid: false, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + for size in [0, 16] { + let source = EntrySource::from_opener(size, || { + panic!("cancelled compression must not open the source") + }); + let progress = StopAfterStart(AtomicBool::new(false)); + assert!(matches!( + compress_whole_member( + 0, + &source, + (size, 0, [0; 32]), + &plan, + &resources, + &progress, + &Allowance::default(), + ), + Err(Error::Cancelled) + )); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_member_cancellation_between_waves_does_not_open_next_source() { + use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; + + struct StopAfterFirst { + finished: AtomicBool, + checks_after_finish: AtomicUsize, + resource_cancellation: Option, + } + impl CompressionProgress for StopAfterFirst { + fn advance(&self, _: u64) -> bool { + !self.is_cancelled() + } + fn is_cancelled(&self) -> bool { + // Let the completed wave return its result, then cancel at + // the coordinator's check before admitting the next wave. + if !self.finished.load(Ordering::SeqCst) { + return false; + } + if self.checks_after_finish.fetch_add(1, Ordering::SeqCst) == 0 { + return false; + } + if let Some(token) = &self.resource_cancellation { + token.cancel(); + false + } else { + true + } + } + fn finished(&self, index: usize, _: u64) { + if index == 0 { + self.finished.store(true, Ordering::SeqCst); + } + } + } + + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let scratch = crate::scratch::case("whole-member-cancel-between-waves"); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(1) + .build() + .unwrap(); + for resource_cancellation in [false, true] { + let first = EntrySource::from_bytes(b"first".to_vec()); + let second = EntrySource::from_opener(6, || { + panic!("cancellation between waves must not open the next source") + }); + let token = resource_cancellation.then(crate::WriteCancellation::new); + let mut resources = WriterResources::new(80 * 1024 * 1024).with_temp_dir(&*scratch); + if let Some(token) = &token { + resources = resources.with_cancellation(token.clone()); + } + let progress = StopAfterFirst { + finished: AtomicBool::new(false), + checks_after_finish: AtomicUsize::new(0), + resource_cancellation: token.clone(), + }; + let result = pool.install(|| { + compress_members_reporting(&[first, second], plan.clone(), &resources, &progress) + }); + assert!( + matches!(result, Err(Error::Cancelled)), + "{:?}", + result.err() + ); + if let Some(token) = &token { + assert!(token.is_cancelled()); + } else { + assert!(progress.is_cancelled()); + } + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + struct Cancelled; + + impl CompressionProgress for Cancelled { + fn advance(&self, _: u64) -> bool { + false + } + + fn is_cancelled(&self) -> bool { + true + } + } + + #[test] + fn cancellation_prevents_worker_dispatch_and_empty_source_open() { + let resources = WriterResources::default(); + let jobs = Records::collect([1u8].into_iter().map(Ok), &resources).unwrap(); + assert_eq!( + run_jobs(jobs, &resources, &Cancelled, |_, _| -> Result { + panic!("cancelled job was dispatched") + }) + .err() + .unwrap(), + Error::Cancelled + ); + + let ledger = crate::codec::workspace::Allowance::limited(1024 * 1024); + let admitted = resources.with_execution_allowance(ledger.clone()); + let jobs = Records::collect([1u8].into_iter().map(Ok), &admitted).unwrap(); + assert_eq!( + run_jobs_admitted( + jobs, + &admitted, + &Cancelled, + |_| 1, + |_, _, _, _| -> Result { panic!("cancelled job was admitted") }, + ) + .err() + .unwrap(), + Error::Cancelled + ); + assert_eq!(ledger.used(), 0); + + let cancellation = crate::WriteCancellation::new(); + let admitted = WriterResources::default() + .with_cancellation(cancellation.clone()) + .with_execution_allowance(ledger.clone()); + let jobs = Records::collect([1u8].into_iter().map(Ok), &admitted).unwrap(); + cancellation.cancel(); + assert_eq!( + run_jobs_admitted( + jobs, + &admitted, + &|_| true, + |_| 1, + |_, _, _, _| -> Result { panic!("cancelled resource dispatched a job") }, + ) + .err() + .unwrap(), + Error::Cancelled + ); + assert_eq!(ledger.used(), 0); + + let source = EntrySource::from_opener(0, || panic!("empty source was opened")); + assert_eq!( + MemberStream::new( + 0, + &source, + 0, + &WriterResources::default(), + &Cancelled, + &crate::codec::workspace::Allowance::default(), + ) + .err() + .unwrap(), + Error::Cancelled + ); + } + + #[test] + fn a_codec_failure_takes_precedence_over_sibling_cancellation() { + let resources = WriterResources::default(); + let jobs = Records::collect( + [ + (None::, Some(Err::(Error::Cancelled))), + (None, Some(Err(Error::InvalidArgument("codec failure")))), + ] + .into_iter() + .map(Ok), + &resources, + ) + .unwrap(); + let output = Records::new(2, &resources).unwrap(); + assert_eq!( + complete_jobs( + jobs, + output, + &resources, + &Cancelled, + |_, _, _| -> Result { + panic!("cancelled worker overwrote its recorded result") + } + ) + .err() + .unwrap(), + Error::InvalidArgument("codec failure") + ); + + let jobs = Records::collect( + [ + ( + None::, + Some(Err::(Error::InvalidArgument("first"))), + ), + (None, Some(Err(Error::InvalidArgument("second")))), + ] + .into_iter() + .map(Ok), + &resources, + ) + .unwrap(); + let output = Records::new(2, &resources).unwrap(); + assert_eq!( + complete_jobs( + jobs, + output, + &resources, + &Cancelled, + |_, _, _| -> Result { + panic!("cancelled worker overwrote its recorded result") + } + ) + .err() + .unwrap(), + Error::InvalidArgument("first") + ); + } + + #[test] + fn compression_guards_sources_before_start_and_fallback() { + struct Untouched; + impl crate::streaming::SourceFactory for Untouched { + fn len(&self) -> Result { + panic!("cancelled compression measured a source") + } + fn open(&self) -> Result> { + panic!("cancelled compression opened a source") + } + } + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 128 * 1024, + block_size: 4096, + solid: false, + method: 0, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let resources = WriterResources::default(); + let source = EntrySource::from_factory(Untouched); + assert_eq!( + compress_members_with_context(&[source], &plan, &resources, &Cancelled, &|_, error| { + error + }) + .err() + .unwrap(), + Error::Cancelled + ); + assert_eq!( + compress_members_with_context( + &[EntrySource::from_bytes(b"payload".to_vec())], + &plan, + &resources, + &|_| false, + &|_, error| error, + ) + .err() + .unwrap(), + Error::Cancelled + ); + let token = crate::WriteCancellation::new(); + token.cancel(); + let resources = WriterResources::default().with_cancellation(token); + assert_eq!( + compress_members_with_context( + &[EntrySource::from_factory(Untouched)], + &plan, + &resources, + &|_| true, + &|_, error| error, + ) + .err() + .unwrap(), + Error::Cancelled + ); + let running = |_: u64| true; + for (resources, progress) in [ + ( + WriterResources::default(), + &Cancelled as &dyn CompressionProgress, + ), + (resources, &running as &dyn CompressionProgress), + ] { + assert_eq!( + compress_fallback_member( + 0, + &EntrySource::from_factory(Untouched), + (7, 0, [0; 32]), + &plan, + 0, + &resources, + progress, + &|_, error| error, + ) + .err() + .unwrap(), + Error::Cancelled + ); + } + } + + #[test] + fn whole_waves_admit_the_sum_without_crossing_fallbacks_or_overflowing() { + let whole = |workspace| MemberPlan { + execution: Execution::WholeMember, + workspace, + }; + let members = [whole(60), whole(40), whole(1), whole(u64::MAX)]; + assert_eq!(whole_member_wave(&members, 0, 4, 100), (2, 100)); + assert_eq!(whole_member_wave(&members, 0, 1, 100), (1, 60)); + assert_eq!(whole_member_wave(&members, 0, 4, 59), (1, 60)); + assert_eq!(whole_member_wave(&members, 2, 4, u64::MAX), (3, 1)); + let fallback = MemberPlan { + execution: Execution::Blocks { + fallback: super::super::plan::FallbackReason::AutomaticFilterWorkspace { + required: 100, + limit: 99, + }, + }, + workspace: 10, + }; + assert_eq!( + whole_member_wave(&[whole(0), fallback, whole(0)], 0, 4, 0), + (1, 0) + ); + } + + #[test] + fn stream_read_admission_precedes_open_and_pushback_keeps_its_charge() { + use std::sync::{atomic::AtomicUsize, Arc}; + let scratch = crate::scratch::case("stream-read-allowance"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let opens = Arc::new(AtomicUsize::new(0)); + let source = EntrySource::from_opener(8, { + let opens = opens.clone(); + move || { + opens.fetch_add(1, Ordering::Relaxed); + Ok(Box::new(std::io::Cursor::new(*b"abcdefgh"))) + } + }); + let allowance = Allowance::limited(3); + let mut stream = + MemberStream::new(0, &source, 8, &resources, &|_| true, &allowance).unwrap(); + assert_eq!( + read_chunk(&mut stream, 4, &|_| true).unwrap_err().kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(opens.load(Ordering::Relaxed), 0); + assert_eq!(stream.remaining, 8); + assert_eq!(allowance.used(), 0); + drop(stream); + + let allowance = Allowance::limited(8); + let mut stream = + MemberStream::new(0, &source, 8, &resources, &|_| true, &allowance).unwrap(); + stream.pushback = read_chunk(&mut stream, 4, &|_| true).unwrap(); + assert_eq!(allowance.used(), 4); + let first = read_chunk(&mut stream, 4, &|_| true).unwrap(); + assert_eq!(&*first, b"abcd"); + assert_eq!(allowance.used(), 4); + assert_eq!(stream.remaining, 4); + let last = read_chunk(&mut stream, 4, &|_| true).unwrap(); + assert_eq!(&*last, b"efgh"); + assert_eq!(allowance.used(), 8); + assert!(stream.reader.is_none()); + drop(stream); + assert_eq!(allowance.used(), 8); + drop((first, last)); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn streaming_writer_allowance_covers_assembly_encoding_and_failure_cleanup() { + let scratch = crate::scratch::case("stream-writer-allowance"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let data: Vec = (0..8192).map(|i| ((i * 71) % 251) as u8).collect(); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + for solid in [false, true] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 1024, + solid, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let sources = [ + EntrySource::from_bytes(data.clone()), + EntrySource::from_bytes(data[..2048].to_vec()), + EntrySource::from_bytes(Vec::new()), + ]; + let initial = [(8192, 0, [0; 32]), (2048, 0, [0; 32]), (0, 0, [0; 32])]; + let mut expected_integrity = initial; + let encode = if solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + let expected = encode( + &sources, + &mut expected_integrity, + &plan, + 2, + 1, + &resources, + &|_| true, + &|_, error| error, + &Allowance::default(), + ) + .unwrap(); + let payloads = |spools: Records| -> Vec> { + spools + .into_iter() + .map(|mut spool| { + let mut bytes = Vec::new(); + spool.copy_to(&mut bytes).unwrap(); + bytes + }) + .collect() + }; + let expected = payloads(expected); + let mut refusals = 0; + let mut successes = 0; + for limit in [0, 1023, 2048, 8192, 32768, 131072, 524288, 4 * 1024 * 1024] { + let allowance = Allowance::limited(limit); + let mut integrity = initial; + let encode = if solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + let result = encode( + &sources, + &mut integrity, + &plan, + 2, + 1, + &resources, + &|_| { + assert!(allowance.used() > 0); + true + }, + &|_, error| error, + &allowance, + ); + match result { + Ok(spools) => { + successes += 1; + assert_eq!(payloads(spools), expected); + assert_eq!(integrity, expected_integrity); + } + Err(error) => { + refusals += 1; + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit, "{error}"); + } + } + assert_eq!(allowance.used(), 0, "solid={solid}, limit={limit}"); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + assert!(refusals >= 3 && successes > 0); + + let allowance = Allowance::limited(4 * 1024 * 1024); + let encode = if solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + let mut integrity = initial; + let result = encode( + &sources, + &mut integrity, + &plan, + 2, + 1, + &resources, + &|_| false, + &|_, error| error, + &allowance, + ); + assert!(matches!(result, Err(Error::Cancelled))); + assert_eq!(allowance.used(), 0); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn bounded_streaming_history_survives_multiple_waves_and_member_boundaries() { + let scratch = crate::scratch::case("stream-history-allowance"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let size = crate::codec::rar50::MAX_LZ_BLOCK_SIZE + 4096; + let data: Vec = (0..size).map(|i| ((i * 71) % 251) as u8).collect(); + let sources = [ + EntrySource::from_bytes(data.clone()), + EntrySource::from_bytes(data), + ]; + let options = EncodeOptions::new(8).with_max_match_distance(65536); + for solid in [false, true] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let mut expected_integrity = [(size as u64, 0, [0; 32]); 2]; + let mut actual_integrity = expected_integrity; + let encode = if solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + let expected = encode( + &sources, + &mut expected_integrity, + &plan, + 1, + 1, + &resources, + &|_| true, + &|_, error| error, + &Allowance::default(), + ) + .unwrap(); + let allowance = Allowance::limited(64 * 1024 * 1024); + let encode = if solid { + compress_solid_chain:: + } else { + compress_independent_members:: + }; + let actual = encode( + &sources, + &mut actual_integrity, + &plan, + 2, + 1, + &resources, + &|_| true, + &|_, error| error, + &allowance, + ) + .unwrap(); + assert_eq!(actual_integrity, expected_integrity); + assert_eq!(allowance.used(), 0); + for (mut expected, mut actual) in expected.into_iter().zip(actual) { + let mut expected_bytes = Vec::new(); + let mut actual_bytes = Vec::new(); + expected.copy_to(&mut expected_bytes).unwrap(); + actual.copy_to(&mut actual_bytes).unwrap(); + assert_eq!(actual_bytes, expected_bytes); + } + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn streaming_ledger_covers_repeated_waves_and_retained_history() { + use std::sync::atomic::AtomicU64; + let scratch = crate::scratch::case("stream-ledger-waves"); + let size = crate::codec::rar50::MAX_LZ_BLOCK_SIZE * 2 + 4096; + let data: Vec = (0..size).map(|i| ((i * 71) % 251) as u8).collect(); + let sources = [ + EntrySource::from_bytes(data.clone()), + EntrySource::from_bytes(data), + ]; + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(2) + .build() + .unwrap(); + for (solid, filter_policy) in [ + (false, FilterPolicy::None), + (true, FilterPolicy::None), + (false, FilterPolicy::Auto), + ] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid, + method: 1, + filter_policy, + candidates: vec![options].into(), + }; + let required = super::super::streaming_lz_workspace( + plan.dictionary_size, + crate::codec::rar50::MAX_LZ_BLOCK_SIZE, + false, + ); + // Automatic mode is forced through its existing streaming fallback. + let max_workers = if plan.filter_policy == FilterPolicy::Auto { + 1 + } else { + 2 + }; + let resources = WriterResources::new(required * max_workers).with_temp_dir(&*scratch); + let collect = |members: Records| -> Vec<_> { + members + .into_iter() + .map(|mut member| { + let mut bytes = Vec::new(); + member.packed.copy_to(&mut bytes).unwrap(); + ( + bytes, + member.crc32, + member.hash, + member.store, + member.solid_continuation, + ) + }) + .collect() + }; + let expected = collect( + pool.install(|| { + compress_members_with_context(&sources, &plan, &resources, &|_| true, &|_, e| e) + }) + .unwrap(), + ); + for workers in 1..=max_workers { + let limit = required * workers + 32 * 1024 * 1024; + let ledger = Allowance::limited(limit); + let bounded = resources.clone().with_execution_allowance(ledger.clone()); + let peak = AtomicU64::new(0); + let progress = |_| { + let used = ledger.used(); + assert!(used <= limit); + peak.fetch_max(used, Ordering::Relaxed); + true + }; + let actual = pool + .install(|| { + compress_members_with_context( + &sources, + &plan, + &bounded, + &progress, + &|_, e| e, + ) + }) + .unwrap(); + assert!(peak.load(Ordering::Relaxed) >= required * workers); + // Native spools retain their path storage alongside result descriptors. + assert!( + ledger.used() + > (sources.len() * std::mem::size_of::()) as u64 + ); + assert_eq!(collect(actual), expected); + assert_eq!(ledger.used(), 0); + assert_eq!(bounded.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + } + + #[test] + fn streaming_ledger_releases_assembly_workers_and_spools_on_failure() { + use std::sync::{atomic::AtomicUsize, Arc}; + let scratch = crate::scratch::case("stream-ledger-failure"); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + for solid in [false, true] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 4096, + solid, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let ledger = Allowance::limited(256 * 1024 * 1024); + let resources = WriterResources::default() + .with_temp_dir(&*scratch) + .with_execution_allowance(ledger.clone()); + let opens = Arc::new(AtomicUsize::new(0)); + let failed_source = EntrySource::from_opener(4096, { + let opens = opens.clone(); + let ledger = ledger.clone(); + move || { + assert!(ledger.used() >= 4096); + opens.fetch_add(1, Ordering::Relaxed); + Err(std::io::Error::other("injected source failure").into()) + } + }); + let result = compress_members_with_context( + &[failed_source], + &plan, + &resources, + &|_| true, + &|_, e| e, + ); + assert!(result.is_err()); + assert_eq!(opens.load(Ordering::Relaxed), 1); + assert_eq!(ledger.used(), 0); + let sources = [EntrySource::from_bytes(vec![7; 8192])]; + let too_small = Allowance::limited(16 * 1024 * 1024); + let constrained = resources + .clone() + .with_execution_allowance(too_small.clone()); + assert_eq!( + compress_members_with_context(&sources, &plan, &constrained, &|_| true, &|_, e| e,) + .err() + .unwrap() + .kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(too_small.used(), 0); + let result = + compress_members_with_context(&sources, &plan, &resources, &|_| false, &|_, e| e); + assert!(matches!(result, Err(Error::Cancelled))); + assert_eq!(ledger.used(), 0); + let constrained = resources.clone().with_max_spool_bytes(1); + assert!(compress_members_with_context( + &sources, + &plan, + &constrained, + &|_| true, + &|_, e| e + ) + .is_err()); + assert_eq!(ledger.used(), 0); + drop( + compress_members_with_context(&sources, &plan, &resources, &|_| true, &|_, e| e) + .unwrap(), + ); + assert_eq!(ledger.used(), 0); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn stored_ledger_admits_read_buffer_before_opening_and_releases_it() { + use std::sync::{atomic::AtomicUsize, Arc}; + let scratch = crate::scratch::case("stored-ledger"); + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid: false, + method: 0, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let opens = Arc::new(AtomicUsize::new(0)); + for limit in [32768, 131072] { + let ledger = Allowance::limited(limit); + let resources = WriterResources::default() + .with_temp_dir(&*scratch) + .with_execution_allowance(ledger.clone()); + let source = EntrySource::from_opener(8, { + let opens = opens.clone(); + let ledger = ledger.clone(); + move || { + assert!(ledger.used() >= 65536); + opens.fetch_add(1, Ordering::Relaxed); + Ok(Box::new(std::io::Cursor::new([7u8; 8]))) + } + }); + let result = + compress_members_with_context(&[source], &plan, &resources, &|_| true, &|_, e| e); + if limit < 65536 { + assert_eq!( + result.err().unwrap().kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(opens.load(Ordering::Relaxed), 0); + } else { + let result = result.unwrap(); + assert!(result[0].store); + assert_eq!(result[0].crc32, crate::crc32::crc32(&[7u8; 8])); + drop(result); + assert_eq!(opens.load(Ordering::Relaxed), 1); + } + assert_eq!(ledger.used(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn streaming_source_failure_releases_admitted_buffers() { + let scratch = crate::scratch::case("stream-source-failure-allowance"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + for bytes in [b"short".as_slice(), b"too long for declared size"] { + let source = + EntrySource::from_opener(8, move || Ok(Box::new(std::io::Cursor::new(bytes)))); + let allowance = Allowance::limited(128); + let mut stream = + MemberStream::new(0, &source, 8, &resources, &|_| true, &allowance).unwrap(); + let error = read_block(&mut stream, 4, &|_| true).unwrap_err(); + assert!(matches!(error, Error::Io(_) | Error::SourceChanged(_))); + drop(stream); + assert_eq!(allowance.used(), 0); + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn admitted_workers_share_one_ledger_without_racing_for_spare_capacity() { + use crate::streaming::preparation::Bytes; + use std::sync::{atomic::AtomicU64, Barrier}; + let ledger = Allowance::limited(65536); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(2) + .build() + .unwrap(); + for fail in [false, true] { + let barrier = Barrier::new(2); + let admitted = AtomicU64::new(0); + let jobs = Records::collect((0..2).map(Ok), &resources).unwrap(); + let result = pool.install(|| { + run_jobs_admitted( + jobs, + &resources, + &|_| true, + |_| 128, + |index, worker, _, allowance| { + if index == 0 { + admitted.store(ledger.used(), Ordering::Relaxed); + } + barrier.wait(); + let prepared = Bytes::zeroed(32, worker)?; + let bytes = Buffer::filled(64, index as u8, allowance)?; + assert_eq!(ledger.used(), admitted.load(Ordering::Relaxed)); + barrier.wait(); + if fail && index == 0 { + Buffer::filled(33, 0u8, allowance)?; + } + Ok((prepared, bytes)) + }, + ) + }); + if fail { + assert_eq!( + result.err().unwrap().kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(ledger.used(), 0); + } else { + let mut output = result.unwrap(); + let first = output.pop().unwrap(); + let second = output.pop().unwrap(); + drop(output); + assert_eq!( + ledger.used(), + 192 + 2 * crate::codec::workspace::RESERVATION_BYTES + ); + drop(first); + assert_eq!( + ledger.used(), + 96 + crate::codec::workspace::RESERVATION_BYTES + ); + drop(second); + assert_eq!(ledger.used(), 0); + } + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_member_ledger_selects_fitting_waves_before_opening_sources() { + use std::sync::{atomic::AtomicUsize, Arc, Barrier}; + let scratch = crate::scratch::case("whole-member-ledger"); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 1024, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let data: Arc<[u8]> = (0..1024u32) + .flat_map(|n| n.to_le_bytes()) + .collect::>() + .into(); + let required = whole_member_workspace(data.len() as u64, &plan); + let expected = candidates_with_allowance( + &data, + 0, + &plan.filter_policy, + &plan.candidates, + None, + &Allowance::default(), + ) + .unwrap(); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(2) + .build() + .unwrap(); + for workers in [1, 2] { + let ledger = Allowance::limited(required * workers + 65536); + let resources = WriterResources::new(required * 2) + .with_temp_dir(&*scratch) + .with_execution_allowance(ledger.clone()); + let opens = Arc::new(AtomicUsize::new(0)); + let barrier = Arc::new(Barrier::new(workers as usize)); + let sources: Vec<_> = (0..4) + .map(|_| { + let data = data.clone(); + let ledger = ledger.clone(); + let opens = opens.clone(); + let barrier = barrier.clone(); + EntrySource::from_opener(data.len() as u64, move || { + assert!(ledger.used() >= required * workers); + opens.fetch_add(1, Ordering::Relaxed); + barrier.wait(); + Ok(Box::new(std::io::Cursor::new(data.clone()))) + }) + }) + .collect(); + let result = pool + .install(|| { + compress_members_with_context( + &sources, + &plan, + &resources, + &|_| true, + &|_, error| error, + ) + }) + .unwrap(); + assert_eq!(opens.load(Ordering::Relaxed), 4); + assert!(ledger.used() > (4 * std::mem::size_of::()) as u64); + for mut member in result { + let mut bytes = Vec::new(); + member.packed.copy_to(&mut bytes).unwrap(); + assert_eq!(&*expected, bytes); + } + assert_eq!(ledger.used(), 0); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn coordinator_slots_are_admitted_before_callbacks_and_results_stay_charged() { + use std::sync::atomic::AtomicUsize; + let calls = AtomicUsize::new(0); + let limited = WriterResources::default().with_max_preparation_bytes(16); + let jobs = Records::collect([Ok(1u64), Ok(2)].into_iter(), &limited).unwrap(); + assert!(matches!( + run_jobs(jobs, &limited, &|_| true, |job, _| { + calls.fetch_add(1, Ordering::Relaxed); + Ok(job) + }), + Err(Error::WriterPreparationLimitExceeded { .. }) + )); + assert_eq!(calls.load(Ordering::Relaxed), 0); + drop(Records::::new(16, &limited).unwrap()); + + let resources = WriterResources::default().with_max_preparation_bytes(65536); + for _ in 0..8 { + let jobs = Records::collect([Ok(1u64), Ok(2)].into_iter(), &resources).unwrap(); + let output = run_jobs(jobs, &resources, &|_| true, |job, _| Ok(job * 2)).unwrap(); + assert_eq!(&*output, &[2, 4]); + assert!(matches!( + Records::::new(65536, &resources), + Err(Error::WriterPreparationLimitExceeded { used: 16, .. }) + )); + drop(output); + drop(Records::::new(65536, &resources).unwrap()); + } + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn failed_wave_skips_queued_sources_and_releases_successful_siblings() { + use std::sync::atomic::AtomicUsize; + struct Retained<'a>(&'a AtomicUsize); + impl Drop for Retained<'_> { + fn drop(&mut self) { + self.0.fetch_add(1, Ordering::Relaxed); + } + } + let scratch = crate::scratch::case("coordinator-failure"); + let resources = WriterResources::new(100) + .with_temp_dir(&*scratch) + .with_max_preparation_bytes(65536); + let calls = AtomicUsize::new(0); + let drops = AtomicUsize::new(0); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(1) + .build() + .unwrap(); + let permit = resources.acquire(100, 0).unwrap(); + let jobs = Records::collect((0..3).map(Ok), &resources).unwrap(); + let result = pool.install(|| { + run_jobs(jobs, &resources, &|_| true, |job, _| { + calls.fetch_add(1, Ordering::Relaxed); + assert_eq!(resources.workspace_in_use(), 100); + if job == 1 { + return Err(Error::SourceChanged("test sibling failure")); + } + Ok((Retained(&drops), Spool::create(&resources)?)) + }) + }); + assert!(matches!( + result, + Err(Error::SourceChanged("test sibling failure")) + )); + assert_eq!(calls.load(Ordering::Relaxed), 2); + assert_eq!(drops.load(Ordering::Relaxed), 1); + assert_eq!(resources.workspace_in_use(), 100); + drop(permit); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + drop(Records::::new(65536, &resources).unwrap()); + let jobs = Records::collect((0..3).map(Ok), &resources).unwrap(); + assert_eq!( + pool.install(|| run_jobs(jobs, &resources, &|_| true, |job, _| Ok(job))) + .unwrap() + .len(), + 3 + ); + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn sibling_failure_joins_running_work_and_keeps_the_original_error() { + use std::sync::{atomic::AtomicUsize, Barrier}; + let resources = WriterResources::default().with_max_preparation_bytes(65536); + let barrier = Barrier::new(2); + let joined = AtomicUsize::new(0); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(2) + .build() + .unwrap(); + let jobs = Records::collect((0..2).map(Ok), &resources).unwrap(); + let result: Result> = pool.install(|| { + run_jobs(jobs, &resources, &|_| true, |job, progress| { + barrier.wait(); + if job == 1 { + return Err(Error::SourceChanged("original failure")); + } + while !progress.is_cancelled() { + std::thread::yield_now(); + } + joined.fetch_add(1, Ordering::Relaxed); + Err(Error::Cancelled) + }) + }); + assert!(matches!( + result, + Err(Error::SourceChanged("original failure")) + )); + assert_eq!(joined.load(Ordering::Relaxed), 1); + drop(Records::::new(65536, &resources).unwrap()); + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_member_allowance_precedes_source_open_and_survives_until_spooling() { + use std::sync::{atomic::AtomicUsize, Arc}; + let scratch = crate::scratch::case("whole-member-allowance"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 1024, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options, options.with_optimal_parse(true)].into(), + }; + let data: Vec = (0..1024u32).flat_map(|n| n.to_le_bytes()).collect(); + let opens = Arc::new(AtomicUsize::new(0)); + let source = EntrySource::from_opener(data.len() as u64, { + let data = data.clone(); + let opens = opens.clone(); + move || { + opens.fetch_add(1, Ordering::Relaxed); + Ok(Box::new(std::io::Cursor::new(data.clone()))) + } + }); + let integrity = (data.len() as u64, 0, [0; 32]); + let allowance = Allowance::limited(data.len() as u64 - 1); + let error = compress_whole_member( + 0, + &source, + integrity, + &plan, + &resources, + &|_| true, + &allowance, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(opens.load(Ordering::Relaxed), 0); + assert_eq!(allowance.used(), 0); + + let allowance = Allowance::limited(16 * 1048576); + let mut packed = compress_whole_member( + 0, + &source, + integrity, + &plan, + &resources, + &|_| { + assert!(allowance.used() >= data.len() as u64); + true + }, + &allowance, + ) + .unwrap(); + assert!(!packed.store); + assert_eq!(packed.crc32, crate::crc32::crc32(&data)); + assert_eq!(packed.hash, blake2sp::hash(&data)); + assert_eq!(allowance.used(), 0); + let expected = candidates_with_allowance( + &data, + 0, + &plan.filter_policy, + &plan.candidates, + None, + &Allowance::default(), + ) + .unwrap(); + let mut bytes = Vec::new(); + packed.packed.copy_to(&mut bytes).unwrap(); + assert_eq!(&*expected, bytes); + drop(packed); + + let refused_spool = resources.clone().with_max_spool_bytes(0); + let error = compress_whole_member( + 0, + &source, + integrity, + &plan, + &refused_spool, + &|_| true, + &allowance, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(allowance.used(), 0); + let cancelled = compress_whole_member( + 0, + &source, + integrity, + &plan, + &resources, + &|_| false, + &allowance, + ); + assert!(matches!(cancelled, Err(Error::Cancelled))); + assert_eq!(allowance.used(), 0); + for actual in [b"short".as_slice(), b"longer than declared"] { + let changed = + EntrySource::from_opener(8, move || Ok(Box::new(std::io::Cursor::new(actual)))); + let result = compress_whole_member( + 0, + &changed, + (8, 0, [0; 32]), + &plan, + &resources, + &|_| true, + &allowance, + ); + assert!(matches!( + result, + Err(Error::Io(_) | Error::SourceChanged(_)) + )); + assert_eq!(allowance.used(), 0); + } + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_member_sources_open_only_after_combined_admission() { + use std::sync::{atomic::AtomicUsize, Arc}; + let encode_options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options, + dictionary_size: 65536, + block_size: 65536, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![encode_options].into(), + }; + let required = whole_member_workspace(32, &plan); + let scratch = crate::scratch::case("coordinator-admission"); + let resources = WriterResources::new(required * 2).with_temp_dir(&*scratch); + let calls = Arc::new(AtomicUsize::new(0)); + let sources: Vec<_> = (0..4) + .map(|_| { + let resources = resources.clone(); + let calls = calls.clone(); + EntrySource::from_opener(32, move || { + assert_eq!(resources.workspace_in_use(), required * 2); + calls.fetch_add(1, Ordering::Relaxed); + Ok(Box::new(std::io::Cursor::new([42u8; 32]))) + }) + }) + .collect(); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(4) + .build() + .unwrap(); + drop( + pool.install(|| compress_members_reporting(&sources, plan, &resources, &|_| true)) + .unwrap(), + ); + assert_eq!(calls.load(Ordering::Relaxed), 4); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[test] + fn automatic_filter_fallback_source_failure_keeps_member_context() { + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + let scratch = crate::scratch::case("fallback-source-error"); + let resources = WriterResources::new(70 * 1024 * 1024).with_temp_dir(&*scratch); + let length = 2 * 1024 * 1024; + let options = EncodeOptions::new(8).with_max_match_distance(128 * 1024); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 128 * 1024, + block_size: crate::codec::rar50::LZ_BLOCK_SIZE, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let execution = + ExecutionPlan::with_resources(&plan, std::iter::once(length), &resources).unwrap(); + let ExecutionPlan::IndependentMembers(ref members) = execution else { + panic!("automatic filtering should plan independent members"); + }; + assert!(matches!(members[0].execution, Execution::Blocks { .. })); + drop(execution); + let opens = Arc::new(AtomicUsize::new(0)); + let source = EntrySource::from_opener(length, { + let opens = Arc::clone(&opens); + move || { + opens.fetch_add(1, Ordering::Relaxed); + Err(std::io::Error::other("fallback source refused").into()) + } + }); + let error = compress_members_with_context( + &[source], + &plan, + &resources, + &|_| true, + &|index, error| { + assert_eq!(index, 0); + error.at_entry(b"fallback.bin".to_vec(), "compressing") + }, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context(), + Some((b"fallback.bin".as_slice(), "compressing")) + ); + assert!(error.to_string().contains("fallback source refused")); + assert_eq!(opens.load(Ordering::Relaxed), 1); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[test] + fn mixed_whole_and_fallback_members_keep_order_progress_and_cleanup() { + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Mutex, + }; + struct Progress { + events: Mutex>, + cancel: bool, + stopped: AtomicBool, + } + impl CompressionProgress for Progress { + fn advance(&self, _: u64) -> bool { + !self.is_cancelled() + } + fn is_cancelled(&self) -> bool { + self.stopped.load(Ordering::Relaxed) + } + fn started(&self, index: usize, _: u64) { + self.events.lock().unwrap().push((true, index)); + if self.cancel && index == 1 { + self.stopped.store(true, Ordering::Relaxed); + } + } + fn finished(&self, index: usize, _: u64) { + self.events.lock().unwrap().push((false, index)); + } + } + let scratch = crate::scratch::case("planned-fallback"); + let data = b"planned automatic filter fallback\n".repeat(65536); + let sources = [ + EntrySource::from_bytes(b"first".to_vec()), + EntrySource::from_bytes(data.clone()), + EntrySource::from_bytes(b"last".to_vec()), + ]; + let encode_options = EncodeOptions::new(8).with_max_match_distance(128 * 1024); + let plan = CompressPlan { + algorithm_version: 0, + encode_options, + dictionary_size: 128 * 1024, + block_size: crate::codec::rar50::LZ_BLOCK_SIZE, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![encode_options].into(), + }; + let resources = WriterResources::new(70 * 1024 * 1024).with_temp_dir(&*scratch); + for cancel in [false, true] { + let progress = Progress { + events: Mutex::new(Vec::new()), + cancel, + stopped: AtomicBool::new(false), + }; + let result = compress_members_reporting(&sources, plan.clone(), &resources, &progress); + if cancel { + assert!(matches!(result, Err(Error::Cancelled))); + assert!(!progress.events.lock().unwrap().contains(&(true, 2))); + } else { + let mut members = result.unwrap(); + assert_eq!(members.len(), 3); + for index in 0..3 { + let events = progress.events.lock().unwrap(); + assert_eq!( + events + .iter() + .filter(|event| **event == (true, index)) + .count(), + 1 + ); + assert_eq!( + events + .iter() + .filter(|event| **event == (false, index)) + .count(), + 1 + ); + } + assert_eq!(members[1].hash, blake2sp::hash(&data)); + let mut fallback_bytes = Vec::new(); + members[1].packed.copy_to(&mut fallback_bytes).unwrap(); + let mut plain = compress_members_reporting( + &sources[1..2], + CompressPlan { + filter_policy: FilterPolicy::None, + ..plan.clone() + }, + &resources, + &|_| true, + ) + .unwrap(); + let mut plain_bytes = Vec::new(); + plain[0].packed.copy_to(&mut plain_bytes).unwrap(); + assert_eq!(fallback_bytes, plain_bytes); + } + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn explicit_filter_pass_events_do_not_change_packed_bytes() { + use crate::filter_search::EncodeProgress; + let data: Vec<_> = (0..8192u32).flat_map(u32::to_le_bytes).collect(); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plain = encode_member_with_filter_policy_candidates_and_progress( + &data, + 0, + &FilterPolicy::Auto, + &[options, options], + None, + ) + .unwrap(); + let mut events = Vec::new(); + let reported = encode_member_with_filter_policy_candidates_and_progress( + &data, + 0, + &FilterPolicy::Auto, + &[options, options], + Some(&mut |event| { + events.push(event); + true + }), + ) + .unwrap(); + assert_eq!(plain, reported); + assert!( + events + .iter() + .filter(|&&event| event == EncodeProgress::PassStarted) + .count() + > 2 + ); + assert_eq!(events.first(), Some(&EncodeProgress::PassStarted)); + } + + use super::*; + + #[cfg(target_os = "linux")] + #[test] + fn many_members_fit_a_small_descriptor_limit() { + const CHILD: &str = "RARS_TEST_LOW_FD_CHILD"; + if std::env::var_os(CHILD).is_none() { + let output = std::process::Command::new("sh") + .args(["-c", "ulimit -n 64 && exec \"$@\"", "sh"]) + .arg(std::env::current_exe().unwrap()) + .args([ + "--exact", + "rar50::write::compress::tests::many_members_fit_a_small_descriptor_limit", + "--test-threads=1", + "--nocapture", + ]) + .env(CHILD, "1") + .env("RAYON_NUM_THREADS", "2") + .output() + .unwrap(); + assert!( + output.status.success(), + "{}\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + return; + } + let scratch = crate::scratch::case("low-fd-members"); + let input = scratch.join("input"); + let data = b"many tiny archive members\n".repeat(8); + std::fs::write(&input, &data).unwrap(); + let sources = vec![EntrySource::from_path(&input); 128]; + let resources = WriterResources::default().with_temp_dir(&*scratch); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + for (method, solid, filter_policy) in [ + (0, false, FilterPolicy::None), + (1, false, FilterPolicy::None), + (1, true, FilterPolicy::None), + (1, false, FilterPolicy::Auto), + ] { + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid, + method, + filter_policy, + candidates: vec![options].into(), + }; + let mut members = + compress_members_reporting(&sources, plan, &resources, &|_| true).unwrap(); + assert_eq!(members.len(), sources.len()); + for member in &mut members { + assert_eq!(member.input_size, data.len() as u64); + assert_eq!(member.hash, blake2sp::hash(&data)); + let mut bytes = Vec::new(); + assert_eq!( + member.packed.copy_to(&mut bytes).unwrap(), + member.packed.len() + ); + if method != 0 { + assert!(!bytes.is_empty()); + } + } + drop(members); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 1); + } + } + + #[test] + fn solid_inputs_open_one_at_a_time_and_close_on_failure() { + use std::io::{Cursor, Seek, SeekFrom}; + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + struct Tracked { + data: Cursor>, + live: Arc, + } + impl Read for Tracked { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + self.data.read(bytes) + } + } + impl Seek for Tracked { + fn seek(&mut self, pos: SeekFrom) -> std::io::Result { + self.data.seek(pos) + } + } + impl Drop for Tracked { + fn drop(&mut self) { + self.live.fetch_sub(1, Ordering::SeqCst); + } + } + let live = Arc::new(AtomicUsize::new(0)); + let sources: Vec<_> = (0..128) + .map(|n| { + let live = live.clone(); + EntrySource::from_opener(32, move || { + assert_eq!(live.fetch_add(1, Ordering::SeqCst), 0); + Ok(Box::new(Tracked { + data: Cursor::new(vec![n; 32]), + live: live.clone(), + })) + }) + }) + .collect(); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid: true, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![options].into(), + }; + let scratch = crate::scratch::case("lazy-solid-inputs"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let result = + compress_members_reporting(&sources, plan.clone(), &resources, &|_| true).unwrap(); + assert_eq!(result.len(), sources.len()); + assert_eq!(live.load(Ordering::SeqCst), 0); + drop(result); + assert!(compress_members_reporting(&sources, plan, &resources, &|_| false).is_err()); + assert_eq!(live.load(Ordering::SeqCst), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[test] + fn whole_member_budget_includes_tree_and_parse_workspace() { + let size = 16 * 1024 * 1024; + let options = EncodeOptions::new(32) + .with_max_match_distance(size) + .with_optimal_parse(true); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: size as u64, + block_size: crate::codec::rar50::LZ_BLOCK_SIZE, + solid: false, + method: 3, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let required = whole_member_workspace(size as u64, &plan); + assert!(required >= (size * 12) as u64); + assert!(matches!( + WriterResources::new((size * 4 + 2 * 1024 * 1024) as u64) + .acquire(required, size as u64), + Err(Error::MemoryLimitExceeded { .. }) + )); + // A large configured dictionary must not charge unreachable links. + let mut larger = plan.clone(); + larger.encode_options.max_match_distance *= 2; + assert_eq!(whole_member_workspace(size as u64, &larger), required); + } + #[cfg(all( + feature = "parallel", + not(all(target_arch = "wasm32", target_os = "unknown")) + ))] + #[test] + fn whole_members_use_multiple_workers_without_changing_bytes() { + use std::collections::HashSet; + use std::sync::Mutex; + let sources: Vec<_> = (0..8) + .map(|n| { + EntrySource::from_bytes( + format!("member {n}: independent text compression\n") + .repeat(1024) + .into_bytes(), + ) + }) + .collect(); + let options = EncodeOptions::new(8); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 65536, + block_size: 65536, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![options].into(), + }; + let run = |threads, budget| { + let workers = Mutex::new(HashSet::new()); + let result = rayon::ThreadPoolBuilder::new() + .num_threads(threads) + .build() + .unwrap() + .install(|| { + compress_members_reporting( + &sources, + plan.clone(), + &WriterResources::new(budget), + &|_| { + workers.lock().unwrap().insert(std::thread::current().id()); + true + }, + ) + .unwrap() + .into_iter() + .map(|mut member| { + let mut bytes = Vec::new(); + member.packed.copy_to(&mut bytes).unwrap(); + bytes + }) + .collect::>() + }); + (result, workers.into_inner().unwrap().len()) + }; + let (serial, _) = run(1, 256 * 1024 * 1024); + let (parallel, workers) = run(4, 256 * 1024 * 1024); + assert_eq!(serial, parallel); + assert!(workers > 1); + let (limited, _) = run( + 4, + whole_member_workspace(sources[0].len().unwrap(), &plan) * 2, + ); + assert_eq!(serial, limited); + } + #[test] + fn checksums_follow_the_compression_read_including_pushback_and_empty_members() { + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + let mut data = vec![0; 65536]; + data.extend(std::iter::repeat_n(1, 65536)); + data.extend(std::iter::repeat_n(2, 65536)); + for policy in [FilterPolicy::None, FilterPolicy::Auto] { + for solid in [false, true] { + let opens = Arc::new(AtomicUsize::new(0)); + let sources: Vec<_> = [data.clone(), Vec::new()] + .into_iter() + .map(|data| { + let opens = Arc::clone(&opens); + EntrySource::from_opener(data.len() as u64, move || { + opens.fetch_add(1, Ordering::SeqCst); + Ok(Box::new(std::io::Cursor::new(data.clone()))) + }) + }) + .collect(); + let options = EncodeOptions::new(8).with_max_match_distance(131072); + let plan = CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 131072, + block_size: 65536, + solid, + method: 1, + filter_policy: policy.clone(), + candidates: vec![options].into(), + }; + let members = compress_members_reporting( + &sources, + plan, + &WriterResources::default(), + &|_| true, + ) + .unwrap(); + assert_eq!( + opens.load(Ordering::SeqCst), + 2, + "policy={policy:?}, solid={solid}" + ); + for (member, input) in members.iter().zip([data.as_slice(), &[]]) { + let mut crc = Crc32::new(); + crc.update(input); + assert_eq!(member.crc32, crc.finish()); + assert_eq!(member.hash, blake2sp::hash(input)); + } + } + } + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/engine.rs b/arca-rar/vendor/rars/src/rar50/write/engine.rs new file mode 100644 index 00000000..ee5ef53e --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/engine.rs @@ -0,0 +1,3223 @@ +//! Assembling a RAR 5 archive from prepared payloads. +//! +//! Native member spools use temporary files; bare-WASM spools retain bytes in +//! memory. Compression may load whole members; headers also allocate memory. +//! Service payloads borrow input and are encrypted in chunks during emission. +//! Quick-open data uses a quota-controlled spool. Once block lengths are known, +//! final archive output streams in one pass. The +//! workspace admission budget is not an aggregate RAM or disk quota. +//! +//! Stored payloads are reread and verified during emission. Recovery requires +//! a further pass over the preceding archive bytes, mirrored into a spool. + +use super::compress::{self, CompressPlan, CompressedMember}; +#[cfg(test)] +use super::headers::write_vint; +use super::headers::{ + block_header_image, encrypted_header_block, encrypted_main_header_block, file_specific, + header_encryption_keys, header_encryption_password, prepared_header_image, + stored_file_specific, write_end_header, write_extra_record, write_file_encryption_record, + write_hash_record_with_value, write_head_crypt, write_main_header, HeaderEncryptionKeys, + PreparedHeader, +}; +use super::layout::{resolve_layout, LayoutInputs}; +use super::{encrypt_reader_to, ArchiveEntry}; +use crate::crypto::rar50::{Rar50Keys, WRITE_KDF_COUNT_LOG}; +use crate::detect::RAR50_SIGNATURE; +use crate::rar50::{ + FHEXTRA_SUBDATA, HEAD_END, HEAD_FILE, HEAD_SERVICE, HFL_DATA, HFL_EXTRA, MHFL_RECOVERY, + MHFL_SOLID, +}; +#[cfg(feature = "recovery")] +use crate::recovery::rar5::{ + choose_recovery_memory_mode, plan_inline_recovery, streamed_recovery_with_allowance, + ReadWriteSeek, +}; +use crate::streaming::preparation::{Bytes, Owned, Records}; +use crate::streaming::Spool; +use crate::write_progress::{check_cancelled, CancellableIo, ProgressReporter}; +use crate::{Error, Result, WriterResources}; +use std::io::{Read, Write}; + +pub(super) struct EnginePlan<'a> { + pub(super) compress: CompressPlan, + pub(super) recovery_percent: Option, + pub(super) header_encrypted: bool, + pub(super) header_password: Option<&'a [u8]>, + pub(super) archive_comment: Option>, + pub(super) archive_metadata: Option>, + pub(super) metadata_record: Option<&'a crate::rar50::ArchiveMetadataRecord>, + pub(super) locked: bool, + pub(super) quick_open: bool, + pub(super) progress: Option>, +} + +pub(super) enum ArchiveCommentPlan<'a> { + Plain(&'a [u8]), + Encrypted { data: &'a [u8], password: &'a [u8] }, +} + +/// A block with its framing settled: the header bytes are final and the +/// payload only has to be copied. +struct PreparedBlock<'a> { + header: PreparedHeader, + payload: Payload<'a>, + payload_len: u64, + /// Quick-open repeats the headers of members and plain comments so a + /// reader can list an archive without walking it. + quick_open_cached: bool, + /// Index into the caller's entries; names are cloned only on error. + entry_index: Option, +} + +impl PreparedBlock<'_> { + fn len(&self) -> Result { + (self.header.len() as u64) + .checked_add(self.payload_len) + .ok_or(Error::InvalidArgument("RAR 5 archive block size overflows")) + } +} + +enum Payload<'a> { + /// Comments and services remain owned by the caller or builder. + Borrowed(&'a [u8]), + /// Copied straight from the source, which is re-read at write time. + Stored(PreparedSource), + Packed(Spool), + /// Encrypted on the way out, so the ciphertext is never stored anywhere. + Encrypted { + plain: Owned>, + keys: Rar50Keys, + iv: [u8; 16], + }, +} + +enum PlainPayload<'a> { + Borrowed(&'a [u8]), + Stored(PreparedSource), + Packed(Spool), +} + +// Member payloads cannot borrow comment/service bytes. Keeping their two +// forms distinct avoids an impossible borrowed arm during plain emission. +enum MemberPlainPayload { + Stored(PreparedSource), + Packed(Spool), +} + +impl From for PlainPayload<'_> { + fn from(member: MemberPlainPayload) -> Self { + match member { + MemberPlainPayload::Stored(source) => Self::Stored(source), + MemberPlainPayload::Packed(packed) => Self::Packed(packed), + } + } +} + +impl From for Payload<'_> { + fn from(member: MemberPlainPayload) -> Self { + match member { + MemberPlainPayload::Stored(source) => Self::Stored(source), + MemberPlainPayload::Packed(packed) => Self::Packed(packed), + } + } +} + +// A reopenable source is not a snapshot. Keep the size and integrity used by +// the header, and verify the actual emission read before reporting success. +struct PreparedSource { + source: crate::EntrySource, + len: u64, + crc32: u32, + hash: [u8; 32], +} + +impl PreparedSource { + fn new(source: &crate::EntrySource, member: &CompressedMember) -> Self { + Self { + source: source.clone(), + len: member.input_size, + crc32: member.crc32, + hash: member.hash, + } + } + + fn open(&self) -> Result { + Ok(CheckedReader { + reader: self.source.open()?, + integrity: ChecksumSink::default(), + }) + } + + fn verify(&self, integrity: ChecksumSink) -> Result<()> { + if integrity.crc.finish() != self.crc32 || integrity.hash.finalize() != self.hash { + return Err(Error::SourceChanged( + "entry source contents changed while writing", + )); + } + Ok(()) + } +} + +struct CheckedReader { + reader: Box, + integrity: ChecksumSink, +} + +impl Read for CheckedReader { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + let read = self.reader.read(buffer)?; + self.integrity.write_all(&buffer[..read])?; + Ok(read) + } +} + +impl CheckedReader { + fn finish(mut self, source: &PreparedSource, observed: u64) -> Result<()> { + crate::write_stream::check_source_length( + &mut *self.reader, + observed, + source.len, + "entry source size changed while writing", + )?; + source.verify(self.integrity) + } +} + +// Both archive and volume emission report and account for one aggregate input +// length. Caller-provided source lengths need not fit that sum even when each +// length fits a member header. Reject overflow before any payload read. +fn total_input_size(entries: &[ArchiveEntry]) -> Result { + entries.iter().try_fold(0u64, |total, entry| { + let length = entry + .source + .len() + .map_err(|error| member_error(error, &entry.name, "preparing"))?; + total.checked_add(length).ok_or_else(|| { + member_error( + Error::InvalidArgument("RAR 5 writer total input size overflows"), + &entry.name, + "preparing", + ) + }) + }) +} + +pub(super) fn write_archive( + entries: &[ArchiveEntry], + plan: EnginePlan<'_>, + resources: &WriterResources, + output: &mut dyn Write, +) -> Result<()> { + let mut controlled_output = CancellableIo { + inner: output, + progress: plan.progress, + }; + let output: &mut dyn Write = &mut controlled_output; + for entry in entries { + super::validate_entry(entry)?; + } + + let header_keys = if plan.header_encrypted { + let password = header_encryption_password( + plan.header_password + .into_iter() + .chain(entries.iter().filter_map(|entry| entry.password.as_deref())), + )?; + Some(header_encryption_keys(password)?) + } else { + None + }; + + let mut sources = Records::new(entries.len(), resources)?; + for entry in entries { + sources.push(entry.source.clone())?; + } + let total_input = total_input_size(entries)?; + let total_entries = entries.len(); + if let Some(progress) = plan.progress { + progress.report(crate::WriteProgressEvent::OperationStarted { + operation: crate::WriteOperation::Compression, + total_bytes: Some(total_input), + total_entries: Some(total_entries), + pass: 1, + }); + } + let work = crate::write_progress::WorkTracker::new( + plan.progress, + crate::WriteOperation::Compression, + total_input, + ); + let compressed = compress::compress_members_with_context( + &sources, + &plan.compress, + resources, + &MemberProgress { + entries, + work: &work, + }, + &|index, error| member_error(error, &entries[index].name, "compressing"), + )?; + + // Everything between the main header and the quick-open block, in order. + // Entries and their owned service vectors contain records larger than a byte + // in disjoint live storage. Their combined count fits usize, including + // the single optional archive comment. This relies on services being owned + // vectors, rather than shared or borrowed lists counted repeatedly. + let block_count = entries.iter().fold( + usize::from(plan.archive_comment.is_some()), + |total, entry| total + 1 + entry.services.len(), + ); + let mut blocks = Records::::new(block_count, resources)?; + if let Some(comment) = &plan.archive_comment { + blocks.push(prepare_comment(comment, header_keys.as_ref(), resources)?)?; + } + for (index, (entry, member)) in entries.iter().zip(compressed).enumerate() { + check_cancelled(plan.progress)?; + let mut block = prepare_member(entry, member, &plan, header_keys.as_ref(), resources) + .map_err(|error| member_error(error, &entry.name, "preparing"))?; + block.entry_index = Some(index); + blocks.push(block)?; + for service in &entry.services { + let mut block = prepare_service(service, header_keys.as_ref(), resources) + .map_err(|error| member_error(error, &entry.name, "preparing service"))?; + block.entry_index = Some(index); + blocks.push(block)?; + } + } + if !work.finish() { + return Err(Error::Cancelled); + } + if let Some(progress) = plan.progress { + progress.report(crate::WriteProgressEvent::OperationFinished { + operation: crate::WriteOperation::Compression, + total_bytes: Some(total_input), + total_entries: Some(total_entries), + pass: 1, + }); + } + + let body_len = blocks.iter().try_fold(0u64, |total, block| { + total + .checked_add(block.len()?) + .ok_or(Error::InvalidArgument("RAR 5 archive body size overflows")) + })?; + + // Quick-open stores how far back each cached header sits from the + // quick-open block itself. Both move together when the prefix grows, so + // the distances only need positions within the body. + let quick_open_payload = if plan.quick_open { + let mut payload = Spool::create(resources)?; + let mut checksum = crate::crc32::Crc32::new(); + let mut offset = 0u64; + for block in &blocks { + check_cancelled(plan.progress)?; + if block.quick_open_cached { + append_quick_open_entry( + &mut payload, + &mut checksum, + body_len - offset, + &block.header, + )?; + } + offset += block.len()?; + } + let payload_len = payload.len(); + let header = stored_service_header( + b"QO", + payload_len, + checksum.finish(), + &[], + header_keys.as_ref(), + resources, + )?; + payload.park(); + Some(PreparedBlock { + header, + payload: Payload::Packed(payload), + payload_len, + quick_open_cached: false, + entry_index: None, + }) + } else { + None + }; + + let head_crypt = match &header_keys { + Some(keys) => { + let mut block = Bytes::new(resources); + write_head_crypt(&mut block, keys, resources)?; + block + } + None => Bytes::new(resources), + }; + + let mut main_flags = if plan.locked { + crate::rar50::MHFL_LOCKED + } else { + 0 + }; + if plan.compress.solid { + main_flags |= MHFL_SOLID; + } + if plan.recovery_percent.is_some() { + main_flags |= MHFL_RECOVERY; + } + + let layout = resolve_layout( + &LayoutInputs { + header_encrypted: plan.header_encrypted, + head_crypt_len: head_crypt.len() as u64, + main_flags, + volume_number: None, + archive_metadata: plan.archive_metadata, + metadata_record: plan.metadata_record, + body_len, + quick_open_payload_len: quick_open_payload.as_ref().map(|block| block.payload_len), + recovery_percent: plan.recovery_percent, + }, + resources, + )?; + + report_emission(plan.progress, true); + // Only mirror the archive when a recovery record has to read it back. + let mut mirror = match plan.recovery_percent { + Some(_) => Some(Spool::create(resources)?), + None => None, + }; + { + let mut sink = Tee { + output, + mirror: mirror.as_mut(), + }; + + let main = match &header_keys { + Some(keys) => encrypted_main_header_block( + &keys.keys, + main_flags, + None, + &layout.main_extra, + resources, + )?, + None => { + let mut main = Bytes::new(resources); + write_main_header(&mut main, main_flags, None, &layout.main_extra, resources)?; + main + } + }; + // The layout predicted this before any of it existed. If the + // prediction is off, every offset in the locator is off with it. + debug_assert_eq!( + main.len() as u64, + layout.main_header_len, + "main header size differs from the size its layout was built on" + ); + + sink.write_all(RAR50_SIGNATURE)?; + sink.write_all(&head_crypt)?; + sink.write_all(&main)?; + + for block in blocks { + let entry_index = block.entry_index; + let result = (|| { + sink.write_all(&block.header)?; + write_payload(block.payload, &mut sink, resources, plan.progress) + })(); + result.map_err(|error| match entry_index { + Some(index) => member_error(error, &entries[index].name, "writing"), + None => error, + })?; + } + + if let Some(block) = quick_open_payload { + sink.write_all(&block.header)?; + write_payload(block.payload, &mut sink, resources, plan.progress)?; + } + } + + if let Some(recovery_percent) = plan.recovery_percent { + let mirror = mirror.as_mut().expect("recovery mirrors the archive"); + // The recovery block has to start exactly where the locator in the + // main header says it does. + debug_assert_eq!(layout.recovery_prefix_len, Some(mirror.len())); + debug_assert_eq!( + layout.recovery_offset, + Some(mirror.len() - RAR50_SIGNATURE.len() as u64), + "recovery record is not where the locator points" + ); + write_recovery_service( + recovery_percent, + mirror, + header_keys.as_ref(), + resources, + plan.progress, + output, + )?; + } + + match &header_keys { + Some(keys) => output.write_all(&encrypted_header_block( + &keys.keys, + HEAD_END, + 0, + None, + &super::end_header_specific(0), + &[], + &[], + resources, + )?)?, + None => { + let mut end = Bytes::new(resources); + write_end_header(&mut end, 0, resources)?; + output.write_all(&end)?; + } + } + check_cancelled(plan.progress)?; + report_emission(plan.progress, false); + Ok(()) +} + +/// Appends one quick-open record: how far back the header sits, then the +/// header itself. +/// +/// The wrapper is `CRC32 || BlockSize || body`, and the checksum covers +/// `BlockSize` as well as the body. That is easy to get backwards, because the +/// length is written after the checksum it is part of. Checksumming the body +/// alone costs nothing visible: readers reject the wrapper, fall back to +/// walking the block chain, and report the archive as fine while the index +/// they were handed goes unused. +fn append_quick_open_entry( + payload: &mut dyn Write, + payload_crc: &mut crate::crc32::Crc32, + distance: u64, + header: &[u8], +) -> Result<()> { + // At most three u64 vints. Keep framing on the stack and borrow the header + // instead of cloning it into body and wrapper buffers. + fn vint(out: &mut [u8], mut value: u64) -> usize { + let mut len = 0; + loop { + out[len] = (value as u8 & 0x7f) | if value >= 0x80 { 0x80 } else { 0 }; + len += 1; + value >>= 7; + if value == 0 { + return len; + } + } + } + let mut body_prefix = [0; 21]; + let mut len = 1; // Flags = 0. + len += vint(&mut body_prefix[len..], distance); + len += vint(&mut body_prefix[len..], header.len() as u64); + let body_len = (header.len() as u64) + .checked_add(len as u64) + .ok_or(Error::InvalidArgument( + "RAR 5 quick-open record size overflows", + ))?; + let mut size = [0; 10]; + let size_len = vint(&mut size, body_len); + let parts = [&size[..size_len], &body_prefix[..len], header]; + let mut crc = crate::crc32::Crc32::new(); + for part in parts { + crc.update(part); + } + // Combine the small framing fields into one write to the native spool. + let mut framing = [0; 35]; + framing[..4].copy_from_slice(&crc.finish().to_le_bytes()); + framing[4..4 + size_len].copy_from_slice(&size[..size_len]); + let framing_len = 4 + size_len + len; + framing[4 + size_len..framing_len].copy_from_slice(&body_prefix[..len]); + for part in [&framing[..framing_len], header] { + payload.write_all(part)?; + payload_crc.update(part); + } + Ok(()) +} + +/// A stored service block borrowing a named payload such as a comment. +fn stored_service_block<'a>( + name: &[u8], + data: &'a [u8], + service_data: &[u8], + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result> { + Ok(PreparedBlock { + header: stored_service_header( + name, + data.len() as u64, + crate::crc32::crc32(data), + service_data, + header_keys, + resources, + )?, + payload: Payload::Borrowed(data), + payload_len: data.len() as u64, + quick_open_cached: false, + entry_index: None, + }) +} + +fn stored_service_header( + name: &[u8], + data_len: u64, + crc32: u32, + service_data: &[u8], + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result { + let mut extra = Bytes::new(resources); + write_extra_record(&mut extra, FHEXTRA_SUBDATA, service_data)?; + let specific = stored_file_specific(name, data_len, crc32, 0, None, 0, resources)?; + prepared_header_image( + HEAD_SERVICE, + HFL_EXTRA | HFL_DATA, + Some(data_len), + &specific, + &extra, + header_keys, + resources, + ) +} + +fn prepare_comment<'a>( + comment: &ArchiveCommentPlan<'a>, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result> { + match comment { + ArchiveCommentPlan::Plain(data) => { + let mut block = stored_service_block(b"CMT", data, &[], header_keys, resources)?; + // Plain comments are listed by quick-open; encrypted ones are not. + block.quick_open_cached = header_keys.is_none(); + Ok(block) + } + ArchiveCommentPlan::Encrypted { data, password } => { + encrypted_service_block(b"CMT", data, &[], password, header_keys, resources) + } + } +} + +fn prepare_service<'a>( + service: &'a super::ServiceEntry, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result> { + match service.password.as_deref() { + Some(password) => encrypted_service_block( + &service.name, + &service.data, + &[], + password, + header_keys, + resources, + ), + None => stored_service_block(&service.name, &service.data, &[], header_keys, resources), + } +} + +/// A service block whose borrowed payload is encrypted during emission. +fn encrypted_service_block<'a>( + name: &[u8], + data: &'a [u8], + service_data: &[u8], + password: &[u8], + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result> { + super::validate_nonempty_password(password)?; + let mut salt = [0u8; 16]; + let mut iv = [0u8; 16]; + crate::write_stream::fill_entropy( + &mut salt, + "RAR 5 writer could not generate encryption salt", + )?; + crate::write_stream::fill_entropy(&mut iv, "RAR 5 writer could not generate encryption IV")?; + let keys = Rar50Keys::derive(password, salt, WRITE_KDF_COUNT_LOG).map_err(Error::from)?; + + let mut extra = Bytes::new(resources); + write_extra_record(&mut extra, FHEXTRA_SUBDATA, service_data)?; + write_file_encryption_record(&mut extra, salt, iv, keys.checked_password_record()?)?; + write_hash_record_with_value( + &mut extra, + keys.checked_hash_mac(crate::rar50::blake2sp::hash(data))?, + )?; + let specific = stored_file_specific( + name, + data.len() as u64, + keys.checked_crc_mac(crate::crc32::crc32(data))?, + 0, + None, + 0, + resources, + )?; + let payload_len = (data.len() as u64) + .checked_add(15) + .ok_or(Error::InvalidArgument( + "RAR 5 encrypted data size overflows", + ))? + & !15; + let header = prepared_header_image( + HEAD_SERVICE, + HFL_EXTRA | HFL_DATA, + Some(payload_len), + &specific, + &extra, + header_keys, + resources, + )?; + Ok(PreparedBlock { + header, + payload: Payload::Encrypted { + plain: Owned::new(PlainPayload::Borrowed(data), resources)?, + keys, + iv, + }, + payload_len, + quick_open_cached: false, + entry_index: None, + }) +} + +fn decoded_rar50_name_len(bytes: &[u8]) -> usize { + let Ok(text) = std::str::from_utf8(bytes) else { + return bytes.len(); + }; + if !text.contains('\u{fffe}') { + return bytes.len(); + } + text.chars() + .map(|ch| match ch { + '\u{fffe}' => 0, + '\u{e080}'..='\u{e0ff}' => 1, + _ => ch.len_utf8(), + }) + .sum() +} + +/// Builds a member's final header and decides how its payload will be written. +fn prepare_member( + entry: &ArchiveEntry, + member: CompressedMember, + plan: &EnginePlan<'_>, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result> { + let compression_info = compress::member_compression_info(&plan.compress, &member)?; + let plain_len = if member.store { + member.input_size + } else { + member.packed.len() + }; + let plain = if member.store { + MemberPlainPayload::Stored(PreparedSource::new(&entry.source, &member)) + } else { + MemberPlainPayload::Packed(member.packed) + }; + + let mut extra = Bytes::new(resources); + let (payload, payload_len, data_crc32, hash) = match entry.password.as_deref() { + Some(password) => { + let mut salt = [0u8; 16]; + let mut iv = [0u8; 16]; + crate::write_stream::fill_entropy( + &mut salt, + "RAR 5 writer could not generate encryption salt", + )?; + crate::write_stream::fill_entropy( + &mut iv, + "RAR 5 writer could not generate encryption IV", + )?; + let keys = + Rar50Keys::derive(password, salt, WRITE_KDF_COUNT_LOG).map_err(Error::from)?; + write_file_encryption_record(&mut extra, salt, iv, keys.checked_password_record()?)?; + let crc32 = keys.checked_crc_mac(member.crc32)?; + let hash = keys.checked_hash_mac(member.hash)?; + ( + Payload::Encrypted { + plain: Owned::new(plain.into(), resources)?, + keys, + iv, + }, + // Encryption pads the payload up to the cipher block size. + plain_len.div_ceil(16) * 16, + crc32, + hash, + ) + } + None => (plain.into(), plain_len, member.crc32, member.hash), + }; + // A link has no file payload to hash; its target is protected by the header CRC. + if entry.redirection.is_none() { + write_hash_record_with_value(&mut extra, hash)?; + } + super::headers::write_mtime_record(&mut extra, entry.mtime, entry.mtime_nanoseconds)?; + if let Some(times) = entry.file_times { + write_extra_record(&mut extra, super::super::FHEXTRA_HTIME, ×.encode()?)?; + } + if let Some(link) = &entry.redirection { + let mut record = Bytes::new(resources); + record.vint(link.redirection_type)?; + record.vint(link.flags)?; + record.vint(link.target_name.len() as u64)?; + record.extend_from_slice(&link.target_name)?; + write_extra_record(&mut extra, super::super::FHEXTRA_REDIR, &record)?; + } + + let specific = file_specific( + &entry.name, + // Match Unix link stat size, while the packed payload remains empty. + entry + .redirection + .as_ref() + .map_or(member.input_size, |link| { + entry + .redirection_size + .unwrap_or_else(|| decoded_rar50_name_len(&link.target_name) as u64) + }), + data_crc32, + entry.attributes, + entry.mtime.filter(|_| entry.mtime_nanoseconds.is_none()), + compression_info, + entry.host_os, + entry.is_directory, + resources, + )?; + let header = prepared_header_image( + HEAD_FILE, + HFL_EXTRA | HFL_DATA, + Some(payload_len), + &specific, + &extra, + header_keys, + resources, + )?; + + Ok(PreparedBlock { + header, + payload, + payload_len, + quick_open_cached: true, + entry_index: None, + }) +} + +fn write_payload( + payload: Payload<'_>, + output: &mut dyn Write, + resources: &WriterResources, + progress: Option>, +) -> Result<()> { + check_cancelled(progress)?; + match payload { + Payload::Borrowed(data) => { + output.write_all(data)?; + Ok(()) + } + Payload::Stored(source) => { + let mut reader = source.open()?; + let copied = std::io::copy(&mut reader.by_ref().take(source.len), output)?; + reader.finish(&source, copied)?; + source.source.release(); + Ok(()) + } + Payload::Packed(mut packed) => { + packed.copy_to(output)?; + Ok(()) + } + Payload::Encrypted { plain, keys, iv } => { + const ENCRYPT_CHUNK: usize = 64 * 1024; + let chunk_size = match &*plain { + PlainPayload::Borrowed(data) => { + data.len().clamp(1, ENCRYPT_CHUNK).div_ceil(16) * 16 + } + _ => ENCRYPT_CHUNK, + }; + let _permit = resources.acquire_cancellable(chunk_size as u64, 0, &|| { + progress.is_some_and(ProgressReporter::is_cancelled) + })?; + match plain.into_inner() { + PlainPayload::Stored(source) => { + let mut reader = source.open()?; + encrypt_reader_to( + &mut reader, + source.len, + output, + &keys, + iv, + ENCRYPT_CHUNK, + progress, + resources, + )?; + reader.finish(&source, source.len)?; + source.source.release(); + Ok(()) + } + PlainPayload::Packed(mut packed) => { + let len = packed.len(); + packed.rewind()?; + encrypt_reader_to( + &mut packed, + len, + output, + &keys, + iv, + ENCRYPT_CHUNK, + progress, + resources, + ) + } + PlainPayload::Borrowed(mut data) => { + let len = data.len() as u64; + encrypt_reader_to( + &mut data, len, output, &keys, iv, chunk_size, progress, resources, + ) + } + } + } + } +} + +/// Computes the recovery record over `prefix` and writes its service block. +fn write_recovery_service( + recovery_percent: u64, + prefix: &mut Spool, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, + progress: Option>, + output: &mut dyn Write, +) -> Result { + #[cfg(not(feature = "recovery"))] + { + let _ = ( + recovery_percent, + prefix, + header_keys, + resources, + progress, + output, + ); + Err(Error::FeatureDisabled { + feature: "recovery", + }) + } + #[cfg(feature = "recovery")] + { + if let Some(allowance) = &resources.execution { + return recovery_service_with_allowance( + recovery_percent, + prefix, + header_keys, + resources, + progress, + output, + allowance, + ); + } + recovery_service_with_allowance( + recovery_percent, + prefix, + header_keys, + resources, + progress, + output, + &crate::codec::workspace::Allowance::default(), + ) + } +} + +#[cfg(feature = "recovery")] +fn recovery_service_with_allowance( + recovery_percent: u64, + prefix: &mut Spool, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, + progress: Option>, + output: &mut dyn Write, + allowance: &B, +) -> Result { + let prefix_len = prefix.len(); + let plan = plan_inline_recovery(prefix_len, recovery_percent)?; + let (mode, required) = choose_recovery_memory_mode(plan, resources.memory_limit())?; + let (mode, required) = if let Some(allowance) = &resources.execution { + crate::recovery::rar5::choose_recovery_capacity_mode( + plan, + resources.memory_limit(), + allowance, + )? + } else { + (mode, required) + }; + let _permit = resources.acquire_cancellable(required, 0, &|| { + progress.is_some_and(ProgressReporter::is_cancelled) + })?; + + let mut scratch = match mode { + crate::recovery::rar5::RecoveryMemoryMode::Striped { .. } => { + Some(Spool::create(resources)?) + } + crate::recovery::rar5::RecoveryMemoryMode::Resident => None, + }; + let mut payload = Spool::create(resources)?; + prefix.rewind()?; + let built = streamed_recovery_with_allowance( + &mut CancellableIo { + inner: prefix, + progress, + }, + prefix_len, + plan, + mode, + scratch + .as_mut() + .map(|scratch| scratch as &mut dyn ReadWriteSeek), + &mut CancellableIo { + inner: &mut payload, + progress, + }, + progress, + 1, + allowance, + ) + .map_err(|error| { + if check_cancelled(progress).is_err() { + Error::Cancelled + } else { + error.into() + } + })?; + + debug_assert_eq!(built.plan.payload_size(), Ok(built.payload_len)); + + let mut service_data = Bytes::new(resources); + service_data.vint(recovery_percent)?; + let mut extra = Bytes::new(resources); + write_extra_record(&mut extra, FHEXTRA_SUBDATA, &service_data)?; + let specific = stored_file_specific( + b"RR", + built.payload_len, + built.payload_crc32, + 0, + None, + 0, + resources, + )?; + let header = match header_keys { + Some(keys) => encrypted_header_block( + &keys.keys, + HEAD_SERVICE, + HFL_EXTRA | HFL_DATA, + Some(built.payload_len), + &specific, + &extra, + &[], + resources, + )?, + None => block_header_image( + HEAD_SERVICE, + HFL_EXTRA | HFL_DATA, + Some(built.payload_len), + &specific, + &extra, + resources, + )?, + }; + output.write_all(&header)?; + payload.copy_to(output)?; + Ok(header.len() as u64 + built.payload_len) +} + +/// Writes to the archive and, when a recovery record is coming, keeps a copy +/// for the parity pass to read. +struct Tee<'a> { + output: &'a mut dyn Write, + mirror: Option<&'a mut Spool>, +} + +impl Write for Tee<'_> { + fn write(&mut self, buffer: &[u8]) -> std::io::Result { + self.output.write_all(buffer)?; + if let Some(mirror) = self.mirror.as_mut() { + mirror.write_all(buffer)?; + } + Ok(buffer.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.output.flush() + } +} + +/// Where a member's payload bytes come from when a volume set slices them up. +enum FragmentSource { + Packed(Spool), + Stored { + prepared: PreparedSource, + emitted: Owned, + }, +} + +impl FragmentSource { + /// Checksums of the bytes a fragment will store, read ahead of writing them. + /// + /// The fragment's header carries these and the header goes out before the + /// payload, so the range is read twice: once here and once to copy it. The + /// alternative is patching the fields after the copy, which an encrypted + /// header will not allow. + fn checksums_range( + &mut self, + start: u64, + len: u64, + progress: Option>, + ) -> Result { + let mut sink = ChecksumSink::default(); + self.copy_range_unverified( + start, + len, + &mut CancellableIo { + inner: &mut sink, + progress, + }, + )?; + Ok(FragmentChecksums { + crc32: sink.crc.finish(), + hash: sink.hash.finalize(), + }) + } + + fn emit_range( + &mut self, + start: u64, + len: u64, + output: &mut dyn Write, + expected_fragment: Option, + resources: &WriterResources, + ) -> Result<()> { + let Self::Stored { prepared, emitted } = self else { + return self.copy_range_unverified(start, len, output); + }; + let mut buffer = Bytes::zeroed(64 * 1024, resources)?; + let mut reader = prepared.source.open()?; + reader.seek(std::io::SeekFrom::Start(start))?; + let mut fragment = ChecksumSink::default(); + let mut remaining = len; + while remaining != 0 { + let want = remaining.min(buffer.len() as u64) as usize; + reader.read_exact(&mut buffer[..want])?; + output.write_all(&buffer[..want])?; + emitted.write_all(&buffer[..want])?; + if expected_fragment.is_some() { + fragment.write_all(&buffer[..want])?; + } + remaining -= want as u64; + } + if let Some(expected) = expected_fragment { + if fragment.crc.finish() != expected.crc32 || fragment.hash.finalize() != expected.hash + { + return Err(Error::SourceChanged( + "entry source contents changed while writing", + )); + } + } + if start + len == prepared.len { + crate::write_stream::check_source_length( + &mut *reader, + start + len, + prepared.len, + "entry source size changed while writing", + )?; + prepared.verify(std::mem::take(&mut **emitted))?; + } + Ok(()) + } + + fn copy_range_unverified( + &mut self, + start: u64, + len: u64, + output: &mut dyn Write, + ) -> Result<()> { + match self { + Self::Packed(spool) => { + spool.copy_range_to(start, len, output)?; + } + Self::Stored { prepared, .. } => { + let mut reader = prepared.source.open()?; + reader.seek(std::io::SeekFrom::Start(start))?; + let copied = std::io::copy(&mut reader.by_ref().take(len), output)?; + if copied != len { + return Err(Error::SourceChanged( + "entry source size changed while writing", + )); + } + } + } + Ok(()) + } +} + +/// What a fragment that is not the last one reports about its own bytes. +#[derive(Clone, Copy)] +struct FragmentChecksums { + crc32: u32, + hash: [u8; 32], +} + +/// Discards what it is given and keeps the running checksums. +struct ChecksumSink { + crc: crate::crc32::Crc32, + hash: crate::rar50::blake2sp::Hasher, +} + +impl Default for ChecksumSink { + fn default() -> Self { + Self { + crc: crate::crc32::Crc32::new(), + hash: crate::rar50::blake2sp::Hasher::new(), + } + } +} + +impl Write for ChecksumSink { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.crc.update(buf); + self.hash.update(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +/// A member ready to be sliced across volumes. +struct VolumeMember<'a> { + name: &'a [u8], + is_directory: bool, + mtime: Option, + mtime_nanoseconds: Option, + file_times: Option, + attributes: u64, + host_os: u64, + unpacked_size: u64, + crc32: u32, + hash: [u8; 32], + compression_info: u64, + payload_len: u64, + source: FragmentSource, + /// Encryption record for the file header, when the payload is encrypted. + encryption: Option<([u8; 16], [u8; 16], [u8; 12])>, +} + +struct MemberProgress<'a, 'p> { + entries: &'a [ArchiveEntry], + work: &'a crate::write_progress::WorkTracker<'p>, +} +impl compress::CompressionProgress for MemberProgress<'_, '_> { + fn is_cancelled(&self) -> bool { + self.work.is_cancelled() + } + fn advance(&self, bytes: u64) -> bool { + self.work.advance(bytes) + } + fn started(&self, index: usize, size: u64) { + self.work + .entry_started(index, self.entries.len(), &self.entries[index].name, size); + } + fn finished(&self, index: usize, size: u64) { + self.work + .entry_finished(index, self.entries.len(), &self.entries[index].name, size); + } +} + +/// Writes a multi-volume archive, handing each volume to `sink` as it is +/// finished rather than keeping the set in memory. +pub(super) fn write_volumes( + entries: &[ArchiveEntry], + plan: EnginePlan<'_>, + max_payload_per_volume: u64, + sink: &mut dyn super::VolumeSink, + resources: &WriterResources, +) -> Result<()> { + if max_payload_per_volume == 0 { + return Err(Error::InvalidArgument("RAR 5 volume payload size is zero")); + } + for entry in entries { + super::validate_entry(entry)?; + } + + let header_keys = if plan.header_encrypted { + let password = header_encryption_password( + plan.header_password + .into_iter() + .chain(entries.iter().filter_map(|entry| entry.password.as_deref())), + )?; + Some(header_encryption_keys(password)?) + } else { + None + }; + + let mut sources = Records::new(entries.len(), resources)?; + for entry in entries { + sources.push(entry.source.clone())?; + } + let total_input = total_input_size(entries)?; + let total_entries = entries.len(); + if let Some(progress) = plan.progress { + progress.report(crate::WriteProgressEvent::OperationStarted { + operation: crate::WriteOperation::Compression, + total_bytes: Some(total_input), + total_entries: Some(total_entries), + pass: 1, + }); + } + let work = crate::write_progress::WorkTracker::new( + plan.progress, + crate::WriteOperation::Compression, + total_input, + ); + let compressed = compress::compress_members_with_context( + &sources, + &plan.compress, + resources, + &MemberProgress { + entries, + work: &work, + }, + &|index, error| member_error(error, &entries[index].name, "compressing"), + )?; + + let mut members = Records::new(entries.len(), resources)?; + for (entry, member) in entries.iter().zip(compressed) { + check_cancelled(plan.progress)?; + members.push( + prepare_volume_member(entry, member, &plan, resources) + .map_err(|error| member_error(error, &entry.name, "preparing volume payload"))?, + )?; + } + if !work.finish() { + return Err(Error::Cancelled); + } + if let Some(progress) = plan.progress { + progress.report(crate::WriteProgressEvent::OperationFinished { + operation: crate::WriteOperation::Compression, + total_bytes: Some(total_input), + total_entries: Some(total_entries), + pass: 1, + }); + } + + report_emission(plan.progress, true); + let mut writer = VolumeWriter { + max_payload_per_volume, + solid: plan.compress.solid, + recovery_percent: plan.recovery_percent, + header_keys: header_keys.as_ref(), + progress: plan.progress, + resources, + sink, + body: None, + payload_in_volume: 0, + volume_index: 0, + }; + + for mut member in members { + writer + .write_member(&mut member) + .map_err(|error| member_error(error, member.name, "writing volume member"))?; + } + writer.finish()?; + check_cancelled(plan.progress)?; + report_emission(plan.progress, false); + Ok(()) +} + +/// Compresses and, if needed, encrypts one member into a form that can be cut +/// at any byte boundary. +fn prepare_volume_member<'a>( + entry: &'a ArchiveEntry, + member: CompressedMember, + plan: &EnginePlan<'_>, + resources: &WriterResources, +) -> Result> { + let progress = plan.progress; + check_cancelled(progress)?; + let compression_info = compress::member_compression_info(&plan.compress, &member)?; + let plain_len = if member.store { + member.input_size + } else { + member.packed.len() + }; + + match entry.password.as_deref() { + Some(password) => { + let mut salt = [0u8; 16]; + let mut iv = [0u8; 16]; + crate::write_stream::fill_entropy( + &mut salt, + "RAR 5 writer could not generate encryption salt", + )?; + crate::write_stream::fill_entropy( + &mut iv, + "RAR 5 writer could not generate encryption IV", + )?; + let keys = + Rar50Keys::derive(password, salt, WRITE_KDF_COUNT_LOG).map_err(Error::from)?; + + // A volume boundary can fall anywhere, and the cipher runs as one + // chain over the member, so encrypt it up front into scratch + // storage and slice the ciphertext. + let mut encrypted = Spool::create(resources)?; + const ENCRYPT_CHUNK: usize = 64 * 1024; + let _permit = resources.acquire_cancellable(ENCRYPT_CHUNK as u64, 0, &|| { + progress.is_some_and(ProgressReporter::is_cancelled) + })?; + if member.store { + let source = PreparedSource::new(&entry.source, &member); + let mut reader = source.open()?; + encrypt_reader_to( + &mut reader, + plain_len, + &mut encrypted, + &keys, + iv, + ENCRYPT_CHUNK, + progress, + resources, + )?; + reader.finish(&source, source.len)?; + } else { + let mut packed = member.packed; + packed.rewind()?; + encrypt_reader_to( + &mut packed, + plain_len, + &mut encrypted, + &keys, + iv, + ENCRYPT_CHUNK, + progress, + resources, + )?; + } + let payload_len = encrypted.len(); + encrypted.park(); + Ok(VolumeMember { + name: &entry.name, + is_directory: entry.is_directory, + mtime: entry.mtime, + mtime_nanoseconds: entry.mtime_nanoseconds, + file_times: entry.file_times, + attributes: entry.attributes, + host_os: entry.host_os, + unpacked_size: member.input_size, + crc32: keys.checked_crc_mac(member.crc32)?, + hash: keys.checked_hash_mac(member.hash)?, + compression_info, + payload_len, + source: FragmentSource::Packed(encrypted), + encryption: Some((salt, iv, keys.checked_password_record()?)), + }) + } + None => Ok(VolumeMember { + name: &entry.name, + is_directory: entry.is_directory, + mtime: entry.mtime, + mtime_nanoseconds: entry.mtime_nanoseconds, + file_times: entry.file_times, + attributes: entry.attributes, + host_os: entry.host_os, + unpacked_size: member.input_size, + crc32: member.crc32, + hash: member.hash, + compression_info, + payload_len: plain_len, + source: if member.store { + FragmentSource::Stored { + prepared: PreparedSource::new(&entry.source, &member), + emitted: Owned::new(ChecksumSink::default(), resources)?, + } + } else { + FragmentSource::Packed(member.packed) + }, + encryption: None, + }), + } +} + +struct VolumeWriter<'a> { + max_payload_per_volume: u64, + solid: bool, + recovery_percent: Option, + header_keys: Option<&'a HeaderEncryptionKeys>, + progress: Option>, + resources: &'a WriterResources, + sink: &'a mut dyn super::VolumeSink, + /// Body of the volume being filled, held on disk rather than in memory. + body: Option, + payload_in_volume: u64, + volume_index: u64, +} + +impl VolumeWriter<'_> { + /// Cuts one member across as many volumes as it takes. + fn write_member(&mut self, member: &mut VolumeMember) -> Result<()> { + check_cancelled(self.progress)?; + let mut start = 0u64; + let mut split_before = false; + // Zero-length members still need a header of their own. + loop { + // A volume that filled exactly is left open until something asks + // for room, because until then we cannot say whether it is the last + // one, and its end-of-archive block has to say which. + if self.body.is_some() && self.payload_in_volume == self.max_payload_per_volume { + self.finish_volume(true)?; + } + if self.body.is_none() { + self.start_volume()?; + } + let room = self.max_payload_per_volume - self.payload_in_volume; + let remaining = member.payload_len - start; + let fragment_len = room.min(remaining); + let split_after = start + fragment_len < member.payload_len; + // A fragment that is not the last one has no whole-member checksum + // to report, so the field carries the CRC32 of the bytes this + // volume stores. That is what WinRAR puts there, and it lets a + // single volume be checked on its own. + let fragment_checksums = match split_after { + true => Some( + member + .source + .checksums_range(start, fragment_len, self.progress)?, + ), + false => None, + }; + + let header = fragment_header( + member, + fragment_len, + split_before, + fragment_checksums, + self.header_keys, + self.resources, + )?; + let body = self.body.as_mut().expect("volume started"); + body.write_all(&header)?; + member.source.emit_range( + start, + fragment_len, + &mut CancellableIo { + inner: body, + progress: self.progress, + }, + fragment_checksums, + self.resources, + )?; + + self.payload_in_volume += fragment_len; + start += fragment_len; + split_before = true; + + if start >= member.payload_len { + return Ok(()); + } + } + } + + fn finish(mut self) -> Result<()> { + // The public volume entry point rejects empty member lists; each + // nonempty member starts a volume, even when its payload is empty. + self.finish_volume(false) + } + + fn start_volume(&mut self) -> Result<()> { + self.body = Some(Spool::create(self.resources)?); + self.payload_in_volume = 0; + Ok(()) + } + + fn finish_volume(&mut self, more_volumes_follow: bool) -> Result<()> { + let mut body = self.body.take().expect("volume started"); + let volume_number = self.volume_index; + self.volume_index += 1; + self.payload_in_volume = 0; + + let head_crypt = match self.header_keys { + Some(keys) => { + let mut block = Bytes::new(self.resources); + write_head_crypt(&mut block, keys, self.resources)?; + block + } + None => Bytes::new(self.resources), + }; + + let mut main_flags = crate::rar50::MHFL_VOLUME | crate::rar50::MHFL_VOLUME_NUMBER; + if self.solid { + main_flags |= MHFL_SOLID; + } + if self.recovery_percent.is_some() { + main_flags |= MHFL_RECOVERY; + } + + let layout = resolve_layout( + &LayoutInputs { + header_encrypted: self.header_keys.is_some(), + head_crypt_len: head_crypt.len() as u64, + main_flags, + volume_number: Some(volume_number), + archive_metadata: None, + metadata_record: None, + body_len: body.len(), + quick_open_payload_len: None, + recovery_percent: self.recovery_percent, + }, + self.resources, + )?; + + check_cancelled(self.progress)?; + let raw_output = self.sink.start_volume(volume_number)?; + let mut output = CancellableIo { + inner: raw_output, + progress: self.progress, + }; + let mut mirror = match self.recovery_percent { + Some(_) => Some(Spool::create(self.resources)?), + None => None, + }; + let mut written; + { + let mut tee = Tee { + output: &mut output, + mirror: mirror.as_mut(), + }; + let main = match self.header_keys { + Some(keys) => encrypted_main_header_block( + &keys.keys, + main_flags, + Some(volume_number), + &layout.main_extra, + self.resources, + )?, + None => { + let mut main = Bytes::new(self.resources); + write_main_header( + &mut main, + main_flags, + Some(volume_number), + &layout.main_extra, + self.resources, + )?; + main + } + }; + debug_assert_eq!(main.len() as u64, layout.main_header_len); + + tee.write_all(RAR50_SIGNATURE)?; + tee.write_all(&head_crypt)?; + tee.write_all(&main)?; + body.rewind()?; + std::io::copy(&mut body, &mut tee)?; + written = RAR50_SIGNATURE.len() as u64 + + head_crypt.len() as u64 + + main.len() as u64 + + body.len(); + } + + if let Some(recovery_percent) = self.recovery_percent { + let mirror = mirror.as_mut().expect("recovery mirrors the volume"); + debug_assert_eq!(layout.recovery_prefix_len, Some(mirror.len())); + written += write_recovery_service( + recovery_percent, + mirror, + self.header_keys, + self.resources, + self.progress, + &mut output, + )?; + } + + let end_flags = if more_volumes_follow { + crate::rar50::EFL_NEXT_VOLUME + } else { + 0 + }; + let end = match self.header_keys { + Some(keys) => encrypted_header_block( + &keys.keys, + HEAD_END, + 0, + None, + &super::end_header_specific(end_flags), + &[], + &[], + self.resources, + )?, + None => { + let mut end = Bytes::new(self.resources); + write_end_header(&mut end, end_flags, self.resources)?; + end + } + }; + output.write_all(&end)?; + written += end.len() as u64; + output.flush()?; + drop(output); + + self.sink.finish_volume(volume_number, written) + } +} + +/// Builds the file header for one fragment of a member. +/// +/// Every fragment repeats the member's metadata. The last one carries the +/// member's own checksum and hash; the rest carry `fragment` over the bytes +/// they store, which is what WinRAR puts there and lets one volume be checked +/// on its own. Encrypted fragments checksum the ciphertext, so that check needs +/// no password. +/// +/// Both a CRC32 and a hash record go on every fragment. A reader takes the hash +/// record as the member's checksum type when it has one, and unrar picks that +/// type from the first fragment and compares it against the last, so a fragment +/// that offered only a CRC32 while the last offered a hash would fail a member +/// that is perfectly intact. +fn fragment_header( + member: &VolumeMember, + fragment_len: u64, + split_before: bool, + fragment: Option, + header_keys: Option<&HeaderEncryptionKeys>, + resources: &WriterResources, +) -> Result { + let split_after = fragment.is_some(); + let mut extra = Bytes::new(resources); + if let Some((salt, iv, check_value)) = member.encryption { + write_file_encryption_record(&mut extra, salt, iv, check_value)?; + } + write_hash_record_with_value(&mut extra, fragment.map_or(member.hash, |f| f.hash))?; + super::headers::write_mtime_record(&mut extra, member.mtime, member.mtime_nanoseconds)?; + if let Some(times) = member.file_times { + write_extra_record(&mut extra, super::super::FHEXTRA_HTIME, ×.encode()?)?; + } + let specific = file_specific( + member.name, + member.unpacked_size, + fragment.map_or(member.crc32, |f| f.crc32), + member.attributes, + member.mtime.filter(|_| member.mtime_nanoseconds.is_none()), + member.compression_info, + member.host_os, + member.is_directory, + resources, + )?; + + // Every fragment has a hash record, so its extra area is never empty. + let mut flags = HFL_DATA | HFL_EXTRA; + if split_before { + flags |= crate::rar50::HFL_SPLIT_BEFORE; + } + if split_after { + flags |= crate::rar50::HFL_SPLIT_AFTER; + } + match header_keys { + Some(keys) => encrypted_header_block( + &keys.keys, + HEAD_FILE, + flags, + Some(fragment_len), + &specific, + &extra, + &[], + resources, + ), + None => block_header_image( + HEAD_FILE, + flags, + Some(fragment_len), + &specific, + &extra, + resources, + ), + } +} + +fn report_emission(progress: Option>, started: bool) { + use crate::{WriteOperation, WriteProgressEvent}; + if let Some(progress) = progress { + progress.report(if started { + WriteProgressEvent::OperationStarted { + operation: WriteOperation::Emission, + total_bytes: None, + total_entries: None, + pass: 1, + } + } else { + WriteProgressEvent::OperationFinished { + operation: WriteOperation::Emission, + total_bytes: None, + total_entries: None, + pass: 1, + } + }); + } +} + +fn member_error(error: Error, name: &[u8], operation: &'static str) -> Error { + // Cancellation remains an operation-level result. A streaming fallback can + // already have supplied the same member context; do not duplicate it. + if error.kind() == crate::ErrorKind::Cancelled + || error + .entry_context() + .is_some_and(|(existing, _)| existing == name) + { + error + } else { + error.at_entry(name.to_vec(), operation) + } +} + +#[cfg(test)] +mod input_size_tests { + use super::*; + + #[test] + fn writer_adapters_flush_the_output_and_preserve_checksums() { + struct FlushingSink { + bytes: Vec, + flushes: usize, + fail: bool, + } + + impl Write for FlushingSink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.bytes.extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.flushes += 1; + if self.fail { + Err(std::io::Error::other("injected flush failure")) + } else { + Ok(()) + } + } + } + + let mut output = FlushingSink { + bytes: Vec::new(), + flushes: 0, + fail: false, + }; + { + let mut tee = Tee { + output: &mut output, + mirror: None, + }; + tee.write_all(b"payload").unwrap(); + tee.flush().unwrap(); + } + assert_eq!(output.bytes, b"payload"); + assert_eq!(output.flushes, 1); + output.fail = true; + assert_eq!( + Tee { + output: &mut output, + mirror: None, + } + .flush() + .unwrap_err() + .to_string(), + "injected flush failure" + ); + assert_eq!(output.flushes, 2); + + let mut checksum = ChecksumSink::default(); + checksum.write_all(b"payload").unwrap(); + checksum.flush().unwrap(); + assert_eq!(checksum.crc.finish(), crate::crc32::crc32(b"payload")); + } + + fn virtual_entry(name: &[u8], length: u64) -> ArchiveEntry { + ArchiveEntry::new( + name.to_vec(), + crate::EntrySource::from_opener(length, || panic!("measuring input opened a source")), + ) + } + + #[test] + fn total_input_size_accepts_empty_and_exact_u64_maximum() { + assert_eq!(total_input_size(&[]).unwrap(), 0); + let entries = [ + virtual_entry(b"first", u64::MAX - 1), + virtual_entry(b"last", 1), + virtual_entry(b"empty", 0), + ]; + assert_eq!(total_input_size(&entries).unwrap(), u64::MAX); + } + + #[test] + fn total_input_size_preserves_source_errors_and_cancellation() { + struct Broken(bool); + impl crate::streaming::SourceFactory for Broken { + fn len(&self) -> Result { + if self.0 { + Err(Error::Cancelled) + } else { + Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "injected metadata failure", + ) + .into()) + } + } + fn open(&self) -> Result> { + panic!("measuring input opened a source") + } + } + for cancelled in [false, true] { + let entry = ArchiveEntry::new( + b"broken".to_vec(), + crate::EntrySource::from_factory(Broken(cancelled)), + ); + let error = total_input_size(&[entry]).unwrap_err(); + if cancelled { + assert_eq!(error, Error::Cancelled); + assert!(error.entry_context().is_none()); + } else { + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context().unwrap(), + (b"broken".as_slice(), "preparing") + ); + } + } + } +} + +#[cfg(test)] +mod quick_open_tests { + use super::*; + + #[test] + fn streamed_records_match_buffered_encoding_at_vint_boundaries() { + for distance in [0, 127, 128, 16383, 16384, u64::MAX] { + for size in [0, 1, 123, 127, 128, 16383, 16384] { + let header = vec![0xa5; size]; + let mut body = Vec::new(); + write_vint(&mut body, 0); + write_vint(&mut body, distance); + write_vint(&mut body, size as u64); + body.extend_from_slice(&header); + let mut framed = Vec::new(); + write_vint(&mut framed, body.len() as u64); + framed.extend_from_slice(&body); + let mut expected = crate::crc32::crc32(&framed).to_le_bytes().to_vec(); + expected.extend_from_slice(&framed); + let mut actual = Vec::new(); + let mut crc = crate::crc32::Crc32::new(); + append_quick_open_entry(&mut actual, &mut crc, distance, &header).unwrap(); + assert_eq!(actual, expected); + assert_eq!(crc.finish(), crate::crc32::crc32(&actual)); + } + } + } +} + +#[cfg(test)] +mod service_payload_tests { + use super::*; + + #[test] + fn prepared_services_borrow_input_and_stream_identical_ciphertext() { + for size in [0usize, 1, 15, 16, 65535, 65536, 65537, 131089] { + let data: Vec = (0..size).map(|i| (i % 251) as u8).collect(); + let plain = stored_service_block(b"CMT", &data, &[], None, &WriterResources::default()) + .unwrap(); + let Payload::Borrowed(borrowed) = plain.payload else { + panic!("expected borrowed service") + }; + assert_eq!(borrowed.as_ptr(), data.as_ptr()); + assert_eq!(borrowed.len(), data.len()); + #[cfg(feature = "encryption")] + { + let encrypted = encrypted_service_block( + b"CMT", + &data, + &[], + b"secret", + None, + &WriterResources::default(), + ) + .unwrap(); + let Payload::Encrypted { plain, keys, iv } = &encrypted.payload else { + panic!("expected streaming encryption") + }; + let PlainPayload::Borrowed(borrowed) = plain.as_ref() else { + panic!("expected borrowed plaintext") + }; + assert_eq!(borrowed.as_ptr(), data.as_ptr()); + let mut expected = data.clone(); + expected.resize(size.div_ceil(16) * 16, 0); + crate::crypto::rar50::Rar50Cipher::new(keys.key, *iv) + .encrypt_in_place(&mut expected) + .unwrap(); + assert_eq!(encrypted.payload_len, expected.len() as u64); + let mut actual = Vec::new(); + write_payload( + encrypted.payload, + &mut actual, + &WriterResources::default(), + None, + ) + .unwrap(); + assert_eq!(actual, expected, "service size {size}"); + } + } + } +} + +#[cfg(test)] +mod preparation_name_tests { + use super::*; + #[test] + fn allocation_free_target_length_preserves_rar50_mapping_rules() { + for bytes in [ + b"plain".as_slice(), + b"\xffinvalid", + "é/å��å­—".as_bytes(), + "\u{e080}".as_bytes(), + "\u{fffe}a\u{e080}\u{e0ff}é".as_bytes(), + "\u{fffe}\u{fffe}".as_bytes(), + ] { + assert_eq!( + decoded_rar50_name_len(bytes), + crate::filename::decode_rar50(bytes).len() + ); + } + } +} + +#[cfg(test)] +mod emission_ledger_tests { + use super::*; + use crate::codec::workspace::Allowance; + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn source_disappearing_at_compression_start_retains_member_context() { + use std::sync::atomic::{AtomicBool, Ordering}; + for volumes in [false, true] { + let scratch = crate::scratch::case("source-disappears-before-compression"); + let path = scratch.join("source"); + std::fs::write(&path, b"payload").unwrap(); + let entries = [ArchiveEntry::new( + b"missing.bin".to_vec(), + crate::EntrySource::from_path(&path), + )]; + let resources = WriterResources::new(128 * 1024 * 1024) + .with_max_memory_bytes(128 * 1024 * 1024) + .with_temp_dir(&*scratch); + let removed = AtomicBool::new(false); + let callback = |event: crate::WriteProgressEvent<'_>| { + if matches!( + event, + crate::WriteProgressEvent::OperationStarted { + operation: crate::WriteOperation::Compression, + .. + } + ) && !removed.swap(true, Ordering::Relaxed) + { + std::fs::remove_file(&path).unwrap(); + } + }; + let mut plan = plan(false); + plan.progress = Some(ProgressReporter(&callback)); + let error = if volumes { + let mut output = super::super::CollectedVolumes::new(); + let error = write_volumes(&entries, plan, 64, &mut output, &resources).unwrap_err(); + assert!(output.take().is_empty()); + error + } else { + let mut output = Vec::new(); + let error = write_archive(&entries, plan, &resources, &mut output).unwrap_err(); + assert!(output.is_empty()); + error + }; + assert!(removed.load(Ordering::Relaxed)); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context(), + Some((b"missing.bin".as_slice(), "compressing")) + ); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(resources.managed_memory_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn zero_volume_payload_is_rejected_before_opening_a_sink() { + let entries = [ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + )]; + let mut sink = super::super::CollectedVolumes::new(); + let error = write_volumes( + &entries, + plan(false), + 0, + &mut sink, + &WriterResources::default(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument); + assert!(sink.take().is_empty()); + } + + #[test] + fn prepared_record_counts_include_empty_archives_comments_and_services() { + // The aggregate bound uses distinct live storage for owned records. + assert!(std::mem::size_of::() >= 2); + assert!(std::mem::size_of::() >= 2); + for count in 0..=2 { + for comment in [false, true] { + let entries: Vec<_> = (0..count) + .map(|index| { + let entry = ArchiveEntry::new( + format!("file{index}").into_bytes(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + ); + if index == 1 { + entry.with_service(super::super::ServiceEntry::new(b"CMT", b"note")) + } else { + entry + } + }) + .collect(); + let mut settings = plan(false); + settings.compress.method = 0; + settings.quick_open = false; + settings.recovery_percent = None; + if !comment { + settings.archive_comment = None; + } + let mut bytes = Vec::new(); + write_archive(&entries, settings, &WriterResources::default(), &mut bytes).unwrap(); + let archive = crate::ArchiveReader::read_owned(bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + assert_eq!(raw.files().count(), count); + assert_eq!( + raw.services().count(), + usize::from(comment) + usize::from(count == 2) + ); + for index in 0..count { + assert_eq!( + archive + .read_member(format!("file{index}").as_bytes(), None) + .unwrap() + .unwrap(), + b"payload" + ); + } + } + } + } + + #[test] + fn compression_completion_cancellation_precedes_archive_and_volume_emission() { + use std::sync::atomic::{AtomicBool, Ordering}; + struct CancelAtCompletion { + armed: AtomicBool, + cancelled: AtomicBool, + finished: AtomicBool, + emitted: AtomicBool, + } + impl crate::WriteProgress for CancelAtCompletion { + fn report(&self, event: crate::WriteProgressEvent<'_>) { + use crate::{WriteOperation, WriteProgressEvent}; + match event { + WriteProgressEvent::OperationStarted { + operation: WriteOperation::Compression, + total_entries: Some(0), + .. + } + | WriteProgressEvent::EntryFinished { + operation: WriteOperation::Compression, + .. + } => self.armed.store(true, Ordering::Relaxed), + WriteProgressEvent::Advanced { + operation: WriteOperation::Compression, + .. + } if self.armed.load(Ordering::Relaxed) => { + self.cancelled.store(true, Ordering::Relaxed); + } + WriteProgressEvent::OperationFinished { + operation: WriteOperation::Compression, + .. + } => self.finished.store(true, Ordering::Relaxed), + WriteProgressEvent::OperationStarted { + operation: WriteOperation::Emission, + .. + } => self.emitted.store(true, Ordering::Relaxed), + _ => {} + } + } + fn is_cancelled(&self) -> bool { + self.cancelled.load(Ordering::Relaxed) + } + } + for empty in [false, true] { + for volumes in [false, true] { + let scratch = crate::scratch::case("completion-cancellation"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let progress = CancelAtCompletion { + armed: AtomicBool::new(false), + cancelled: AtomicBool::new(false), + finished: AtomicBool::new(false), + emitted: AtomicBool::new(false), + }; + let entries = if empty { + Vec::new() + } else { + vec![ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + )] + }; + let mut settings = plan(false); + settings.archive_comment = None; + settings.recovery_percent = None; + settings.progress = Some(ProgressReporter(&progress)); + let error = if volumes { + let mut sink = super::super::CollectedVolumes::new(); + let error = + write_volumes(&entries, settings, 1024, &mut sink, &resources).unwrap_err(); + assert!(sink.take().is_empty()); + error + } else { + let mut output = Vec::new(); + let error = + write_archive(&entries, settings, &resources, &mut output).unwrap_err(); + assert!(output.is_empty()); + error + }; + assert_eq!(error, Error::Cancelled); + assert!(progress.armed.load(Ordering::Relaxed)); + assert!(progress.cancelled.load(Ordering::Relaxed)); + assert!(!progress.finished.load(Ordering::Relaxed)); + assert!(!progress.emitted.load(Ordering::Relaxed)); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + } + + #[test] + fn quick_open_skips_file_services_but_keeps_plain_comments() { + let entry = ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + ) + .with_service(super::super::ServiceEntry::new(b"CMT", b"file note")); + let mut plan = plan(false); + plan.quick_open = true; + plan.recovery_percent = None; + let mut bytes = Vec::new(); + write_archive(&[entry], plan, &WriterResources::default(), &mut bytes).unwrap(); + + let archive = crate::ArchiveReader::read_owned(bytes).unwrap(); + let raw = archive.as_rar50().unwrap(); + assert!(raw.main.locator().unwrap().quick_open_offset.is_some()); + let quick_open = raw + .services() + .find(|service| service.name == b"QO") + .unwrap(); + let payload = quick_open.packed_data(raw).unwrap(); + fn vint(data: &[u8], cursor: &mut usize) -> usize { + let mut value = 0usize; + for shift in (0..70).step_by(7) { + let byte = data[*cursor]; + *cursor += 1; + value |= ((byte & 0x7f) as usize) << shift; + if byte & 0x80 == 0 { + return value; + } + } + panic!("invalid quick-open record length") + } + let mut cursor = 0; + let mut records = 0; + while cursor < payload.len() { + cursor += 4; // Per-record CRC32. + let body_len = vint(&payload, &mut cursor); + cursor += body_len; + assert!(cursor <= payload.len()); + records += 1; + } + // The plain archive comment and file are cached; the attached service is not. + assert_eq!(records, 2); + assert_eq!( + archive.member_comment_at(0, None).unwrap(), + Some(b"file note".to_vec()) + ); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } + + struct FailingSink; + impl Write for FailingSink { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::other("injected emission failure")) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + #[test] + fn archive_emission_propagates_each_output_write_failure() { + struct FailOnWrite { + fail_at: usize, + writes: usize, + } + impl Write for FailOnWrite { + fn write(&mut self, data: &[u8]) -> std::io::Result { + let call = self.writes; + self.writes += 1; + if call == self.fail_at { + Err(std::io::Error::other("injected output failure")) + } else { + Ok(data.len()) + } + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let entries = [ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + )]; + let settings = || { + let mut plan = plan(false); + plan.recovery_percent = None; + plan.quick_open = true; + plan + }; + let resources = WriterResources::default(); + let mut counting = FailOnWrite { + fail_at: usize::MAX, + writes: 0, + }; + write_archive(&entries, settings(), &resources, &mut counting).unwrap(); + assert!(counting.writes >= 6); + + let mut member_failure = false; + let mut archive_failure = false; + for fail_at in 0..counting.writes { + let mut sink = FailOnWrite { fail_at, writes: 0 }; + let error = write_archive(&entries, settings(), &resources, &mut sink).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io, "write {fail_at}"); + assert_eq!(sink.writes, fail_at + 1); + if error.entry_context() == Some((b"file".as_slice(), "writing")) { + member_failure = true; + } else { + archive_failure = true; + } + } + assert!(member_failure); + assert!(archive_failure); + } + + #[test] + fn volume_emission_propagates_sink_failures_before_handoff() { + use std::sync::{Arc, Mutex}; + + #[derive(Default)] + struct State { + writes: usize, + finishes: usize, + } + struct Sink { + state: Arc>, + fail_write: Option, + fail_start: bool, + fail_flush: bool, + fail_finish: bool, + } + struct Volume { + state: Arc>, + fail_write: Option, + fail_flush: bool, + } + impl Write for Volume { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + let mut state = self.state.lock().unwrap(); + let call = state.writes; + state.writes += 1; + if self.fail_write == Some(call) { + Err(std::io::Error::other("injected volume write failure")) + } else { + Ok(bytes.len()) + } + } + fn flush(&mut self) -> std::io::Result<()> { + if self.fail_flush { + Err(std::io::Error::other("injected volume flush failure")) + } else { + Ok(()) + } + } + } + impl super::super::VolumeSink for Sink { + fn start_volume(&mut self, _: u64) -> Result> { + if self.fail_start { + return Err(std::io::Error::other("injected volume start failure").into()); + } + Ok(Box::new(Volume { + state: self.state.clone(), + fail_write: self.fail_write, + fail_flush: self.fail_flush, + })) + } + fn finish_volume(&mut self, _: u64, _: u64) -> Result<()> { + self.state.lock().unwrap().finishes += 1; + if self.fail_finish { + Err(std::io::Error::other("injected volume finish failure").into()) + } else { + Ok(()) + } + } + } + + let entries = [ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + )]; + let settings = || { + let mut plan = plan(false); + plan.recovery_percent = None; + plan + }; + let resources = WriterResources::default(); + let make_sink = || Sink { + state: Arc::new(Mutex::new(State::default())), + fail_write: None, + fail_start: false, + fail_flush: false, + fail_finish: false, + }; + let mut success = make_sink(); + write_volumes(&entries, settings(), 4096, &mut success, &resources).unwrap(); + let writes = success.state.lock().unwrap().writes; + assert!(writes >= 4); + assert_eq!(success.state.lock().unwrap().finishes, 1); + + for fail_at in 0..writes { + let mut sink = make_sink(); + sink.fail_write = Some(fail_at); + let error = + write_volumes(&entries, settings(), 4096, &mut sink, &resources).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io, "write {fail_at}"); + assert_eq!(sink.state.lock().unwrap().writes, fail_at + 1); + assert_eq!(sink.state.lock().unwrap().finishes, 0); + } + for failure in 0..3 { + let mut sink = make_sink(); + sink.fail_start = failure == 0; + sink.fail_flush = failure == 1; + sink.fail_finish = failure == 2; + let error = + write_volumes(&entries, settings(), 4096, &mut sink, &resources).unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + sink.state.lock().unwrap().finishes, + usize::from(failure == 2) + ); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_emission_counts_retained_preparation_and_releases_chunk() { + let data = vec![7; 65537]; + for limit in [65536, 131072] { + let ledger = Allowance::limited(limit); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + let retained = Bytes::zeroed(128, &resources).unwrap(); + for fail_sink in [false, true] { + let keys = Rar50Keys::derive(b"secret", [1; 16], WRITE_KDF_COUNT_LOG).unwrap(); + let mut expected = data.clone(); + expected.resize(data.len().div_ceil(16) * 16, 0); + crate::crypto::rar50::Rar50Cipher::new(keys.key, [2; 16]) + .encrypt_in_place(&mut expected) + .unwrap(); + let payload = Payload::Encrypted { + plain: Owned::new(PlainPayload::Borrowed(&data), &resources).unwrap(), + keys, + iv: [2; 16], + }; + let mut actual = Vec::new(); + let result = if fail_sink { + write_payload(payload, &mut FailingSink, &resources, None) + } else { + write_payload(payload, &mut actual, &resources, None) + }; + if limit == 65536 { + assert_eq!(result.unwrap_err().kind(), crate::ErrorKind::ResourceLimit); + assert!(actual.is_empty()); + } else if fail_sink { + assert!(result.is_err()); + } else { + result.unwrap(); + assert_eq!(actual, expected); + } + assert_eq!(ledger.used(), 128); + assert_eq!(resources.workspace_in_use(), 0); + } + drop(retained); + assert_eq!(ledger.used(), 0); + } + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_emission_shares_ledger_in_resident_and_striped_modes() { + let scratch = crate::scratch::case("recovery-emission-ledger"); + let data = vec![7; 131072]; + for estimated_limit in [16384, 8 * 1024 * 1024] { + let base = WriterResources::new(estimated_limit).with_temp_dir(&*scratch); + let mut prefix = Spool::create(&base).unwrap(); + prefix.write_all(&data).unwrap(); + let mut expected = Vec::new(); + write_recovery_service(10, &mut prefix, None, &base, None, &mut expected).unwrap(); + for limit in [131072, 8 * 1024 * 1024] { + let ledger = Allowance::limited(limit); + let resources = base.clone().with_execution_allowance(ledger.clone()); + let retained = Bytes::zeroed(128, &resources).unwrap(); + let mut actual = Vec::new(); + let result = + write_recovery_service(10, &mut prefix, None, &resources, None, &mut actual); + if limit == 131072 { + assert_eq!(result.unwrap_err().kind(), crate::ErrorKind::ResourceLimit); + assert!(actual.is_empty()); + } else { + result.unwrap(); + assert_eq!(actual, expected); + let cancel = CancelRecovery { + cancelled: std::sync::atomic::AtomicBool::new(false), + }; + let error = write_recovery_service( + 10, + &mut prefix, + None, + &resources, + Some(ProgressReporter(&cancel)), + &mut Vec::new(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled); + assert_eq!(ledger.used(), 128); + + assert!(write_recovery_service( + 10, + &mut prefix, + None, + &resources, + None, + &mut FailingSink + ) + .is_err()); + } + assert_eq!(ledger.used(), 128); + assert_eq!(resources.workspace_in_use(), 0); + drop(retained); + assert_eq!(ledger.used(), 0); + // The caller's prefix survives; temporary parity and payload files do not. + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 1); + } + drop(prefix); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[cfg(feature = "recovery")] + struct CancelRecovery { + cancelled: std::sync::atomic::AtomicBool, + } + #[cfg(feature = "recovery")] + impl crate::WriteProgress for CancelRecovery { + fn report(&self, event: crate::WriteProgressEvent<'_>) { + if matches!( + event, + crate::WriteProgressEvent::Advanced { + operation: crate::WriteOperation::Recovery, + .. + } + ) { + self.cancelled + .store(true, std::sync::atomic::Ordering::Relaxed); + } + } + fn is_cancelled(&self) -> bool { + self.cancelled.load(std::sync::atomic::Ordering::Relaxed) + } + } + + fn plan<'a>(encrypted: bool) -> EnginePlan<'a> { + let options = crate::codec::rar50::EncodeOptions::new(8).with_max_match_distance(131072); + EnginePlan { + compress: CompressPlan { + algorithm_version: 0, + encode_options: options, + dictionary_size: 131072, + block_size: 4096, + solid: false, + method: 0, + filter_policy: super::super::FilterPolicy::None, + candidates: vec![options].into(), + }, + recovery_percent: cfg!(feature = "recovery").then_some(10), + header_encrypted: encrypted, + header_password: encrypted.then_some(b"secret".as_slice()), + archive_comment: Some(if encrypted { + ArchiveCommentPlan::Encrypted { + data: b"comment", + password: b"secret", + } + } else { + ArchiveCommentPlan::Plain(b"comment") + }), + archive_metadata: None, + metadata_record: None, + locked: false, + quick_open: false, + progress: None, + } + } + + #[test] + fn volume_emission_reports_compression_completion() { + use std::sync::atomic::{AtomicBool, Ordering}; + + let finished = AtomicBool::new(false); + let report = |event: crate::WriteProgressEvent<'_>| { + if matches!( + event, + crate::WriteProgressEvent::OperationFinished { + operation: crate::WriteOperation::Compression, + total_bytes: Some(7), + total_entries: Some(1), + .. + } + ) { + finished.store(true, Ordering::Relaxed); + } + }; + let mut plan = plan(false); + plan.progress = Some(ProgressReporter(&report)); + plan.recovery_percent = None; + let entries = [ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + )]; + let mut sink = super::super::CollectedVolumes::new(); + write_volumes(&entries, plan, 4096, &mut sink, &WriterResources::default()).unwrap(); + assert!(finished.load(Ordering::Relaxed)); + assert_eq!(sink.take().len(), 1); + } + + #[test] + fn an_existing_member_context_is_not_wrapped_again() { + let original = + Error::InvalidArgument("source changed").at_entry(b"file".to_vec(), "reading"); + let error = member_error(original, b"file", "writing"); + assert_eq!(error.entry_context(), Some((b"file".as_slice(), "reading"))); + } + + #[test] + fn archive_and_volume_emission_keep_the_ledger_reusable() { + let scratch = crate::scratch::case("archive-emission-ledger"); + for encrypted in crate::test_features::encryption_cases() { + let mut entry = ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(vec![7; 16384]), + ); + if encrypted { + entry = entry.with_password(b"secret"); + } + let entries = [entry]; + let base = WriterResources::default().with_temp_dir(&*scratch); + let ledger = Allowance::limited(8 * 1024 * 1024); + let resources = base.clone().with_execution_allowance(ledger.clone()); + let mut expected = Vec::new(); + write_archive(&entries, plan(encrypted), &base, &mut expected).unwrap(); + let mut actual = Vec::new(); + write_archive(&entries, plan(encrypted), &resources, &mut actual).unwrap(); + if !encrypted { + assert_eq!(actual, expected); + } else { + assert_eq!(actual.len(), expected.len()); + } + assert_eq!(ledger.used(), 0); + assert!( + write_archive(&entries, plan(encrypted), &resources, &mut FailingSink).is_err() + ); + assert_eq!(ledger.used(), 0); + let mut expected = super::super::CollectedVolumes::new(); + write_volumes(&entries, plan(encrypted), 4096, &mut expected, &base).unwrap(); + let small = Allowance::limited(32768); + let constrained = base.clone().with_execution_allowance(small.clone()); + assert_eq!( + write_volumes( + &entries, + plan(encrypted), + 4096, + &mut super::super::CollectedVolumes::new(), + &constrained, + ) + .unwrap_err() + .kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(small.used(), 0); + let mut actual = super::super::CollectedVolumes::new(); + write_volumes(&entries, plan(encrypted), 4096, &mut actual, &resources).unwrap(); + let expected = expected.take(); + let actual = actual.take(); + assert_eq!(actual.len(), 4); + if !encrypted { + assert_eq!(actual, expected); + } else { + assert_eq!( + actual.iter().map(Vec::len).collect::>(), + expected.iter().map(Vec::len).collect::>() + ); + } + assert_eq!(ledger.used(), 0); + assert_eq!(resources.workspace_in_use(), 0); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + } + + #[test] + fn archive_preparation_refusals_release_capacity_at_each_boundary() { + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let mut limit = 0; + let mut refusals = 0; + loop { + let resources = WriterResources::default().with_max_preparation_bytes(limit); + let mut settings = plan(false); + settings.compress.method = 0; + settings.recovery_percent = None; + settings.quick_open = true; + let mut output = Vec::new(); + match write_archive(&entries, settings, &resources, &mut output) { + Ok(()) => { + assert!(!output.is_empty()); + break; + } + Err(error) => match error.root_cause() { + Error::WriterPreparationLimitExceeded { + limit: actual_limit, + required, + .. + } => { + assert_eq!(*actual_limit, limit); + assert!(*required > limit); + refusals += 1; + drop(Records::::new(limit as usize, &resources).unwrap()); + limit = *required; + assert!(limit < 64 * 1024, "tiny archive used too much preparation"); + } + _ => panic!("unexpected preparation failure: {error}"), + }, + } + } + assert!(refusals > 3, "the test must cross several admission sites"); + } + + #[test] + fn volume_preparation_refusals_release_capacity_at_each_boundary() { + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let mut limit = 0; + let mut refusals = 0; + loop { + let resources = WriterResources::default().with_max_preparation_bytes(limit); + let mut settings = plan(false); + settings.compress.method = 0; + settings.recovery_percent = None; + let mut volumes = super::super::CollectedVolumes::new(); + match write_volumes(&entries, settings, 4096, &mut volumes, &resources) { + Ok(()) => { + assert_eq!(volumes.take().len(), 1); + break; + } + Err(error) => match error.root_cause() { + Error::WriterPreparationLimitExceeded { + limit: actual_limit, + required, + .. + } => { + assert_eq!(*actual_limit, limit); + assert!(*required > limit); + refusals += 1; + drop(Records::::new(limit as usize, &resources).unwrap()); + limit = *required; + assert!( + limit < 1024 * 1024, + "tiny volumes used {limit} bytes of preparation" + ); + } + _ => panic!("unexpected preparation failure: {error}"), + }, + } + } + assert!(refusals > 3, "the test must cross several admission sites"); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_archive_preparation_refusals_release_capacity() { + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + ) + .with_password(b"secret")]; + let mut limit = 0; + let mut refusals = 0; + loop { + let resources = WriterResources::default().with_max_preparation_bytes(limit); + let mut settings = plan(true); + settings.compress.method = 0; + settings.recovery_percent = None; + let mut output = Vec::new(); + match write_archive(&entries, settings, &resources, &mut output) { + Ok(()) => { + assert!(!output.is_empty()); + break; + } + Err(error) => match error.root_cause() { + Error::WriterPreparationLimitExceeded { required, .. } => { + assert!(*required > limit); + refusals += 1; + drop(Records::::new(limit as usize, &resources).unwrap()); + limit = *required; + assert!( + limit < 64 * 1024, + "encrypted archive used too much preparation" + ); + } + _ => panic!("unexpected preparation failure: {error}"), + }, + } + } + assert!(refusals > 3); + } + + #[test] + fn oversized_archive_metadata_is_refused_during_layout_before_output() { + let name = vec![b'm'; 4096]; + let mut settings = plan(false); + settings.archive_comment = None; + settings.recovery_percent = None; + settings.archive_metadata = Some(super::super::ArchiveMetadataEntry { + name: Some(&name), + creation_time: Some(1), + }); + let resources = WriterResources::default().with_max_preparation_bytes(128); + let mut output = Vec::new(); + let error = write_archive(&[], settings, &resources, &mut output).unwrap_err(); + assert!(matches!( + error, + Error::WriterPreparationLimitExceeded { limit: 128, .. } + )); + assert!(output.is_empty()); + drop(Records::::new(128, &resources).unwrap()); + } + + #[test] + fn archive_service_preparation_failure_preserves_member_context() { + for encrypted in crate::test_features::encryption_cases() { + let mut service = super::super::ServiceEntry::new(b"CMT", b"note"); + if encrypted { + service = service.with_password(b"secret"); + } + let mut entry = ArchiveEntry::new( + b"member".to_vec(), + crate::EntrySource::from_bytes(b"payload".to_vec()), + ); + for _ in 0..8 { + entry = entry.with_service(service.clone()); + } + let mut limit = 0; + let mut service_refused = false; + loop { + let mut settings = plan(false); + settings.archive_comment = None; + settings.recovery_percent = None; + let resources = WriterResources::default().with_max_preparation_bytes(limit); + let mut output = Vec::new(); + let result = write_archive( + std::slice::from_ref(&entry), + settings, + &resources, + &mut output, + ); + assert_eq!(resources.workspace_in_use(), 0); + drop(Records::::new(limit as usize, &resources).unwrap()); + match result { + Ok(()) => { + assert!(!output.is_empty()); + assert!(service_refused); + break; + } + Err(error) => { + assert!(output.is_empty()); + let Error::WriterPreparationLimitExceeded { + required, + limit: actual, + .. + } = error.root_cause() + else { + panic!("unexpected preparation failure: {error}"); + }; + assert_eq!(*actual, limit); + assert!(*required > limit); + service_refused |= error.entry_context() + == Some((b"member".as_slice(), "preparing service")); + limit = *required; + assert!(limit < 64 * 1024); + } + } + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_service_rejects_oversized_name_after_extra_preparation() { + let name = vec![b'n'; 4096]; + let resources = WriterResources::default().with_max_preparation_bytes(512); + let error = encrypted_service_block(&name, b"payload", &[], b"secret", None, &resources) + .err() + .expect("the service name exceeds the preparation quota"); + assert!(matches!( + error, + Error::WriterPreparationLimitExceeded { limit: 512, .. } + )); + drop(Records::::new(512, &resources).unwrap()); + } + + #[test] + fn archive_releases_preparation_for_each_injected_admission_failure() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let run = |resources: &WriterResources| -> Result> { + let mut settings = plan(false); + settings.compress.method = 0; + settings.recovery_percent = None; + settings.quick_open = true; + let mut output = Vec::new(); + write_archive(&entries, settings, resources, &mut output)?; + Ok(output) + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + assert!(!run(&resources).unwrap().is_empty()); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 10); + assert!(count < 200, "unexpectedly many preparation admissions"); + assert_eq!(resources.preparation_in_use(), 0); + + for index in 0..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + + #[test] + fn volumes_release_preparation_for_each_injected_admission_failure() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let run = |resources: &WriterResources| -> Result { + let mut settings = plan(false); + settings.compress.method = 0; + settings.recovery_percent = None; + let mut volumes = super::super::CollectedVolumes::new(); + write_volumes(&entries, settings, 4096, &mut volumes, resources)?; + Ok(volumes.take().len()) + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + assert_eq!(run(&resources).unwrap(), 1); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 10); + assert!(count < 200, "unexpectedly many preparation admissions"); + assert_eq!(resources.preparation_in_use(), 0); + + for index in 0..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_releases_preparation_for_each_injected_admission_failure() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let run = |resources: &WriterResources| -> Result> { + let mut settings = plan(false); + settings.compress.method = 0; + let mut output = Vec::new(); + write_archive(&entries, settings, resources, &mut output)?; + Ok(output) + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + assert!(!run(&resources).unwrap().is_empty()); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 10); + assert!(count < 200, "unexpectedly many preparation admissions"); + assert_eq!(resources.preparation_in_use(), 0); + + for index in 0..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + + #[test] + #[cfg(feature = "recovery")] + fn volume_recovery_releases_preparation_for_each_injected_admission_failure() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + )]; + let run = |resources: &WriterResources| -> Result { + let mut settings = plan(false); + settings.compress.method = 0; + let mut volumes = super::super::CollectedVolumes::new(); + write_volumes(&entries, settings, 4096, &mut volumes, resources)?; + Ok(volumes.take().len()) + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + assert!(run(&resources).unwrap() > 0); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 10); + assert!(count < 200, "unexpectedly many preparation admissions"); + assert_eq!(resources.preparation_in_use(), 0); + + for index in 0..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_outputs_release_late_preparation_refusals() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + ) + .with_password(b"secret")]; + for volumes in [false, true] { + let run = |resources: &WriterResources| -> Result<()> { + let mut settings = plan(true); + settings.compress.method = 0; + settings.recovery_percent = None; + settings.archive_comment = None; + if volumes { + write_volumes( + &entries, + settings, + 4096, + &mut super::super::CollectedVolumes::new(), + resources, + ) + } else { + write_archive(&entries, settings, resources, &mut Vec::new()) + } + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + run(&resources).unwrap(); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 3); + assert!(count < 200); + assert_eq!(resources.preparation_in_use(), 0); + + for index in count - 3..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "volume mode {volumes}, admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + #[cfg(feature = "recovery")] + fn encrypted_recovery_releases_late_preparation_refusals() { + use std::sync::atomic::Ordering; + + let entries = [ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(b"contents".to_vec()), + ) + .with_password(b"secret")]; + let run = |resources: &WriterResources| -> Result<()> { + let mut settings = plan(true); + settings.compress.method = 0; + settings.archive_comment = None; + write_archive(&entries, settings, resources, &mut Vec::new()) + }; + let (resources, attempts) = + WriterResources::default().refuse_preparation_growth_at(usize::MAX); + run(&resources).unwrap(); + let count = attempts.load(Ordering::Relaxed); + assert!(count > 5); + assert_eq!(resources.preparation_in_use(), 0); + + for index in count - 5..count { + let (resources, _) = WriterResources::default().refuse_preparation_growth_at(index); + let error = run(&resources).unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::WriterFailure("injected preparation admission failure"), + "admission {index}" + ); + assert_eq!(resources.preparation_in_use(), 0, "admission {index}"); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_volume_reread_failure_keeps_member_context() { + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + + let opens = Arc::new(AtomicUsize::new(0)); + let source = crate::EntrySource::from_opener(8, { + let opens = opens.clone(); + move || { + if opens.fetch_add(1, Ordering::Relaxed) == 0 { + Ok(Box::new(std::io::Cursor::new(b"contents".to_vec()))) + } else { + Err(std::io::Error::other("injected encrypted reread failure").into()) + } + } + }); + let entries = [ArchiveEntry::new(b"payload".to_vec(), source).with_password(b"secret")]; + let mut settings = plan(false); + settings.compress.method = 0; + settings.archive_comment = None; + settings.recovery_percent = None; + let mut volumes = super::super::CollectedVolumes::new(); + let error = write_volumes( + &entries, + settings, + 4096, + &mut volumes, + &WriterResources::default(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!( + error.entry_context(), + Some((b"payload".as_slice(), "preparing volume payload")) + ); + assert_eq!(opens.load(Ordering::Relaxed), 2); + assert!(volumes.take().is_empty()); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_compressed_volume_payload_propagates_spool_refusal() { + let scratch = crate::scratch::case("encrypted-volume-spool-refusal"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let entry = ArchiveEntry::new( + b"payload".to_vec(), + crate::EntrySource::from_bytes(vec![b'A'; 64 * 1024]), + ) + .with_password(b"secret"); + let mut settings = plan(false); + settings.compress.method = 1; + settings.recovery_percent = None; + let member = compress::compress_members_reporting( + std::slice::from_ref(&entry.source), + settings.compress.clone(), + &resources, + &|_| true, + ) + .unwrap() + .remove(0); + assert!(!member.store); + + let constrained = resources.clone().with_max_spool_bytes(0); + let error = prepare_volume_member(&entry, member, &settings, &constrained) + .err() + .expect("encrypted ciphertext must be charged to its spool"); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/filter_policy.rs b/arca-rar/vendor/rars/src/rar50/write/filter_policy.rs new file mode 100644 index 00000000..f1327539 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/filter_policy.rs @@ -0,0 +1,961 @@ +use super::*; +use crate::codec::rar50::EncodeOptions; +#[cfg(test)] +use crate::codec::rar50::{ + encode_lz_member_with_options, encode_lz_member_with_options_and_progress, Unpack50Encoder, +}; +#[cfg(test)] +use crate::codec::workspace::Allowance; +use crate::codec::workspace::{Budget, Buffer}; +use crate::filter_search::{encode_pass, EncodeProgress, OwnedSearch}; + +fn borrow_progress<'a>( + progress: &'a mut Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Option<&'a mut dyn FnMut(EncodeProgress) -> bool> { + match progress { + Some(report) => Some(&mut **report), + None => None, + } +} + +#[cfg(test)] +pub(super) fn encode_member_with_filter_policy_and_progress( + data: &[u8], + algorithm_version: u8, + policy: &FilterPolicy, + options: EncodeOptions, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Result> { + policy_with_allowance( + data, + algorithm_version, + policy, + options, + progress, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} +#[cfg(test)] +pub(super) fn encode_member_with_filter_policy_candidates_and_progress( + data: &[u8], + algorithm_version: u8, + policy: &FilterPolicy, + candidates: &[EncodeOptions], + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Result> { + candidates_with_allowance( + data, + algorithm_version, + policy, + candidates, + progress, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} +pub(super) fn candidates_with_allowance( + data: &[u8], + algorithm_version: u8, + policy: &FilterPolicy, + candidates: &[EncodeOptions], + mut progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, + allowance: &B, +) -> Result> { + let mut remaining = candidates.iter().copied(); + let first = remaining.next().ok_or(Error::WriterFailure( + "RAR 5 compression level has no encoder options", + ))?; + + // Searching for a filter once and then trying the encoder settings against + // it is the difference between a handful of passes over the member and one + // whole search per setting. + if *policy == FilterPolicy::Auto && auto_size_filter_search_applies(data) { + let (specs, mut best) = choose_owned_filter( + data, + algorithm_version, + first, + borrow_progress(&mut progress), + allowance, + )?; + // The search already encoded the winner at the first setting, so only + // the remaining settings are left to try. + for options in remaining { + let packed = specs_with_allowance( + data, + algorithm_version, + &specs, + options, + borrow_progress(&mut progress), + allowance, + )?; + if packed.len() < best.len() { + best = packed; + } + } + return Ok(best); + } + + let mut best = policy_with_allowance( + data, + algorithm_version, + policy, + first, + borrow_progress(&mut progress), + allowance, + )?; + for options in remaining { + let packed = policy_with_allowance( + data, + algorithm_version, + policy, + options, + borrow_progress(&mut progress), + allowance, + )?; + if packed.len() < best.len() { + best = packed; + } + } + Ok(best) +} + +use crate::filter_search::search_applies as auto_size_filter_search_applies; + +/// How many bytes the encoder will walk while packing this member, for progress +/// to scale by. +pub(super) fn filter_policy_walk_bytes( + data: &[u8], + policy: &FilterPolicy, + _algorithm_version: u8, + encoder_candidates: usize, +) -> u64 { + let member = data.len() as u64; + if *policy != FilterPolicy::Auto || !auto_size_filter_search_applies(data) { + return member * encoder_candidates.max(1) as u64; + } + crate::filter_search::walk_bytes_for_kinds( + data, + SCREENED_KINDS.len() as u64, + encoder_candidates, + ) +} + +/// Whether a member compression did not help is better off stored. +/// +/// Takes lengths rather than the bytes, because the streaming path decides this +/// for a payload it has already spilled to disk. +pub(super) fn should_store_compressed_payload( + unpacked: u64, + packed: u64, + solid: bool, + policy: &FilterPolicy, +) -> bool { + // A solid member is decoded against the dictionary the members before it + // filled, so this writer can never go back and store one. + crate::write_plan::StoreFallback::new() + .filter_requested(matches!(policy, FilterPolicy::Explicit(_))) + .applies(solid, unpacked as usize, packed as usize) +} + +/// How hard each level looks for a match, and where the default sits. +/// +/// The ladder used to run 8, 32, 64, 48, 64 with the absent level on 256, so +/// asking for the most compression got you less of it than asking for nothing: +/// `--level 5` searched 64 positions where the default searched 256, and level +/// 4 searched fewer than level 3. On 4 MiB of man pages the default packed +/// 679,368 bytes and `--level 5` packed 691,274. +/// +/// Measured on that member, packed bytes against seconds, at lookahead 2: +/// +/// ```text +/// candidates 64 128 256 512 1024 +/// packed 686,891 680,315 675,746 672,645 670,061 +/// seconds 1.67 2.35 3.53 4.71 6.65 +/// ``` +/// +/// It flattens out: the last doubling buys 0.4% for another two seconds. So +/// the top of the ladder sits at 512 rather than chasing it, and level 3 stays +/// near what the default already cost. +fn match_candidates_for_level(level: u8) -> Result { + match level { + 0 => Ok(0), + 1 => Ok(8), + 2 => Ok(32), + 3 => Ok(128), + 4 => Ok(256), + 5 => Ok(512), + _ => Err(Error::InvalidArgument( + "RAR 5 compression level must be in the range 0..5", + )), + } +} + +/// The level an absent `--level` means. Resolved once, so the effort spent, the +/// method byte written and the fallback ladder cannot disagree about it. +pub(super) const RAR50_DEFAULT_LEVEL: u8 = 3; + +pub(super) fn resolved_level(level: Option) -> u8 { + level.unwrap_or(RAR50_DEFAULT_LEVEL) +} + +pub(super) fn encode_options_for_level( + level: Option, + dictionary_size: u64, +) -> Result { + let level = resolved_level(level); + let candidates = match_candidates_for_level(level)?; + let max_match_distance = usize::try_from(dictionary_size).map_err(|_| { + Error::InvalidArgument("RAR 5 dictionary size exceeds this platform's address space") + })?; + Ok(EncodeOptions::new(candidates) + // Looking one byte further ahead before settling for the match at hand + // is both smaller and quicker than not: at 64 candidates it took 4,383 + // bytes off that member and half a second off the encode, because a + // longer match covers ground the finder then does not have to search. + // Four is worse than one, which is its own question (#83). + .with_lazy_matching(level >= 2) + .with_lazy_lookahead(2) + // Everything above level 1 parses by shortest path. + // + // This used to start at level 5, which left three rungs in the middle + // doing something that could not close the distance to WinRAR whatever + // it was tuned to. Measured over the bench corpus against each level's + // own WinRAR, byte weighted, as the parse moved down the ladder: + // + // ```text + // parse from m2 m3 m4 m5 + // level 5 +7.27% +4.13% +4.16% -0.38% + // level 4 +7.27% +4.13% -0.39% -0.38% + // level 3 +3.36% -0.62% -0.39% -0.38% + // level 2 -2.07% -0.65% -0.42% -0.41% + // ``` + // + // Search depth is worth tenths of a percent across that whole range and + // the parse is worth several, so there is no setting of the other knobs + // that makes a greedy rung competitive. What the depth still buys is + // the ordering: at 32, 128, 256 and 512 candidates the parse packs + // steadily smaller for steadily more time, which is what a level is. + // + // Level 1 keeps the greedy parse. It is the rung that exists to be + // quick, it already beats WinRAR's own level 1 by 2.71%, and it is the + // only place left to go when the parse is too slow for the job. + .with_optimal_parse(level >= 2) + .with_max_match_distance(max_match_distance)) +} + +/// The encoder settings to try for a level, smallest output kept. +/// +/// One, now. Level 5 used to try levels 4 down to 1 as well, to catch a member +/// that packs smaller with less search. Over the whole bench corpus it caught +/// one byte, on one member, for four extra whole-member encodes; dropping it +/// took 28% off level 5's time and nothing off its output. +/// +/// The shape stays because the caller still asks a list, and because a future +/// setting that genuinely competes rather than merely searches less would go +/// here. +pub(super) fn encode_option_candidates_for_level( + level: Option, + dictionary_size: u64, +) -> Result<[EncodeOptions; 1]> { + Ok([encode_options_for_level(level, dictionary_size)?]) +} + +pub(super) fn rar50_algorithm_version(options: WriterOptions, dictionary_size: u64) -> Result { + match options.target { + crate::ArchiveVersion::Rar50 => Ok(0), + crate::ArchiveVersion::Rar70 => { + if dictionary_size_fields(0, dictionary_size).is_ok() { + Ok(0) + } else { + Ok(1) + } + } + _ => Err(Error::UnsupportedVersion(options.target)), + } +} + +/// The level written into the member header. +/// +/// It is the resolved level, so an archive says what it was compressed at. An +/// absent level used to write 1 while spending more search than `--level 5` +/// did, which described neither what was asked for nor what was done. +pub(super) fn compression_method_for_level(level: Option) -> Result { + let level = resolved_level(level); + match_candidates_for_level(level)?; + Ok(level) +} + +/// The largest dictionary the writer picks on its own at each level. +/// +/// The format goes far higher and `--dict-size` still does. What stops the +/// writer reaching for it is that the hash chains lengthen with the window, so +/// a wider one costs time that is not always repaid. How often it is repaid +/// depends entirely on the data. Over 16 MiB of manpage text and 16 MiB of +/// shared libraries at level 3: +/// +/// ```text +/// dictionary text seconds binary seconds +/// 1 MiB 3,480,749 6.6 4,646,481 14.1 +/// 2 MiB 2,223,009 8.1 4,590,488 25.3 +/// 4 MiB 2,061,307 14.8 4,514,109 53.0 +/// 8 MiB 2,043,138 21.7 4,505,410 83.2 +/// 16 MiB 2,040,730 27.6 4,507,232 105.0 +/// ``` +/// +/// A 1 MiB cap costs text 41% and buys binaries most of their speed. One +/// number cannot serve both, so the level picks, which is what a level is for. +/// Text keeps paying up to about 8 MiB; binaries stop at 4 and are slightly +/// worse by 16. +/// +/// Level 2 was raised off the 1 MiB floor when it gained the shortest-path +/// parse: on 4 MiB of manpage text it took 24,315 bytes off for a tenth of a +/// second, which is the same trade level 3 was already making. +fn fitted_dictionary_cap(level: u8) -> u64 { + let megabytes = match level { + 0..=1 => 1, + 2 => 4, + 3 => 4, + 4 => 8, + _ => 16, + }; + megabytes * 1024 * 1024 +} + +/// The smallest dictionary that still reaches past `content`. +/// +/// A window larger than the data cannot match anything extra, so a small member +/// keeps a small window and stays as quick as it was. Sizes are the format's +/// own: 128 KiB doubled. +pub(super) fn fitted_dictionary_size(content: u64, level: u8) -> u64 { + let cap = fitted_dictionary_cap(level); + let mut size = DEFAULT_RAR50_DICTIONARY_SIZE; + while size < cap && size <= content { + size *= 2; + } + size +} + +/// The dictionary to write with, either the caller's or one fitted to the data. +/// +/// `content` is what one window has to reach across: the whole archive when the +/// members share a dictionary, otherwise the largest member. `memory_limit` is +/// the workspace budget the write has to stay inside. +/// +/// A dictionary the caller named is validated and used as given: if it does not +/// fit the budget the write fails saying so, which is the answer to a request +/// that cannot be met. A fitted one is shrunk to fit instead, because it has no +/// business failing a write that the smaller default would have finished. +pub(super) fn dictionary_size_for_options( + options: WriterOptions, + content: u64, + memory_limit: u64, +) -> Result { + let size = match options.dictionary_size { + Some(size) => size, + None => { + let level = resolved_level(options.compression_level); + let mut fitted = fitted_dictionary_size(content, level); + // Whether the level parses optimally decides how much a window + // costs, and the level owns that answer. The size passed here does + // not change it. + let optimal_parse = encode_options_for_level(Some(level), fitted)?.optimal_parse; + while fitted > DEFAULT_RAR50_DICTIONARY_SIZE + && super::streaming_lz_workspace( + fitted, + crate::codec::rar50::MAX_LZ_BLOCK_SIZE, + optimal_parse, + ) > memory_limit + { + fitted /= 2; + } + fitted + } + }; + validate_dictionary_size(options.target, size)?; + Ok(size) +} + +pub(super) fn validate_dictionary_size(target: crate::ArchiveVersion, size: u64) -> Result<()> { + match target { + crate::ArchiveVersion::Rar50 => dictionary_size_fields(0, size).map(|_| ()), + crate::ArchiveVersion::Rar70 => dictionary_size_fields(0, size) + .or_else(|_| dictionary_size_fields(1, size)) + .map(|_| ()), + _ => Err(Error::UnsupportedVersion(target)), + } +} + +pub(super) fn dictionary_size_fields(algorithm_version: u8, size: u64) -> Result<(u8, u8)> { + if size == 0 { + return Err(Error::InvalidArgument( + "RAR 5 dictionary size must be non-zero", + )); + } + match algorithm_version { + 0 => { + if size < DEFAULT_RAR50_DICTIONARY_SIZE { + return Err(Error::InvalidArgument( + "RAR 5 v0 dictionary size must be at least 128 KiB", + )); + } + if !size.is_multiple_of(DEFAULT_RAR50_DICTIONARY_SIZE) { + return Err(Error::InvalidArgument( + "RAR 5 v0 dictionary size must be a power-of-two multiple of 128 KiB", + )); + } + let multiple = size / DEFAULT_RAR50_DICTIONARY_SIZE; + if !multiple.is_power_of_two() { + return Err(Error::InvalidArgument( + "RAR 5 v0 dictionary size must be a power-of-two multiple of 128 KiB", + )); + } + let power = multiple.trailing_zeros(); + if power > 15 { + return Err(Error::InvalidArgument( + "RAR 5 v0 dictionary size exceeds 4 GiB", + )); + } + Ok((power as u8, 0)) + } + 1 => { + if !size.is_multiple_of(4096) { + return Err(Error::InvalidArgument( + "RAR 7 dictionary size must be a multiple of 4 KiB", + )); + } + let mut units = size / 4096; + let mut power = 0u8; + while units > 63 { + if !units.is_multiple_of(2) || power == 31 { + return Err(Error::InvalidArgument( + "RAR 7 dictionary size is not encodable", + )); + } + units /= 2; + power += 1; + } + if units < 32 { + return Err(Error::InvalidArgument( + "RAR 7 dictionary size must be at least 128 KiB", + )); + } + Ok((power, (units - 32) as u8)) + } + _ => Err(Error::InvalidArgument( + "RAR 5 unknown compression algorithm version", + )), + } +} + +#[cfg(test)] +mod dictionary_encoding_tests { + use super::*; + + #[cfg(target_pointer_width = "32")] + #[test] + fn encode_options_refuse_a_valid_dictionary_above_the_host_limit() { + let size = 1u64 << 32; + assert_eq!(dictionary_size_fields(0, size).unwrap(), (15, 0)); + assert_eq!( + encode_options_for_level(Some(3), size).unwrap_err(), + Error::InvalidArgument("RAR 5 dictionary size exceeds this platform's address space") + ); + } + + #[test] + fn rar5_dictionary_boundaries_and_rejections() { + let unit = DEFAULT_RAR50_DICTIONARY_SIZE; + assert_eq!(dictionary_size_fields(0, unit).unwrap(), (0, 0)); + assert_eq!(dictionary_size_fields(0, 1u64 << 32).unwrap(), (15, 0)); + for (size, reason) in [ + ( + unit - 1, + "RAR 5 v0 dictionary size must be at least 128 KiB", + ), + ( + unit + 4096, + "RAR 5 v0 dictionary size must be a power-of-two multiple of 128 KiB", + ), + ( + unit * 3, + "RAR 5 v0 dictionary size must be a power-of-two multiple of 128 KiB", + ), + (1u64 << 33, "RAR 5 v0 dictionary size exceeds 4 GiB"), + ] { + assert_eq!( + dictionary_size_fields(0, size).unwrap_err(), + Error::InvalidArgument(reason), + "size {size}" + ); + } + } + + #[test] + fn rar7_dictionary_boundaries_and_rejections() { + assert_eq!(dictionary_size_fields(1, 128 * 1024).unwrap(), (0, 0)); + assert_eq!(dictionary_size_fields(1, 63 * 4096).unwrap(), (0, 31)); + assert_eq!(dictionary_size_fields(1, 64 * 4096).unwrap(), (1, 0)); + for (size, reason) in [ + (4096, "RAR 7 dictionary size must be at least 128 KiB"), + (65 * 4096, "RAR 7 dictionary size is not encodable"), + ( + 64u64 * (1u64 << 31) * 4096, + "RAR 7 dictionary size is not encodable", + ), + ] { + assert_eq!( + dictionary_size_fields(1, size).unwrap_err(), + Error::InvalidArgument(reason), + "size {size}" + ); + } + } + + #[test] + fn dictionary_and_compression_options_reject_unsupported_encodings() { + for level in [6, u8::MAX] { + assert_eq!( + encode_options_for_level(Some(level), 128 * 1024).unwrap_err(), + Error::InvalidArgument("RAR 5 compression level must be in the range 0..5") + ); + } + let rar5 = WriterOptions::default(); + let rar7 = WriterOptions::new( + crate::ArchiveVersion::Rar70, + crate::FeatureSet::store_only(), + ); + let fractional = 160 * 1024; + assert!(validate_dictionary_size(rar5.target, fractional).is_err()); + validate_dictionary_size(rar7.target, fractional).unwrap(); + assert_eq!(rar50_algorithm_version(rar7, 128 * 1024).unwrap(), 0); + assert_eq!(rar50_algorithm_version(rar7, fractional).unwrap(), 1); + assert_eq!( + rar50_algorithm_version( + WriterOptions::new( + crate::ArchiveVersion::Rar40, + crate::FeatureSet::store_only(), + ), + 128 * 1024, + ) + .unwrap_err(), + Error::UnsupportedVersion(crate::ArchiveVersion::Rar40) + ); + assert_eq!( + validate_dictionary_size(crate::ArchiveVersion::Rar40, 128 * 1024).unwrap_err(), + Error::UnsupportedVersion(crate::ArchiveVersion::Rar40) + ); + assert_eq!( + dictionary_size_fields(2, 128 * 1024).unwrap_err(), + Error::InvalidArgument("RAR 5 unknown compression algorithm version") + ); + } + + #[test] + fn filter_trials_propagate_codec_allocation_refusals() { + use crate::codec::workspace::Allowance; + use crate::filter_search::OwnedSearch; + + let search = Rar50OwnedSearch { + algorithm_version: 0, + allowance: Allowance::limited(0), + }; + let filter = FilterSpec::whole(FilterKind::Delta { channels: 1 }); + let data = vec![42; 4096]; + assert_eq!( + search + .filtered_bytes(&data, std::slice::from_ref(&filter)) + .unwrap_err() + .kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!( + search + .encode_filtered(&data, &[filter], EncodeOptions::new(8), None) + .unwrap_err() + .kind(), + crate::ErrorKind::ResourceLimit + ); + } +} + +pub(super) fn compression_info( + algorithm_version: u8, + method: u8, + dictionary_size: u64, + solid_continuation: bool, +) -> Result { + let (dictionary_power, dictionary_fraction) = + dictionary_size_fields(algorithm_version, dictionary_size)?; + Ok(u64::from(algorithm_version) + | (u64::from(method) << 7) + | (u64::from(dictionary_power) << 10) + | (u64::from(dictionary_fraction) << 15) + | solid_compression_flag(solid_continuation)) +} + +const SCREENED_KINDS: [FilterKind; 5] = [ + FilterKind::Arm, + FilterKind::Delta { channels: 1 }, + FilterKind::Delta { channels: 2 }, + FilterKind::Delta { channels: 3 }, + FilterKind::Delta { channels: 4 }, +]; + +struct Rar50OwnedSearch { + algorithm_version: u8, + allowance: B, +} +impl OwnedSearch for Rar50OwnedSearch { + type Options = EncodeOptions; + type Memory = B; + fn allowance(&self) -> &B { + &self.allowance + } + fn screened_kinds(&self, _: &[u8]) -> Result> { + Ok(Buffer::collect(SCREENED_KINDS, &self.allowance)?) + } + fn detects_x86(&self) -> bool { + true + } + fn max_delta_channels(&self) -> usize { + crate::codec::rar50::MAX_DELTA_CHANNELS + } + fn screen_options(&self, options: EncodeOptions) -> EncodeOptions { + options.with_optimal_parse(false) + } + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + Ok(crate::codec::rar50::filtered_owned_member( + data, + filters, + &self.allowance, + )?) + } + fn encode_plain( + &self, + data: &[u8], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Ok(crate::codec::rar50::encode_owned_member( + data, + self.algorithm_version, + options, + None, + progress, + &self.allowance, + )?) + } + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + Ok(crate::codec::rar50::encode_owned_member( + data, + self.algorithm_version, + options, + Some(filters), + progress, + &self.allowance, + )?) + } +} +fn choose_owned_filter( + data: &[u8], + algorithm_version: u8, + options: EncodeOptions, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, + allowance: &B, +) -> Result> { + crate::filter_search::choose_owned( + &Rar50OwnedSearch { + algorithm_version, + allowance: allowance.clone(), + }, + data, + options, + progress, + ) +} +fn specs_with_allowance( + data: &[u8], + algorithm_version: u8, + filters: &[FilterSpec], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, + allowance: &B, +) -> Result> { + encode_pass(progress, |progress| { + Ok(crate::codec::rar50::encode_owned_member( + data, + algorithm_version, + options, + (!filters.is_empty()).then_some(filters), + progress, + allowance, + )?) + }) +} +fn policy_with_allowance( + data: &[u8], + algorithm_version: u8, + policy: &FilterPolicy, + options: EncodeOptions, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, + allowance: &B, +) -> Result> { + match policy { + FilterPolicy::Auto if auto_size_filter_search_applies(data) => { + choose_owned_filter(data, algorithm_version, options, progress, allowance) + .map(|(_, bytes)| bytes) + } + FilterPolicy::Explicit(filter) => specs_with_allowance( + data, + algorithm_version, + std::slice::from_ref(filter), + options, + progress, + allowance, + ), + _ => specs_with_allowance(data, algorithm_version, &[], options, progress, allowance), + } +} + +/// How RAR 5 measures a filter candidate, for the shared search. +#[cfg(test)] +#[derive(Clone, Copy)] +pub(crate) struct Rar50Search { + pub(crate) algorithm_version: u8, +} + +#[cfg(test)] +impl crate::filter_search::FilterSearch for Rar50Search { + type Options = EncodeOptions; + + fn screened_kinds(&self, _data: &[u8]) -> Vec { + SCREENED_KINDS.to_vec() + } + + fn max_delta_channels(&self) -> usize { + crate::codec::rar50::MAX_DELTA_CHANNELS + } + + fn filtered_bytes(&self, data: &[u8], filters: &[FilterSpec]) -> Result> { + crate::codec::rar50::filtered_lz_member(data, filters) + .map(|(filtered, _)| filtered) + .map_err(Error::from) + } + + /// Screens rank filters against each other, and the optimal parse costs six + /// encodes' worth of time to sharpen a ranking that the same parse on both + /// sides already gets right. Everything else about the settings stays, so a + /// screen still measures what the writer will do. + fn screen_options(&self, options: EncodeOptions) -> EncodeOptions { + options.with_optimal_parse(false) + } + + fn encode_plain( + &self, + data: &[u8], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + match progress { + Some(progress) => encode_lz_member_with_options_and_progress( + data, + self.algorithm_version, + options, + progress, + ), + None => encode_lz_member_with_options(data, self.algorithm_version, options), + } + .map_err(Error::from) + } + + fn encode_filtered( + &self, + data: &[u8], + filters: &[FilterSpec], + options: EncodeOptions, + progress: Option<&mut dyn FnMut(usize) -> bool>, + ) -> Result> { + let mut encoder = Unpack50Encoder::with_options(options); + match progress { + Some(progress) => encoder.encode_member_with_filters_and_progress( + data, + self.algorithm_version, + filters, + progress, + ), + None => encoder.encode_member_with_filters(data, self.algorithm_version, filters), + } + .map_err(Error::from) + } +} + +#[cfg(test)] +pub(super) fn encode_member_with_auto_size_filter_progress( + data: &[u8], + algorithm_version: u8, + options: EncodeOptions, + progress: Option<&mut dyn FnMut(EncodeProgress) -> bool>, +) -> Result> { + policy_with_allowance( + data, + algorithm_version, + &FilterPolicy::Auto, + options, + progress, + &Allowance::default(), + ) + .map(Buffer::into_vec) +} + +pub(super) fn solid_compression_flag(solid_continuation: bool) -> u64 { + if solid_continuation { + 0x40 + } else { + 0 + } +} + +#[cfg(test)] +mod allowance_tests { + use super::*; + + #[test] + fn candidate_search_keeps_the_winner_charged_and_releases_refused_trials() { + let data: Vec = (0..1024u32) + .flat_map(|n| ((n * 71) % 32749).to_le_bytes()) + .collect(); + let candidates = [ + EncodeOptions::new(8).with_max_match_distance(65536), + EncodeOptions::new(16).with_max_match_distance(65536), + ]; + for version in [0, 1] { + for policy in [ + FilterPolicy::None, + FilterPolicy::Auto, + FilterPolicy::Explicit(FilterSpec::whole(FilterKind::Delta { channels: 4 })), + ] { + let expected = candidates_with_allowance( + &data, + version, + &policy, + &candidates, + None, + &Allowance::default(), + ) + .unwrap(); + let mut successes = 0; + let mut refusals = 0; + for limit in [0, 4096, 16384, 65536, 262144, 1048576, 8 * 1048576] { + let allowance = Allowance::limited(limit); + match candidates_with_allowance( + &data, + version, + &policy, + &candidates, + None, + &allowance, + ) { + Ok(packed) => { + successes += 1; + assert_eq!(&*packed, &*expected); + assert!(allowance.used() >= packed.len() as u64); + assert!(allowance.used() > 0); + drop(packed); + } + Err(error) => { + refusals += 1; + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit, "{error}"); + } + } + assert_eq!(allowance.used(), 0); + } + assert!(successes > 0 && refusals >= 3); + } + } + } + + #[test] + fn bounded_sampled_search_preserves_code_and_table_candidates() { + let mut data = vec![0x90u8; 65536]; + for pos in (0..65000).step_by(32) { + data[pos] = 0xe8; + data[pos + 1..pos + 5].copy_from_slice(&(1024i32 - pos as i32).to_le_bytes()); + } + for index in 0..8192u64 { + data.extend_from_slice(&(0x7f80_1234_0000 + index * 24).to_le_bytes()); + data.extend_from_slice(&0x0102_0304_0506_0708u64.to_le_bytes()); + data.extend_from_slice(&(0x4455_6677_0000 | ((index * 7) & 0xffff)).to_le_bytes()); + } + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let expected = choose_owned_filter(&data, 0, options, None, &Allowance::default()).unwrap(); + assert!(!expected.0.is_empty()); + assert!(expected + .0 + .iter() + .any(|spec| matches!(spec.kind, FilterKind::Delta { channels: 24 }))); + let allowance = Allowance::limited(32 * 1048576); + let (specs, packed) = choose_owned_filter(&data, 0, options, None, &allowance).unwrap(); + assert_eq!(&*specs, &*expected.0); + assert_eq!(&*packed, &*expected.1); + let retained = allowance.used(); + assert!(retained > packed.len() as u64); + drop(specs); + assert!(allowance.used() < retained); + assert!(allowance.used() >= packed.len() as u64); + drop(packed); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn cancellation_drops_retained_screens_and_previous_encoder_candidates() { + let data: Vec = (0..1024u32).flat_map(|n| n.to_le_bytes()).collect(); + let options = EncodeOptions::new(8).with_max_match_distance(65536); + let candidates = [options, options.with_optimal_parse(true)]; + for policy in [FilterPolicy::None, FilterPolicy::Auto] { + let mut passes = 0; + let expected = candidates_with_allowance( + &data, + 0, + &policy, + &candidates, + Some(&mut |event| { + passes += usize::from(event == EncodeProgress::PassStarted); + true + }), + &Allowance::default(), + ) + .unwrap(); + assert!(passes >= 2); + for stop in 1..=passes { + let allowance = Allowance::limited(16 * 1048576); + let mut pass = 0; + let result = candidates_with_allowance( + &data, + 0, + &policy, + &candidates, + Some(&mut |event| { + pass += usize::from(event == EncodeProgress::PassStarted); + pass < stop + }), + &allowance, + ); + assert!(matches!(result, Err(Error::Cancelled))); + assert_eq!(allowance.used(), 0, "pass {stop}"); + let retried = + candidates_with_allowance(&data, 0, &policy, &candidates, None, &allowance) + .unwrap(); + assert_eq!(&*retried, &*expected); + drop(retried); + assert_eq!(allowance.used(), 0); + } + } + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/headers.rs b/arca-rar/vendor/rars/src/rar50/write/headers.rs new file mode 100644 index 00000000..a4b1f5fd --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/headers.rs @@ -0,0 +1,1027 @@ +//! RAR 5 header serialization. +//! +//! Plain header encodings and lengths depend only on their inputs, letting the +//! layout resolver predict positions before emission. Encrypted headers obtain +//! fresh IVs. Prepared images additionally reserve their allocation capacity +//! against the writer resource policy. + +use super::ArchiveMetadataEntry; +#[cfg(test)] +use crate::crc32::crc32; +#[cfg(all(test, feature = "encryption"))] +use crate::crypto::rar50::Rar50Cipher; +use crate::crypto::rar50::{Rar50Keys, WRITE_KDF_COUNT_LOG}; +use crate::rar50::framing::{checked_image_len, image_size_error, HeaderImage, HeaderScratch}; +use crate::rar50::{ + FHEXTRA_CRYPT, FHEXTRA_HASH, FHFL_CRC32, FHFL_DIRECTORY, FHFL_MTIME, HEAD_CRYPT, HEAD_END, + HEAD_MAIN, HFL_EXTRA, MHEXTRA_ARCHIVE_METADATA, MHEXTRA_ARCHIVE_METADATA_NAME, + MHEXTRA_ARCHIVE_METADATA_TIME, MHEXTRA_LOCATOR, MHEXTRA_LOCATOR_QUICK_OPEN, + MHEXTRA_LOCATOR_RECOVERY, +}; +use crate::streaming::preparation::Bytes; +use crate::WriterResources; +use crate::{Error, Result}; + +pub(crate) trait HeaderOutput { + fn append(&mut self, bytes: &[u8]) -> Result<()>; + fn vint(&mut self, value: u64) -> Result<()>; +} +impl HeaderOutput for Bytes { + fn append(&mut self, bytes: &[u8]) -> Result<()> { + self.extend_from_slice(bytes) + } + fn vint(&mut self, value: u64) -> Result<()> { + self.vint(value) + } +} +#[cfg(test)] +impl HeaderOutput for Vec { + fn append(&mut self, bytes: &[u8]) -> Result<()> { + self.extend_from_slice(bytes); + Ok(()) + } + fn vint(&mut self, value: u64) -> Result<()> { + write_vint(self, value); + Ok(()) + } +} + +#[cfg(test)] +pub(super) fn write_vint(out: &mut Vec, mut value: u64) { + while value >= 0x80 { + out.push((value as u8) | 0x80); + value >>= 7; + } + out.push(value as u8); +} + +pub(super) fn write_extra_record( + out: &mut impl HeaderOutput, + record_type: u64, + data: &[u8], +) -> Result<()> { + let mut kind = HeaderScratch::<10>::new(); + kind.vint(record_type); + // A slice length is at most isize::MAX, so adding a ten-byte vint fits u64. + out.vint(data.len() as u64 + kind.len() as u64)?; + out.append(kind.as_slice())?; + out.append(data)?; + + Ok(()) +} + +pub(super) fn write_hash_record_with_value( + out: &mut impl HeaderOutput, + hash: [u8; 32], +) -> Result<()> { + let mut record = HeaderScratch::<33>::new(); + record.vint(0); + record.extend_from_slice(&hash); + write_extra_record(out, FHEXTRA_HASH, record.as_slice())?; + + Ok(()) +} + +pub(super) fn write_file_encryption_record( + out: &mut impl HeaderOutput, + salt: [u8; 16], + iv: [u8; 16], + check_value: [u8; 12], +) -> Result<()> { + let mut record = HeaderScratch::<47>::new(); + record.vint(0); + record.vint(0x0003); + record.extend_from_slice(&[WRITE_KDF_COUNT_LOG]); + record.extend_from_slice(&salt); + record.extend_from_slice(&iv); + record.extend_from_slice(&check_value); + write_extra_record(out, FHEXTRA_CRYPT, record.as_slice())?; + + Ok(()) +} + +fn join_record(parts: &[&[u8]], resources: &WriterResources) -> Result { + let len = parts + .iter() + .try_fold(0usize, |total, part| total.checked_add(part.len())) + .ok_or_else(image_size_error)?; + let mut out = Bytes::zeroed(checked_image_len(&[len])?, resources)?; + let mut offset = 0; + for part in parts { + out[offset..offset + part.len()].copy_from_slice(part); + offset += part.len(); + } + Ok(out) +} + +impl HeaderImage<'_> { + fn render( + &self, + keys: Option<&Rar50Keys>, + data: &[u8], + resources: &WriterResources, + ) -> Result { + let mut out = Bytes::zeroed(self.image_len(keys.is_some(), data.len())?, resources)?; + self.render_into(keys, data, &mut out)?; + Ok(out) + } +} + +pub(super) fn block_header_image( + header_type: u64, + flags: u64, + data_size: Option, + type_specific: &[u8], + extra: &[u8], + resources: &WriterResources, +) -> Result { + HeaderImage::new(header_type, flags, data_size, type_specific, extra)?.render( + None, + &[], + resources, + ) +} + +#[allow(clippy::too_many_arguments)] +pub(super) fn write_block( + out: &mut impl HeaderOutput, + header_type: u64, + flags: u64, + data_size: Option, + type_specific: &[u8], + extra: &[u8], + data: &[u8], + resources: &WriterResources, +) -> Result<()> { + let header = block_header_image( + header_type, + flags, + data_size, + type_specific, + extra, + resources, + )?; + out.append(&header)?; + out.append(data)?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn block_header_admission_failure_leaves_output_empty() { + let resources = WriterResources::default().with_max_preparation_bytes(0); + let mut output = Bytes::new(&resources); + let error = + write_block(&mut output, HEAD_MAIN, 0, None, &[], &[], &[], &resources).unwrap_err(); + assert!(matches!( + error, + Error::WriterPreparationLimitExceeded { + limit: 0, + used: 0, + .. + } + )); + assert!(output.is_empty()); + } + + #[test] + fn archive_metadata_extra_releases_each_refused_preparation_charge() { + let metadata = ArchiveMetadataEntry { + name: Some(b"archive"), + creation_time: Some(1), + }; + let mut limit = 0; + let mut refusals = 0; + loop { + let resources = WriterResources::default().with_max_preparation_bytes(limit); + match resolved_main_extra(Some(metadata), None, None, &resources) { + Ok(extra) => { + assert!(!extra.is_empty()); + break; + } + Err(Error::WriterPreparationLimitExceeded { required, .. }) => { + assert!(required > limit); + refusals += 1; + drop(Bytes::zeroed(limit as usize, &resources).unwrap()); + limit = required; + assert!(limit < 4096); + } + Err(error) => panic!("unexpected metadata error: {error}"), + } + } + assert!(refusals > 2); + } +} + +/// Encrypts a header block under `keys`, returning `iv || ciphertext || data`. +/// +/// Each block gets its own IV and its own CBC chain, so headers can be built +/// and emitted one at a time without any cross-block state. +#[allow(clippy::too_many_arguments)] +pub(crate) fn encrypted_header_block( + keys: &Rar50Keys, + header_type: u64, + flags: u64, + data_size: Option, + type_specific: &[u8], + extra: &[u8], + data: &[u8], + resources: &WriterResources, +) -> Result { + HeaderImage::new(header_type, flags, data_size, type_specific, extra)?.render( + Some(keys), + data, + resources, + ) +} + +pub(super) fn stored_file_specific( + name: &[u8], + unpacked_size: u64, + data_crc32: u32, + attributes: u64, + mtime: Option, + host_os: u64, + resources: &WriterResources, +) -> Result { + file_specific( + name, + unpacked_size, + data_crc32, + attributes, + mtime, + 0, + host_os, + false, + resources, + ) +} + +// Keep the on-disk file header fields explicit at this serialization boundary. +#[allow(clippy::too_many_arguments)] +pub(super) fn file_specific( + name: &[u8], + unpacked_size: u64, + data_crc32: u32, + attributes: u64, + mtime: Option, + compression_info: u64, + host_os: u64, + is_directory: bool, + resources: &WriterResources, +) -> Result { + if name.is_empty() { + return Err(Error::InvalidArgument("RAR 5 file name is empty")); + } + let mut file_flags = FHFL_CRC32; + if is_directory { + file_flags |= FHFL_DIRECTORY; + } + if mtime.is_some() { + file_flags |= FHFL_MTIME; + } + + let mut specific = HeaderScratch::<68>::new(); + specific.vint(file_flags); + specific.vint(unpacked_size); + specific.vint(attributes); + if let Some(mtime) = mtime { + specific.extend_from_slice(&mtime.to_le_bytes()); + } + specific.extend_from_slice(&data_crc32.to_le_bytes()); + specific.vint(compression_info); + specific.vint(host_os); + specific.vint(name.len() as u64); + join_record(&[specific.as_slice(), name], resources) +} + +pub(super) fn write_mtime_record( + extra: &mut impl HeaderOutput, + seconds: Option, + nanos: Option, +) -> Result<()> { + if let (Some(seconds), Some(nanos)) = (seconds, nanos) { + // Unix time + mtime + nanoseconds. Emit the complete timestamp here, + // with no base-header time competing with the higher precision record. + let mut record = HeaderScratch::<9>::new(); + record.extend_from_slice(&[0x13]); + record.extend_from_slice(&seconds.to_le_bytes()); + record.extend_from_slice(&nanos.to_le_bytes()); + write_extra_record(extra, super::super::FHEXTRA_HTIME, record.as_slice())?; + } + + Ok(()) +} + +fn metadata_image( + flags: u64, + name: Option<&[u8]>, + time: &[u8], + resources: &WriterResources, +) -> Result { + let mut fields = HeaderScratch::<20>::new(); + fields.vint(flags); + if let Some(name) = name { + fields.vint(name.len() as u64); + } + let name = name.unwrap_or_default(); + let mut kind = HeaderScratch::<10>::new(); + kind.vint(MHEXTRA_ARCHIVE_METADATA); + let body_len = checked_image_len(&[kind.len(), fields.len(), name.len(), time.len()])?; + let mut size = HeaderScratch::<10>::new(); + size.vint(body_len as u64); + join_record( + &[ + size.as_slice(), + kind.as_slice(), + fields.as_slice(), + name, + time, + ], + resources, + ) +} + +pub(super) fn archive_metadata_record( + metadata: ArchiveMetadataEntry<'_>, + resources: &WriterResources, +) -> Result { + if metadata.name.is_none() && metadata.creation_time.is_none() { + return Err(Error::InvalidArgument( + "RAR 5 archive metadata writer needs a name or creation time", + )); + } + if metadata.name.is_some() && metadata.creation_time.is_none() { + return Err(Error::InvalidArgument( + "RAR 5 archive metadata name needs a creation time", + )); + } + let mut flags = 0; + if metadata.name.is_some() { + flags |= MHEXTRA_ARCHIVE_METADATA_NAME; + } + // A creation time is required, with or without a name. + flags |= MHEXTRA_ARCHIVE_METADATA_TIME; + + if metadata.name.is_some_and(|name| name.is_empty()) { + return Err(Error::InvalidArgument( + "RAR 5 archive metadata name is empty", + )); + } + let time = metadata.creation_time.map(u64::to_le_bytes); + metadata_image( + flags, + metadata.name, + time.as_ref().map_or(&[], |bytes| bytes.as_slice()), + resources, + ) +} + +pub(super) fn write_locator_record( + out: &mut impl HeaderOutput, + quick_open_offset: Option, + recovery_record_offset: Option, +) -> Result<()> { + let mut flags = 0; + if quick_open_offset.is_some() { + flags |= MHEXTRA_LOCATOR_QUICK_OPEN; + } + if recovery_record_offset.is_some() { + flags |= MHEXTRA_LOCATOR_RECOVERY; + } + + let mut record = HeaderScratch::<21>::new(); + record.vint(flags); + if let Some(quick_open_offset) = quick_open_offset { + record.vint(quick_open_offset); + } + if let Some(recovery_record_offset) = recovery_record_offset { + record.vint(recovery_record_offset); + } + write_extra_record(out, MHEXTRA_LOCATOR, record.as_slice())?; + + Ok(()) +} + +pub(super) fn resolved_main_extra( + archive_metadata: Option>, + quick_open_offset: Option, + recovery_offset: Option, + resources: &WriterResources, +) -> Result { + let mut main_extra = Bytes::new(resources); + let locator_quick_open_offset = quick_open_offset.or_else(|| archive_metadata.map(|_| 0)); + if locator_quick_open_offset.is_some() || recovery_offset.is_some() { + write_locator_record(&mut main_extra, locator_quick_open_offset, recovery_offset)?; + } + if let Some(archive_metadata) = archive_metadata { + main_extra.extend_from_slice(&archive_metadata_record(archive_metadata, resources)?)?; + } + Ok(main_extra) +} + +pub(super) fn write_main_header( + out: &mut impl HeaderOutput, + archive_flags: u64, + volume_number: Option, + extra: &[u8], + resources: &WriterResources, +) -> Result<()> { + let mut specific = HeaderScratch::<20>::new(); + specific.vint(archive_flags); + if let Some(volume_number) = volume_number { + specific.vint(volume_number); + } + write_block( + out, + HEAD_MAIN, + if extra.is_empty() { 0 } else { HFL_EXTRA }, + None, + specific.as_slice(), + extra, + &[], + resources, + ) +} + +pub(super) fn encrypted_main_header_block( + keys: &Rar50Keys, + archive_flags: u64, + volume_number: Option, + extra: &[u8], + resources: &WriterResources, +) -> Result { + let mut specific = HeaderScratch::<20>::new(); + specific.vint(archive_flags); + if let Some(volume_number) = volume_number { + specific.vint(volume_number); + } + encrypted_header_block( + keys, + HEAD_MAIN, + if extra.is_empty() { 0 } else { HFL_EXTRA }, + None, + specific.as_slice(), + extra, + &[], + resources, + ) +} + +pub(crate) struct HeaderEncryptionKeys { + pub(super) keys: Rar50Keys, + pub(super) salt: [u8; 16], +} + +pub(super) fn header_encryption_keys(password: &[u8]) -> Result { + crate::crypto::require_encryption()?; + let mut salt = [0u8; 16]; + crate::write_stream::fill_entropy( + &mut salt, + "RAR 5 writer could not generate encryption salt", + )?; + let keys = Rar50Keys::derive(password, salt, WRITE_KDF_COUNT_LOG).map_err(Error::from)?; + Ok(HeaderEncryptionKeys { keys, salt }) +} + +/// Header encryption covers the whole archive, so every member, service and +/// comment has to be locked with the same password. +pub(super) fn header_encryption_password<'a>( + mut passwords: impl Iterator, +) -> Result<&'a [u8]> { + let first = passwords.next().ok_or(Error::NeedPassword)?; + for password in passwords { + if password != first { + return Err(Error::InvalidArgument( + "RAR 5 header-encrypted writer needs one shared password", + )); + } + } + Ok(first) +} + +pub(super) fn write_head_crypt( + out: &mut impl HeaderOutput, + header_keys: &HeaderEncryptionKeys, + resources: &WriterResources, +) -> Result<()> { + let mut specific = HeaderScratch::<31>::new(); + specific.vint(0); + specific.vint(0x0001); + specific.extend_from_slice(&[WRITE_KDF_COUNT_LOG]); + specific.extend_from_slice(&header_keys.salt); + specific.extend_from_slice(&header_keys.keys.checked_password_record()?); + write_block( + out, + HEAD_CRYPT, + 0, + None, + specific.as_slice(), + &[], + &[], + resources, + ) +} + +pub(crate) fn write_end_header( + out: &mut impl HeaderOutput, + end_flags: u64, + resources: &WriterResources, +) -> Result<()> { + write_block( + out, + HEAD_END, + 0, + None, + &end_header_specific(end_flags), + &[], + &[], + resources, + ) +} + +pub(crate) fn end_header_specific(end_flags: u64) -> HeaderScratch<10> { + let mut specific = HeaderScratch::new(); + specific.vint(end_flags); + specific +} + +pub(crate) fn retained_archive_metadata( + metadata: &crate::rar50::ArchiveMetadataRecord, + resources: &WriterResources, +) -> Result { + if metadata.flags & !15 != 0 + || (metadata.flags & 8 != 0 && metadata.flags & 4 == 0) + || (metadata.flags & 1 != 0) != metadata.name.is_some() + || (metadata.flags & 2 != 0) != metadata.creation_time.is_some() + || metadata.flags & 3 == 0 + || metadata + .name + .as_ref() + .is_some_and(|name| name.is_empty() || std::str::from_utf8(name).is_err()) + { + return Err(Error::InvalidArgument( + "unsupported archive metadata record", + )); + } + let mut time_bytes = HeaderScratch::<8>::new(); + if let Some(time) = metadata.creation_time { + if metadata.flags & 4 != 0 && metadata.flags & 8 == 0 { + time_bytes.extend_from_slice( + &u32::try_from(time) + .map_err(|_| Error::InvalidArgument("archive Unix timestamp exceeds 32 bits"))? + .to_le_bytes(), + ); + } else { + time_bytes.extend_from_slice(&time.to_le_bytes()); + } + } + metadata_image( + metadata.flags, + metadata.name.as_deref(), + time_bytes.as_slice(), + resources, + ) +} + +/// An immutable final header image. Free bytes before releasing admission. +pub(super) struct PreparedHeader { + bytes: Bytes, + _charge: Option, +} + +impl std::ops::Deref for PreparedHeader { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.bytes + } +} + +pub(super) fn prepared_header_image( + header_type: u64, + flags: u64, + data_size: Option, + type_specific: &[u8], + extra: &[u8], + keys: Option<&HeaderEncryptionKeys>, + resources: &crate::WriterResources, +) -> Result { + let image = HeaderImage::new(header_type, flags, data_size, type_specific, extra)?; + let length = image.header_len(keys.is_some())?; + let charge = resources.reserve_prepared_header(length as u64)?; + let bytes = image.render(keys.map(|keys| &keys.keys), &[], resources)?; + Ok(PreparedHeader { + bytes, + _charge: charge, + }) +} + +#[cfg(test)] +mod prepared_header_tests { + use super::*; + use crate::{ErrorKind, WriterResources}; + + #[test] + fn exact_images_match_existing_serialization_and_include_encryption_padding() { + #[cfg(feature = "encryption")] + let keys = header_encryption_keys(b"secret").unwrap(); + for len in [0, 1, 15, 16, 120, 127, 128, 16384] { + let specific = vec![0x51; len]; + for encrypted in crate::test_features::encryption_cases() { + let key = { + #[cfg(feature = "encryption")] + { + encrypted.then_some(&keys) + } + #[cfg(not(feature = "encryption"))] + { + None + } + }; + let expected = block_header_image( + 2, + HFL_EXTRA, + Some(u64::MAX), + &specific, + b"extra", + &crate::WriterResources::default(), + ) + .unwrap(); + let size = if encrypted { + 16 + expected.len().div_ceil(16) * 16 + } else { + expected.len() + }; + let limited = + WriterResources::default().with_max_prepared_header_bytes(size as u64 - 1); + let error = prepared_header_image( + 2, + HFL_EXTRA, + Some(u64::MAX), + &specific, + b"extra", + key, + &limited, + ) + .err() + .unwrap(); + assert_eq!(error.kind(), ErrorKind::ResourceLimit); + assert_eq!( + error, + Error::WriterPreparedHeaderLimitExceeded { + limit: size as u64 - 1, + required: size as u64, + used: 0 + } + ); + let resources = + WriterResources::default().with_max_prepared_header_bytes(size as u64); + let header = prepared_header_image( + 2, + HFL_EXTRA, + Some(u64::MAX), + &specific, + b"extra", + key, + &resources, + ) + .unwrap(); + assert_eq!(header.bytes.capacity(), size); + assert!(resources.clone().reserve_prepared_header(1).is_err()); + if encrypted { + #[cfg(feature = "encryption")] + { + let iv = header[..16].try_into().unwrap(); + let mut plain = header[16..].to_vec(); + Rar50Cipher::new(keys.keys.key, iv) + .decrypt_in_place(&mut plain) + .unwrap(); + assert_eq!(&plain[..expected.len()], expected.as_slice()); + assert!(plain[expected.len()..].iter().all(|byte| *byte == 0)); + } + } else { + assert_eq!(&*header, expected.as_slice()); + } + drop(header); + assert!(resources.reserve_prepared_header(size as u64).is_ok()); + } + } + } + + #[test] + fn shared_header_quota_is_released_on_unwind() { + let resources = WriterResources::default().with_max_prepared_header_bytes(1024); + let failure = std::panic::catch_unwind(|| { + let _header = + prepared_header_image(2, 0, None, b"data", &[], None, &resources).unwrap(); + assert!(resources.reserve_prepared_header(1024).is_err()); + panic!("injected failure"); + }); + assert!(failure.is_err()); + assert!(resources.reserve_prepared_header(1024).is_ok()); + } +} + +#[cfg(test)] +mod scratch_tests { + use super::*; + + fn buffered_record(kind: u64, data: &[u8]) -> Vec { + let mut body = Vec::new(); + write_vint(&mut body, kind); + body.extend_from_slice(data); + let mut out = Vec::new(); + write_vint(&mut out, body.len() as u64); + out.extend_from_slice(&body); + out + } + + #[test] + fn stack_framing_matches_buffered_encoding_at_vint_boundaries() { + for len in [0, 1, 127, 128, 16384] { + let data = vec![0xa5; len]; + for kind in [0, 127, 128, u64::MAX] { + let mut record = vec![0x5a]; + write_extra_record(&mut record, kind, &data).unwrap(); + let mut expected = vec![0x5a]; + expected.extend(buffered_record(kind, &data)); + assert_eq!(record, expected); + for flags in [0, HFL_EXTRA, u64::MAX] { + for size in [None, Some(u64::MAX)] { + let mut body = Vec::new(); + write_vint(&mut body, kind); + write_vint(&mut body, flags); + if flags & HFL_EXTRA != 0 { + write_vint(&mut body, data.len() as u64); + } + if let Some(size) = size { + write_vint(&mut body, size); + } + body.extend_from_slice(b"specific"); + body.extend_from_slice(&data); + let mut expected = vec![0; 4]; + write_vint(&mut expected, body.len() as u64); + expected.extend_from_slice(&body); + let crc = crc32(&expected[4..]); + expected[..4].copy_from_slice(&crc.to_le_bytes()); + assert_eq!( + block_header_image( + kind, + flags, + size, + b"specific", + &data, + &crate::WriterResources::default() + ) + .unwrap(), + expected + ); + } + } + } + } + } + + #[test] + fn fixed_records_fit_their_stack_capacity_and_keep_wire_bytes() { + let mut actual = Vec::new(); + write_file_encryption_record(&mut actual, [1; 16], [2; 16], [3; 12]).unwrap(); + let mut body = vec![0, 3, WRITE_KDF_COUNT_LOG]; + body.extend_from_slice(&[1; 16]); + body.extend_from_slice(&[2; 16]); + body.extend_from_slice(&[3; 12]); + assert_eq!(actual, buffered_record(FHEXTRA_CRYPT, &body)); + actual.clear(); + write_hash_record_with_value(&mut actual, [7; 32]).unwrap(); + let mut body = vec![0]; + body.extend_from_slice(&[7; 32]); + assert_eq!(actual, buffered_record(FHEXTRA_HASH, &body)); + actual.clear(); + write_mtime_record(&mut actual, Some(u32::MAX), Some(u32::MAX)).unwrap(); + let mut body = vec![0x13]; + body.extend_from_slice(&[0xff; 8]); + assert_eq!( + actual, + buffered_record(super::super::super::FHEXTRA_HTIME, &body) + ); + actual.clear(); + write_locator_record(&mut actual, Some(u64::MAX), Some(u64::MAX)).unwrap(); + let mut body = Vec::new(); + write_vint( + &mut body, + MHEXTRA_LOCATOR_QUICK_OPEN | MHEXTRA_LOCATOR_RECOVERY, + ); + write_vint(&mut body, u64::MAX); + write_vint(&mut body, u64::MAX); + assert_eq!(actual, buffered_record(MHEXTRA_LOCATOR, &body)); + } +} + +#[cfg(test)] +mod image_tests { + use super::*; + + #[test] + fn header_length_checks_reject_overflow_without_allocating() { + assert_eq!(checked_image_len(&[0, 7]).unwrap(), 7); + for parts in [[usize::MAX, 1], [isize::MAX as usize, 1]] { + assert_eq!( + checked_image_len(&parts).unwrap_err(), + Error::InvalidArgument("RAR 5 header size overflows") + ); + } + } + + #[test] + fn invalid_archive_metadata_is_rejected_at_serialization() { + let resources = crate::WriterResources::default(); + for (name, time, reason) in [ + ( + None, + None, + "RAR 5 archive metadata writer needs a name or creation time", + ), + ( + Some(b"name".as_slice()), + None, + "RAR 5 archive metadata name needs a creation time", + ), + ( + Some(b"".as_slice()), + Some(1), + "RAR 5 archive metadata name is empty", + ), + ] { + let error = archive_metadata_record( + ArchiveMetadataEntry { + name, + creation_time: time, + }, + &resources, + ) + .unwrap_err(); + assert_eq!(error, Error::InvalidArgument(reason)); + } + assert_eq!( + file_specific(b"", 0, 0, 0, None, 0, 0, false, &resources).unwrap_err(), + Error::InvalidArgument("RAR 5 file name is empty") + ); + } + + #[test] + fn retained_metadata_rejects_inconsistent_flags_and_names() { + let resources = crate::WriterResources::default(); + for (flags, name, time) in [ + (16, None, None), + (8, None, None), + (1, None, None), + (2, None, None), + (0, Some(b"name".to_vec()), None), + (0, None, Some(1)), + (4, None, None), + (1, Some(Vec::new()), None), + (1, Some(vec![0xff]), None), + ] { + let record = crate::rar50::ArchiveMetadataRecord { + flags, + name, + creation_time: time, + }; + assert_eq!( + retained_archive_metadata(&record, &resources).unwrap_err(), + Error::InvalidArgument("unsupported archive metadata record"), + "flags {flags}" + ); + } + let record = crate::rar50::ArchiveMetadataRecord { + flags: 6, + name: None, + creation_time: Some(u64::from(u32::MAX) + 1), + }; + assert_eq!( + retained_archive_metadata(&record, &resources).unwrap_err(), + Error::InvalidArgument("archive Unix timestamp exceeds 32 bits") + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_images_match_buffered_ciphertext_and_leave_trailing_data_plain() { + let keys = header_encryption_keys(b"secret").unwrap(); + for size in [0, 1, 15, 16, 17, 127, 128, 16384] { + let specific = vec![0x35; size]; + let data = b"unencrypted trailing payload"; + let actual = encrypted_header_block( + &keys.keys, + u64::MAX, + HFL_EXTRA, + Some(data.len() as u64), + &specific, + b"extra", + data, + &crate::WriterResources::default(), + ) + .unwrap(); + let iv = actual[..16].try_into().unwrap(); + let expected = block_header_image( + u64::MAX, + HFL_EXTRA, + Some(data.len() as u64), + &specific, + b"extra", + &crate::WriterResources::default(), + ) + .unwrap(); + let mut expected = expected.to_vec(); + expected.resize(expected.len().div_ceil(16) * 16, 0); + Rar50Cipher::new(keys.keys.key, iv) + .encrypt_in_place(&mut expected) + .unwrap(); + assert_eq!(&actual[16..16 + expected.len()], expected.as_slice()); + assert_eq!(&actual[16 + expected.len()..], data); + assert_eq!(actual.capacity(), actual.len()); + } + } + + #[test] + fn metadata_images_keep_all_supported_time_encodings_and_name_lengths() { + for length in [1, 127, 128, 16384] { + let name = vec![b'n'; length]; + for flags in [1, 2, 3, 6, 7, 14, 15] { + let time = if flags & 4 != 0 && flags & 8 == 0 { + u32::MAX as u64 + } else { + u64::MAX + }; + let record = crate::rar50::ArchiveMetadataRecord { + flags, + name: (flags & 1 != 0).then(|| name.clone()), + creation_time: (flags & 2 != 0).then_some(time), + }; + let mut body = Vec::new(); + write_vint(&mut body, flags); + if let Some(name) = &record.name { + write_vint(&mut body, name.len() as u64); + body.extend_from_slice(name); + } + if record.creation_time.is_some() { + if flags & 4 != 0 && flags & 8 == 0 { + body.extend_from_slice(&(time as u32).to_le_bytes()); + } else { + body.extend_from_slice(&time.to_le_bytes()); + } + } + let mut expected = Vec::new(); + write_extra_record(&mut expected, MHEXTRA_ARCHIVE_METADATA, &body).unwrap(); + let actual = + retained_archive_metadata(&record, &crate::WriterResources::default()).unwrap(); + assert_eq!(actual, expected); + assert_eq!(actual.capacity(), actual.len()); + if flags == 2 || flags == 3 { + assert_eq!( + archive_metadata_record( + ArchiveMetadataEntry { + name: record.name.as_deref(), + creation_time: record.creation_time, + }, + &crate::WriterResources::default() + ) + .unwrap(), + expected + ); + } + } + } + } + + #[test] + fn file_specific_fields_keep_maximum_widths_without_growing_the_record() { + let name = vec![b'n'; 16384]; + let actual = file_specific( + &name, + u64::MAX, + u32::MAX, + u64::MAX, + Some(u32::MAX), + u64::MAX, + u64::MAX, + true, + &crate::WriterResources::default(), + ) + .unwrap(); + let mut expected = Vec::new(); + for value in [FHFL_CRC32 | FHFL_DIRECTORY | FHFL_MTIME, u64::MAX, u64::MAX] { + write_vint(&mut expected, value); + } + expected.extend_from_slice(&[0xff; 8]); + for value in [u64::MAX, u64::MAX, name.len() as u64] { + write_vint(&mut expected, value); + } + expected.extend_from_slice(&name); + assert_eq!(actual, expected); + assert_eq!(actual.capacity(), actual.len()); + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/layout.rs b/arca-rar/vendor/rars/src/rar50/write/layout.rs new file mode 100644 index 00000000..cbe09f07 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/layout.rs @@ -0,0 +1,446 @@ +//! Where each archive block lands, worked out before anything is written. +//! +//! The main header carries a locator record holding the offsets of the +//! quick-open and recovery blocks, and those offsets are stored as variable +//! length integers. So the main header's own size depends on values that +//! depend on the main header's size. The writer used to break that circle by +//! emitting the entire archive up to four times until the offsets stopped +//! moving, which meant recomputing every recovery record from scratch on each +//! attempt. +//! +//! It is only a circle over two integers, though. Everything else in the +//! archive has a size that is already known: block headers are a pure function +//! of their fields, and the quick-open payload stores offsets *relative* to +//! itself, so growing the prefix shifts its position and its targets equally +//! and leaves its length alone. That makes the fixed point cheap to solve here, +//! over a few dozen bytes, instead of over the whole archive. + +use super::headers::{block_header_image, resolved_main_extra, stored_file_specific}; +use super::ArchiveMetadataEntry; +use crate::detect::RAR50_SIGNATURE; +use crate::rar50::{FHEXTRA_SUBDATA, HEAD_MAIN, HEAD_SERVICE, HFL_DATA, HFL_EXTRA}; +use crate::streaming::preparation::Bytes; +use crate::{Error, Result, WriterResources}; + +#[derive(Debug, Clone, Copy)] +pub(super) struct LayoutInputs<'a> { + /// Header encryption pads every header to a 16-byte boundary and prefixes + /// an IV, which changes sizes but keeps them predictable. + pub(super) header_encrypted: bool, + /// Size of the plaintext HEAD_CRYPT block, or zero when absent. + pub(super) head_crypt_len: u64, + /// Archive flags, including MHFL_RECOVERY and any volume flags. + pub(super) main_flags: u64, + pub(super) volume_number: Option, + pub(super) archive_metadata: Option>, + pub(super) metadata_record: Option<&'a crate::rar50::ArchiveMetadataRecord>, + /// Everything between the main header and the quick-open block: comments, + /// members and their services. + pub(super) body_len: u64, + pub(super) quick_open_payload_len: Option, + pub(super) recovery_percent: Option, +} + +#[derive(Debug)] +pub(super) struct ResolvedLayout { + /// The extra area to put in the main header, with settled offsets. + pub(super) main_extra: Bytes, + pub(super) main_header_len: u64, + /// Value stored in the locator: the block's position measured from the end + /// of the signature. The quick-open offset is settled the same way but is + /// only ever written into `main_extra`, so it is not repeated here. + pub(super) recovery_offset: Option, + /// Bytes the recovery record protects, i.e. everything before it. + pub(super) recovery_prefix_len: Option, +} + +pub(super) fn resolve_layout( + inputs: &LayoutInputs<'_>, + resources: &WriterResources, +) -> Result { + let signature_len = RAR50_SIGNATURE.len() as u64; + let quick_open_block_len = match inputs.quick_open_payload_len { + Some(payload_len) => { + stored_service_block_len(b"QO", payload_len, &[], inputs.header_encrypted, resources)? + } + None => 0, + }; + + let mut quick_open_offset = inputs.quick_open_payload_len.map(|_| 0); + let mut recovery_offset = inputs.recovery_percent.map(|_| 0); + + // Starting with zero offsets makes header sizes and offsets monotone. + // The two locator vints can grow by at most 18 bytes altogether; their + // record-size vint stays one byte. The extra-size and header-size vints + // can each grow by one byte, so the plaintext header grows by at most 20 + // bytes, or 32 after encryption padding. After the first offset update, + // each offset can therefore cross at most one further vint boundary + // (consecutive boundaries are at least 16,256 bytes apart). Those two + // possible width changes, plus the initial update and propagation, settle + // within five passes. Allocation or arithmetic failures return via `?`. + loop { + let mut main_extra = resolved_main_extra( + inputs.archive_metadata, + quick_open_offset, + recovery_offset, + resources, + )?; + if let Some(metadata) = inputs.metadata_record { + main_extra.extend_from_slice(&super::headers::retained_archive_metadata( + metadata, resources, + )?)?; + } + let main_header_len = main_header_len(inputs, &main_extra, resources)?; + + let quick_open_position = signature_len + .checked_add(inputs.head_crypt_len) + .and_then(|value| value.checked_add(main_header_len)) + .and_then(|value| value.checked_add(inputs.body_len)) + .ok_or(Error::InvalidArgument("RAR 5 archive layout overflows"))?; + let recovery_position = quick_open_position + .checked_add(quick_open_block_len) + .ok_or(Error::InvalidArgument("RAR 5 archive layout overflows"))?; + + let next_quick_open = quick_open_offset.map(|_| quick_open_position - signature_len); + let next_recovery = recovery_offset.map(|_| recovery_position - signature_len); + + if next_quick_open == quick_open_offset && next_recovery == recovery_offset { + return Ok(ResolvedLayout { + main_extra, + main_header_len, + recovery_offset, + recovery_prefix_len: inputs.recovery_percent.map(|_| recovery_position), + }); + } + + quick_open_offset = next_quick_open; + recovery_offset = next_recovery; + } +} + +/// Size of a main header carrying `extra`, as it will appear in the archive. +fn main_header_len( + inputs: &LayoutInputs<'_>, + extra: &[u8], + resources: &WriterResources, +) -> Result { + let mut specific = Bytes::new(resources); + specific.vint(inputs.main_flags)?; + if let Some(volume_number) = inputs.volume_number { + specific.vint(volume_number)?; + } + let header = block_header_image( + HEAD_MAIN, + if extra.is_empty() { 0 } else { HFL_EXTRA }, + None, + &specific, + extra, + resources, + )?; + Ok(emitted_header_len( + header.len() as u64, + inputs.header_encrypted, + )) +} + +/// Size of a stored service block, header and payload together. +pub(super) fn stored_service_block_len( + name: &[u8], + data_len: u64, + service_data: &[u8], + header_encrypted: bool, + resources: &WriterResources, +) -> Result { + let mut extra = Bytes::new(resources); + super::headers::write_extra_record(&mut extra, FHEXTRA_SUBDATA, service_data)?; + // The CRC is a fixed-width field, so any value gives the right size. + let specific = stored_file_specific(name, data_len, 0, 0, None, 0, resources)?; + let header = block_header_image( + HEAD_SERVICE, + HFL_EXTRA | HFL_DATA, + Some(data_len), + &specific, + &extra, + resources, + )?; + emitted_header_len(header.len() as u64, header_encrypted) + .checked_add(data_len) + .ok_or(Error::InvalidArgument("RAR 5 service block size overflows")) +} + +/// An encrypted header is a 16-byte IV followed by the plaintext padded up to +/// the AES block size. +fn emitted_header_len(plain_len: u64, header_encrypted: bool) -> u64 { + if header_encrypted { + 16 + plain_len.div_ceil(16) * 16 + } else { + plain_len + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn layout_header_sizes_release_preparation_charge_at_every_limit() { + for measure in [ + &(|resources: &WriterResources| main_header_len(&inputs(0), &[], resources)) + as &dyn Fn(&WriterResources) -> Result, + &(|resources: &WriterResources| { + stored_service_block_len(b"QO", 16, &[], false, resources) + }), + ] { + let mut succeeded = false; + let mut failed_after_admission = false; + for limit in 0..512 { + let resources = WriterResources::default().with_max_preparation_bytes(limit); + match measure(&resources) { + Ok(_) => { + succeeded = true; + break; + } + Err(Error::WriterPreparationLimitExceeded { used, .. }) => { + failed_after_admission |= used > 0; + drop(Bytes::zeroed(limit as usize, &resources).unwrap()); + } + Err(error) => panic!("unexpected limit {limit} failure: {error}"), + } + } + assert!(failed_after_admission); + assert!(succeeded); + } + } + + fn inputs(body_len: u64) -> LayoutInputs<'static> { + LayoutInputs { + header_encrypted: false, + head_crypt_len: 0, + main_flags: 0, + volume_number: None, + archive_metadata: None, + metadata_record: None, + body_len, + quick_open_payload_len: None, + recovery_percent: Some(5), + } + } + + /// The offsets a layout reports must be exactly where the blocks land when + /// the archive is assembled from the sizes it computed. + fn assert_self_consistent(inputs: &LayoutInputs<'_>, layout: &ResolvedLayout) { + let signature_len = RAR50_SIGNATURE.len() as u64; + let quick_open_position = + signature_len + inputs.head_crypt_len + layout.main_header_len + inputs.body_len; + + // Rebuilding the header with the settled offsets must not resize it. + let rebuilt = super::main_header_len( + inputs, + &layout.main_extra, + &crate::WriterResources::default(), + ) + .unwrap(); + assert_eq!(rebuilt, layout.main_header_len, "main header size moved"); + + let (records, complete) = crate::rar50::parse_main_extra_area( + &layout.main_extra, + 0..layout.main_extra.len(), + &crate::read_control::ReadControl::new(None), + ) + .unwrap(); + assert!(complete); + for record in records { + if let crate::rar50::MainExtraRecord::Locator(locator) = record { + assert_eq!( + locator.quick_open_offset, + inputs + .quick_open_payload_len + .map(|_| quick_open_position - signature_len) + .or_else(|| inputs.archive_metadata.map(|_| 0)) + ); + assert_eq!(locator.recovery_record_offset, layout.recovery_offset); + } + } + + if let Some(offset) = layout.recovery_offset { + let quick_open_block_len = match inputs.quick_open_payload_len { + Some(len) => stored_service_block_len( + b"QO", + len, + &[], + inputs.header_encrypted, + &crate::WriterResources::default(), + ) + .unwrap(), + None => 0, + }; + assert_eq!( + offset, + quick_open_position + quick_open_block_len - signature_len + ); + assert_eq!( + layout.recovery_prefix_len, + Some(offset + signature_len), + "recovery protects everything before its own block" + ); + } + } + + #[test] + fn layout_settles_across_vint_width_boundaries() { + // Body sizes chosen so the resulting offsets sit either side of each + // vint width step, which is where a naive single pass gets it wrong. + for boundary in [0x7fu64, 0x3fff, 0x1f_ffff, 0x0fff_ffff] { + for delta in [-3i64, -2, -1, 0, 1, 2, 3] { + let body_len = (boundary as i64 + delta).max(0) as u64; + let inputs = inputs(body_len); + let layout = resolve_layout(&inputs, &crate::WriterResources::default()).unwrap(); + assert_self_consistent(&inputs, &layout); + } + } + } + + #[test] + fn layout_settles_at_every_u64_offset_width_with_metadata_and_padding() { + let resources = WriterResources::default(); + for name_len in [0, 104, 120, 16_360] { + let metadata = crate::rar50::ArchiveMetadataRecord { + flags: 1, + name: Some(vec![b'x'; name_len]), + creation_time: None, + }; + for encrypted in [false, true] { + for features in 1..=3 { + let mut inputs = inputs(0); + inputs.header_encrypted = encrypted; + inputs.head_crypt_len = if encrypted { 60 } else { 0 }; + inputs.quick_open_payload_len = (features & 1 != 0).then_some(17); + inputs.recovery_percent = (features & 2 != 0).then_some(5); + inputs.metadata_record = (name_len != 0).then_some(&metadata); + let initial = resolve_layout(&inputs, &resources).unwrap(); + for bits in (7..=63).step_by(7) { + let boundary = 1u64 << bits; + let base = boundary + .saturating_sub(inputs.head_crypt_len + initial.main_header_len); + for delta in -32i64..=32 { + inputs.body_len = base.saturating_add_signed(delta); + let layout = resolve_layout(&inputs, &resources).unwrap(); + assert_self_consistent(&inputs, &layout); + } + } + } + } + } + } + + #[test] + fn layout_settles_with_quick_open_and_recovery_together() { + for body_len in [0u64, 100, 0x3ffe, 0x4001, 1 << 20] { + let mut inputs = inputs(body_len); + inputs.quick_open_payload_len = Some(4096); + let layout = resolve_layout(&inputs, &crate::WriterResources::default()).unwrap(); + + // assert_self_consistent checks that the recovery offset leaves + // room for the whole quick-open block ahead of it. + assert!(layout.recovery_offset.is_some()); + assert_self_consistent(&inputs, &layout); + } + } + + #[test] + fn layout_accounts_for_encrypted_header_padding() { + let mut inputs = inputs(1024); + inputs.header_encrypted = true; + inputs.head_crypt_len = 60; + let layout = resolve_layout(&inputs, &crate::WriterResources::default()).unwrap(); + + assert_eq!( + layout.main_header_len % 16, + 0, + "an IV plus padded ciphertext is a multiple of the block size" + ); + assert_self_consistent(&inputs, &layout); + } + + #[test] + fn layout_without_locator_features_has_no_offsets() { + let mut inputs = inputs(4096); + inputs.recovery_percent = None; + let layout = resolve_layout(&inputs, &crate::WriterResources::default()).unwrap(); + + assert_eq!(layout.recovery_offset, None); + assert_eq!(layout.recovery_prefix_len, None); + assert!(layout.main_extra.is_empty()); + } + + #[test] + fn layout_includes_retained_metadata_before_solving_offsets() { + let metadata = crate::rar50::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: Some(123), + }; + let mut inputs = inputs(4096); + inputs.metadata_record = Some(&metadata); + inputs.quick_open_payload_len = Some(17); + let layout = resolve_layout(&inputs, &crate::WriterResources::default()).unwrap(); + assert!(!layout.main_extra.is_empty()); + assert_self_consistent(&inputs, &layout); + } + + #[test] + fn retained_layout_metadata_obeys_preparation_limit() { + let metadata = crate::rar50::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: Some(123), + }; + let mut inputs = inputs(0); + inputs.quick_open_payload_len = None; + inputs.recovery_percent = None; + inputs.metadata_record = Some(&metadata); + let resources = crate::WriterResources::default().with_max_preparation_bytes(0); + assert!(matches!( + resolve_layout(&inputs, &resources), + Err(Error::WriterPreparationLimitExceeded { limit: 0, .. }) + )); + } + + #[test] + fn layout_rejects_offset_and_service_length_overflow() { + let resources = crate::WriterResources::default(); + for (body_len, head_crypt_len, quick_open_payload_len) in + [(u64::MAX, 0, None), (0, u64::MAX, None)] + { + let mut inputs = inputs(body_len); + inputs.head_crypt_len = head_crypt_len; + inputs.quick_open_payload_len = quick_open_payload_len; + assert_eq!( + resolve_layout(&inputs, &resources).unwrap_err(), + Error::InvalidArgument("RAR 5 archive layout overflows") + ); + } + assert_eq!( + stored_service_block_len(b"QO", u64::MAX, &[], false, &resources).unwrap_err(), + Error::InvalidArgument("RAR 5 service block size overflows") + ); + } + + #[test] + fn layout_and_service_sizing_release_refused_admission() { + let ledger = crate::codec::workspace::Allowance::limited(0); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + assert_eq!( + resolve_layout(&inputs(0), &resources).err().unwrap().kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(ledger.used(), 0); + assert_eq!( + stored_service_block_len(b"QO", 1, &[], false, &resources) + .unwrap_err() + .kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(ledger.used(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/mod.rs b/arca-rar/vendor/rars/src/rar50/write/mod.rs new file mode 100644 index 00000000..c6490562 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/mod.rs @@ -0,0 +1,2867 @@ +use super::*; +use crate::crc32::Crc32; +#[cfg(feature = "encryption")] +use crate::crypto::rar50::Rar50Cipher; +use crate::crypto::rar50::Rar50Keys; +pub use crate::filter::{FilterKind, FilterPolicy, FilterSpec}; +use crate::write_plan::{PlanShape, WriterOption}; +use crate::write_progress::ProgressReporter; +use crate::{EntrySource, WriteProgress, WriterResources}; +use std::io::{Read, Write}; + +mod compress; +mod engine; +mod filter_policy; +pub(crate) mod headers; +mod layout; +mod plan; +#[cfg(test)] +use filter_policy::encode_options_for_level; +use filter_policy::{ + compression_method_for_level, dictionary_size_for_options, encode_option_candidates_for_level, + filter_policy_walk_bytes, rar50_algorithm_version, +}; +pub(super) use headers::end_header_specific; + +const DEFAULT_RAR50_DICTIONARY_SIZE: u64 = 128 * 1024; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct WriterOptions { + pub target: crate::ArchiveVersion, + pub features: crate::FeatureSet, + pub compression_level: Option, + pub dictionary_size: Option, +} + +impl WriterOptions { + pub const fn new(target: crate::ArchiveVersion, features: crate::FeatureSet) -> Self { + Self { + target, + features, + compression_level: None, + dictionary_size: None, + } + } + + pub const fn with_compression_level(mut self, level: u8) -> Self { + self.compression_level = Some(level); + self + } + + pub const fn with_dictionary_size(mut self, size: u64) -> Self { + self.dictionary_size = Some(size); + self + } +} + +impl Default for WriterOptions { + fn default() -> Self { + Self { + target: crate::ArchiveVersion::Rar50, + features: crate::FeatureSet::store_only(), + compression_level: None, + dictionary_size: None, + } + } +} + +/// An archive member, read from a reopenable source when it is needed. +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct ArchiveEntry { + pub name: Vec, + pub source: EntrySource, + /// Explicit directory entry; its source must be empty. + pub is_directory: bool, + /// Optional redirection metadata; the source must be empty. + pub redirection: Option, + /// Logical size from a retained redirection header. + pub redirection_size: Option, + pub mtime: Option, + /// Optional nanosecond fraction; requires mtime and a value below one second. + pub mtime_nanoseconds: Option, + pub file_times: Option, + pub attributes: u64, + pub host_os: u64, + /// Encrypts this member's payload. With header encryption every member + /// must use the same password. + pub password: Option>, + /// Service records attached to this member, such as a file comment. + pub services: Vec, +} + +/// A small named record attached to an archive or a member. +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct ServiceEntry { + /// Service name, such as `CMT`, `ACL` or `STM`. + pub name: Vec, + pub data: Vec, + pub password: Option>, +} + +impl ServiceEntry { + pub fn new(name: impl Into>, data: impl Into>) -> Self { + Self { + name: name.into(), + data: data.into(), + password: None, + } + } + + pub fn with_password(mut self, password: impl Into>) -> Self { + self.password = Some(password.into()); + self + } +} + +impl ArchiveEntry { + pub fn new(name: impl Into>, source: EntrySource) -> Self { + Self { + name: name.into(), + source, + is_directory: false, + redirection: None, + redirection_size: None, + mtime: None, + mtime_nanoseconds: None, + file_times: None, + attributes: 0, + host_os: 0, + password: None, + services: Vec::new(), + } + } + + pub fn with_directory(mut self, is_directory: bool) -> Self { + self.is_directory = is_directory; + self + } + + pub fn with_redirection_size(mut self, size: Option) -> Self { + self.redirection_size = size; + self + } + + pub fn with_redirection(mut self, redirection: Option) -> Self { + self.redirection = redirection; + self + } + + pub fn with_service(mut self, service: ServiceEntry) -> Self { + self.services.push(service); + self + } + + pub fn with_file_times(mut self, times: Option) -> Self { + self.file_times = times; + self + } + + pub fn with_mtime(mut self, mtime: Option) -> Self { + self.mtime = mtime; + self + } + + pub fn with_mtime_nanoseconds(mut self, nanoseconds: Option) -> Self { + self.mtime_nanoseconds = nanoseconds; + self + } + + pub fn with_attributes(mut self, attributes: u64) -> Self { + self.attributes = attributes; + self + } + + pub fn with_host_os(mut self, host_os: u64) -> Self { + self.host_os = host_os; + self + } + + pub fn with_password(mut self, password: impl Into>) -> Self { + self.password = Some(password.into()); + self + } +} + +/// Receives each volume of a multi-volume archive as it is finished. +pub trait VolumeSink { + /// Opens the output for volume `index`, numbered from zero. + fn start_volume(&mut self, index: u64) -> Result>; + + /// Called once volume `index` has been written and flushed. + fn finish_volume(&mut self, index: u64, len: u64) -> Result<()> { + let _ = (index, len); + Ok(()) + } +} + +/// A [`VolumeSink`] that keeps the whole set in memory. +/// +/// The point of the sink is that a caller need not, so this is for the callers +/// that want the bytes back anyway: the Python bindings hand Python a list, and +/// tests inspect what was written. Four hand-rolled copies of it had grown up, +/// and only two of them checked that volumes arrived in order. +#[derive(Debug, Default)] +pub struct CollectedVolumes { + volumes: std::sync::Arc>>>, +} + +struct CollectedVolume { + volumes: std::sync::Arc>>>, + index: usize, +} + +impl CollectedVolumes { + pub fn new() -> Self { + Self::default() + } + + /// The finished set, in order. Takes the volumes rather than copying them, + /// so a set that only just fitted in memory does not need twice the room. + pub fn take(&mut self) -> Vec> { + std::mem::take( + &mut *self + .volumes + .lock() + .expect("volume collector is not poisoned"), + ) + } +} + +impl Write for CollectedVolume { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + self.volumes + .lock() + .expect("volume collector is not poisoned")[self.index] + .extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +impl VolumeSink for CollectedVolumes { + fn start_volume(&mut self, index: u64) -> Result> { + let mut volumes = self + .volumes + .lock() + .expect("volume collector is not poisoned"); + if volumes.len() as u64 != index { + return Err(Error::WriterFailure("RAR 5 volumes arrived out of order")); + } + volumes.push(Vec::new()); + drop(volumes); + Ok(Box::new(CollectedVolume { + volumes: std::sync::Arc::clone(&self.volumes), + index: index as usize, + })) + } + + fn finish_volume(&mut self, index: u64, len: u64) -> Result<()> { + let volumes = self + .volumes + .lock() + .expect("volume collector is not poisoned"); + if volumes[index as usize].len() as u64 != len { + return Err(Error::WriterFailure( + "RAR 5 volume length does not match what was written", + )); + } + Ok(()) + } +} + +/// Writes a multi-volume RAR 5 or RAR 7 archive, handing each volume to `sink` +/// as it completes so the set is never held in memory. +pub fn write_streaming_volumes_to( + entries: &[ArchiveEntry], + options: WriterOptions, + extras: ArchiveExtras<'_>, + max_payload_per_volume: u64, + sink: &mut dyn VolumeSink, + resources: &WriterResources, +) -> Result<()> { + write_streaming_volumes_with_progress( + entries, + options, + extras, + max_payload_per_volume, + sink, + resources, + None, + ) +} + +/// As [`write_streaming_volumes_to`], reporting compression progress as it +/// goes. +pub fn write_streaming_volumes_with_progress( + entries: &[ArchiveEntry], + options: WriterOptions, + extras: ArchiveExtras<'_>, + max_payload_per_volume: u64, + sink: &mut dyn VolumeSink, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, +) -> Result<()> { + let control = + crate::write_progress::ResourceProgress::new(resources, progress.map(ProgressReporter)); + let progress: Option<&dyn WriteProgress> = + (progress.is_some() || resources.has_cancellation()).then_some(&control); + crate::write_progress::check_cancelled(progress.map(ProgressReporter))?; + let encrypted = entries.iter().any(|entry| entry.password.is_some()); + if encrypted && !entries.iter().all(|entry| entry.password.is_some()) { + return Err(Error::UnsupportedFeature { + version: options.target, + feature: "RAR 5 writer mixing encrypted and plain members", + }); + } + let shape = PlanShape::new() + .compressed(true) + .volumes(true) + .filtered(extras.filter_policy != FilterPolicy::None); + // One option at a time, so a refusal names the one that was asked for. + // This used to be a single check over all three, which reported a string + // naming every option it covered whichever one the caller had set. Quick + // open rides on the feature set, so `validate_plan` catches that one. + validate_plan(options, shape)?; + if extras.locked { + return Err(Error::InvalidArgument( + "archive lock flag is not supported in volume output", + )); + } + if extras.comment.is_some() { + crate::write_plan::validate_option(options.target, WriterOption::ArchiveComment, shape)?; + } + if extras.metadata.is_some() || extras.metadata_record.is_some() { + crate::write_plan::validate_option(options.target, WriterOption::ArchiveMetadata, shape)?; + } + // The volume preparation path does not carry redirection metadata. + if entries.iter().any(|entry| entry.redirection.is_some()) { + return Err(Error::InvalidArgument( + "symbolic links are not supported in volume output", + )); + } + // A member's services are validated with it and then had nowhere to go: + // `prepare_volume_member` never reads them, so a file comment asked for on + // a split set was accepted and then dropped without a word. + if entries.iter().any(|entry| !entry.services.is_empty()) { + crate::write_plan::validate_option(options.target, WriterOption::FileComment, shape)?; + } + // A set with no members produces no volumes at all: the writer would + // return success having never asked the sink for a single one. + if entries.is_empty() { + return Err(Error::InvalidArgument( + "RAR 5 volume writer needs at least one member", + )); + } + if let Some(percent) = extras.recovery_percent { + validate_recovery_percent(percent)?; + } + if options.features.header_encryption && !encrypted && extras.header_password.is_none() { + return Err(Error::NeedPassword); + } + + engine::write_volumes( + entries, + engine::EnginePlan { + compress: compression_plan( + options, + extras.filter_policy, + dictionary_reach(entries, options.features.solid), + resources.memory_limit(), + resources, + )?, + recovery_percent: extras.recovery_percent, + header_encrypted: options.features.header_encryption, + header_password: extras.header_password, + archive_comment: None, + archive_metadata: None, + metadata_record: None, + locked: extras.locked, + // No volume writer emits the index, and `validate_plan` refuses a + // set that asks for one, so this is the only value that can get + // here rather than a decision taken quietly on the caller's behalf. + quick_open: false, + progress: progress.map(ProgressReporter), + }, + max_payload_per_volume, + sink, + resources, + ) +} + +/// Archive-level options that sit alongside the members. +#[derive(Debug, Clone, Default)] +#[non_exhaustive] +pub struct ArchiveExtras<'a> { + /// Archive comment, stored as a `CMT` service record. + pub comment: Option<&'a [u8]>, + /// Encrypts the comment. Without it the comment is stored in the clear. + pub comment_password: Option<&'a [u8]>, + /// Password for encrypted headers, including archives without members. + /// When omitted, uses the shared member password. When supplied, must + /// agree with any member passwords; ignored unless header encryption is set. + pub header_password: Option<&'a [u8]>, + pub metadata: Option>, + /// Complete retained metadata, mutually exclusive with `metadata`. + pub metadata_record: Option<&'a super::ArchiveMetadataRecord>, + /// Retains the advisory archive lock flag. + pub locked: bool, + /// Whether to look for a data filter that makes members compress better. + pub filter_policy: FilterPolicy, + /// Percentage of the archive to spend on a recovery record. + pub recovery_percent: Option, +} + +impl<'a> ArchiveExtras<'a> { + pub fn with_comment(mut self, comment: &'a [u8]) -> Self { + self.comment = Some(comment); + self + } + + pub fn with_encrypted_comment(mut self, comment: &'a [u8], password: &'a [u8]) -> Self { + self.comment = Some(comment); + self.comment_password = Some(password); + self + } + + pub fn with_metadata(mut self, metadata: ArchiveMetadataEntry<'a>) -> Self { + self.metadata = Some(metadata); + self + } + + pub fn with_filter_policy(mut self, policy: FilterPolicy) -> Self { + self.filter_policy = policy; + self + } + + pub fn with_recovery_percent(mut self, percent: Option) -> Self { + self.recovery_percent = percent; + self + } +} + +/// Writes a RAR 5 or RAR 7 archive to `output`, admitting estimated compression +/// workspace through `resources`. Packed payloads are retained in spools before +/// emission. This is not a total RAM or temporary-disk limit; bare-WASM spools +/// remain in memory. +/// +/// Supports solid compression, per-member and header encryption, and recovery +/// records, in any combination. +pub fn write_streaming_archive_to( + entries: &[ArchiveEntry], + options: WriterOptions, + extras: ArchiveExtras<'_>, + resources: &WriterResources, + output: &mut dyn Write, +) -> Result<()> { + write_streaming_archive_reporting(entries, options, extras, resources, None, output) +} + +/// As [`write_streaming_archive_to`], reporting compression progress as it +/// goes. +pub fn write_streaming_archive_with_progress( + entries: &[ArchiveEntry], + options: WriterOptions, + extras: ArchiveExtras<'_>, + resources: &WriterResources, + progress: Option<&dyn WriteProgress>, + output: &mut dyn Write, +) -> Result<()> { + write_streaming_archive_reporting( + entries, + options, + extras, + resources, + progress.map(ProgressReporter), + output, + ) +} + +pub(crate) fn write_streaming_archive_reporting( + entries: &[ArchiveEntry], + options: WriterOptions, + extras: ArchiveExtras<'_>, + resources: &WriterResources, + progress: Option>, + output: &mut dyn Write, +) -> Result<()> { + let control = crate::write_progress::ResourceProgress::new(resources, progress); + let progress = + (progress.is_some() || resources.has_cancellation()).then_some(ProgressReporter(&control)); + crate::write_progress::check_cancelled(progress)?; + let encrypted = entries.iter().any(|entry| entry.password.is_some()); + if extras.metadata.is_some() && extras.metadata_record.is_some() { + return Err(Error::InvalidArgument( + "duplicate archive metadata settings", + )); + } + let recovery_percent = extras.recovery_percent; + validate_plan( + options, + PlanShape::new() + .compressed(true) + .filtered(extras.filter_policy != FilterPolicy::None), + )?; + if let Some(percent) = recovery_percent { + validate_recovery_percent(percent)?; + } + if options.features.header_encryption && !encrypted && extras.header_password.is_none() { + return Err(Error::NeedPassword); + } + engine::write_archive( + entries, + engine::EnginePlan { + compress: compression_plan( + options, + extras.filter_policy, + dictionary_reach(entries, options.features.solid), + resources.memory_limit(), + resources, + )?, + recovery_percent, + header_encrypted: options.features.header_encryption, + header_password: extras.header_password, + archive_comment: match (extras.comment, extras.comment_password) { + (Some(data), Some(password)) => { + Some(engine::ArchiveCommentPlan::Encrypted { data, password }) + } + (Some(data), None) => Some(engine::ArchiveCommentPlan::Plain(data)), + (None, _) => None, + }, + archive_metadata: extras.metadata, + metadata_record: extras.metadata_record, + locked: extras.locked, + quick_open: options.features.quick_open, + progress, + }, + resources, + output, + ) +} + +/// How far one dictionary has to reach for these members. +/// +/// Solid members are coded as one chain through a single window, so a match can +/// point back into an earlier member and the whole archive is in reach. +/// Otherwise each member starts afresh and only the largest one matters. A +/// source that cannot say how long it is takes the largest window the writer +/// fits on its own, rather than the smallest. +fn dictionary_reach(entries: &[ArchiveEntry], solid: bool) -> u64 { + let sizes = entries + .iter() + .map(|entry| entry.source.len().unwrap_or(u64::MAX)); + if solid { + sizes.fold(0u64, u64::saturating_add) + } else { + sizes.max().unwrap_or(0) + } +} + +fn compression_plan( + options: WriterOptions, + filter_policy: FilterPolicy, + content: u64, + memory_limit: u64, + resources: &WriterResources, +) -> Result { + let method = compression_method_for_level(options.compression_level)?; + // A stored member has no window to reach across, and the size still lands in + // its header, so fitting one to the data would only inflate what the header + // claims. + let reach = if method == 0 { 0 } else { content }; + let dictionary_size = dictionary_size_for_options(options, reach, memory_limit)?; + let candidates = + encode_option_candidates_for_level(options.compression_level, dictionary_size)?; + let encode_options = *candidates.first().ok_or(Error::WriterFailure( + "RAR 5 compression level has no encoder options", + ))?; + Ok(compress::CompressPlan { + algorithm_version: rar50_algorithm_version(options, dictionary_size)?, + encode_options, + dictionary_size, + block_size: crate::codec::rar50::LZ_BLOCK_SIZE, + solid: options.features.solid, + method, + filter_policy, + candidates: crate::streaming::preparation::Records::collect( + candidates.into_iter().map(Ok), + resources, + )?, + }) +} + +fn source_integrity( + source: &EntrySource, + expected_size: u64, + block_size: usize, + progress: &dyn compress::CompressionProgress, + _resources: &WriterResources, +) -> Result<(u32, [u8; 32])> { + if let Some(allowance) = &_resources.execution { + return source_integrity_with_allowance( + source, + expected_size, + block_size, + progress, + allowance, + ); + } + source_integrity_with_allowance( + source, + expected_size, + block_size, + progress, + &crate::codec::workspace::Allowance::default(), + ) +} + +fn source_integrity_with_allowance( + source: &EntrySource, + expected_size: u64, + block_size: usize, + progress: &dyn compress::CompressionProgress, + allowance: &B, +) -> Result<(u32, [u8; 32])> { + if progress.is_cancelled() { + return Err(Error::Cancelled); + } + let mut crc = Crc32::new(); + let mut hash = blake2sp::Hasher::new(); + let mut buffer = crate::codec::workspace::Buffer::filled(block_size, 0u8, allowance)?; + let mut reader = source.open()?; + let mut observed = 0u64; + let mut limited = reader.by_ref().take(expected_size); + loop { + if progress.is_cancelled() { + return Err(Error::Cancelled); + } + let read = limited.read(&mut buffer)?; + if read == 0 { + break; + } + observed += read as u64; + crc.update(&buffer[..read]); + hash.update(&buffer[..read]); + } + crate::write_stream::check_source_length( + &mut *reader, + observed, + expected_size, + "entry source size changed while reading", + )?; + Ok((crc.finish(), hash.finalize())) +} + +/// What one compression job holds, for admitting jobs against the memory limit +/// and for shrinking a fitted dictionary until it fits. +/// +/// Nearly all of it is the match finder's chain links: four bytes per byte of +/// window, and the window is a power of two, so a dictionary just over one costs +/// almost double the one just under. That rounding is why a flat multiple of the +/// dictionary never described this well. It used to charge twelve times the +/// dictionary, which is the middle of the eight-to-sixteen the rounding then +/// produced, so it over-charged a dictionary that was already a power of two and +/// came close to under-charging one that had just crossed. +/// +/// Peak resident bytes for one member encode, over the member itself, taken on a +/// 16 MiB member so every window is filled: +/// +/// ```text +/// dictionary measured links alone +/// 256 KiB 6,197,248 1,048,576 +/// 1 MiB 9,170,944 4,194,304 +/// 3 MiB 20,152,320 16,777,216 +/// 4 MiB 20,234,240 16,777,216 +/// 8 MiB 36,941,824 33,554,432 +/// ``` +/// +/// The links account for the whole shape; what is left is the hash heads, the +/// token buffer for one block, and the packed output. Three megabytes covers +/// those with room to spare, and the fifth byte per window position absorbs the +/// rest rather than pretending to predict it. +/// +/// The optimal parse searches a binary tree instead of hash chains, and a tree +/// holds two links per window position where a chain holds one. So it is eight +/// bytes per byte of window rather than four, and the charge doubles the links +/// and keeps the one byte of slack. Measured on the same 16 MiB member, over +/// the member, against a 512-candidate parse: +/// +/// ```text +/// dictionary measured tree links alone +/// 256 KiB 19,668,992 2,097,152 +/// 1 MiB 21,794,816 8,388,608 +/// 4 MiB 47,030,272 33,554,432 +/// 8 MiB 75,390,976 67,108,864 +/// 16 MiB 109,412,352 134,217,728 +/// ``` +/// +/// The last row measures under its links because a 16 MiB member cannot fill a +/// 16 MiB window: the pages behind the untouched slots never become resident. +/// The charge covers the allocation anyway, since data that does fill the +/// window will touch them. +/// +/// `block_size` is the largest block the parse can be holding, not the size the +/// reader asks for: a block grows past that when the data it covers is not +/// moving, and the parse's arrays grow with it. See +/// [`crate::codec::rar50::MAX_LZ_BLOCK_SIZE`]. +fn streaming_lz_workspace(dictionary_size: u64, block_size: usize, optimal_parse: bool) -> u64 { + // Runs retain up to a dictionary of new input as well as history and + // combined search bytes. Charge those buffers alongside finder links. + let per_window_byte = if optimal_parse { 17 } else { 13 }; + dictionary_size + .checked_next_power_of_two() + .unwrap_or(dictionary_size) + .saturating_mul(per_window_byte) + // Repricing can retain an earlier winner beside the current and next + // token streams, in addition to the reused DP arrays and match cache. + .saturating_add((block_size as u64).saturating_mul(if optimal_parse { 160 } else { 64 })) + .saturating_add(3 * 1024 * 1024) +} + +#[allow(clippy::too_many_arguments)] +fn encrypt_reader_to( + reader: &mut dyn Read, + input_size: u64, + output: &mut dyn Write, + keys: &Rar50Keys, + iv: [u8; 16], + block_size: usize, + progress: Option>, + _resources: &WriterResources, +) -> Result<()> { + if let Some(allowance) = &_resources.execution { + return encrypt_reader_with_allowance( + reader, input_size, output, keys, iv, block_size, progress, allowance, + ); + } + encrypt_reader_with_allowance( + reader, + input_size, + output, + keys, + iv, + block_size, + progress, + &crate::codec::workspace::Allowance::default(), + ) +} + +#[allow(clippy::too_many_arguments)] +fn encrypt_reader_with_allowance( + reader: &mut dyn Read, + input_size: u64, + output: &mut dyn Write, + keys: &Rar50Keys, + iv: [u8; 16], + block_size: usize, + progress: Option>, + allowance: &B, +) -> Result<()> { + #[cfg(not(feature = "encryption"))] + { + let _ = ( + reader, input_size, output, keys, iv, block_size, progress, allowance, + ); + Err(Error::FeatureDisabled { + feature: "encryption", + }) + } + #[cfg(feature = "encryption")] + { + crate::write_progress::check_cancelled(progress)?; + if input_size == 0 { + return Ok(()); + } + let mut cipher = Rar50Cipher::new(keys.key, iv); + let chunk_size = block_size.max(16) & !15; + let mut buffer = crate::codec::workspace::Buffer::filled(chunk_size, 0u8, allowance)?; + let mut remaining = input_size; + while remaining >= chunk_size as u64 { + crate::write_progress::check_cancelled(progress)?; + reader.read_exact(&mut buffer)?; + cipher + .encrypt_in_place(&mut buffer) + .map_err(super::map_rar50_crypto_error)?; + output.write_all(&buffer)?; + remaining -= chunk_size as u64; + } + let final_plain = usize::try_from(remaining) + .map_err(|_| Error::InvalidArgument("RAR 5 encrypted data size overflows"))?; + let final_padded = final_plain.checked_add(15).ok_or(Error::InvalidArgument( + "RAR 5 encrypted data size overflows", + ))? & !15; + if final_padded != 0 { + crate::write_progress::check_cancelled(progress)?; + buffer[..final_padded].fill(0); + reader.read_exact(&mut buffer[..final_plain])?; + cipher + .encrypt_in_place(&mut buffer[..final_padded]) + .map_err(super::map_rar50_crypto_error)?; + output.write_all(&buffer[..final_padded])?; + } + Ok(()) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ArchiveMetadataEntry<'a> { + pub name: Option<&'a [u8]>, + pub creation_time: Option, +} + +/// Builds a RAR 5 or RAR 7 archive from members held in memory. +/// +/// [`write_streaming_archive_to`] is the same writer without the buffer; this +/// exists for callers that want the bytes back. +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct Rar50Writer<'a> { + options: WriterOptions, + entries: Vec, + archive_comment: Option<&'a [u8]>, + archive_comment_password: Option<&'a [u8]>, + archive_metadata: Option>, + filter_policy: FilterPolicy, + recovery_percent: Option, + progress: Option>, +} + +impl<'a> Rar50Writer<'a> { + pub fn new(options: WriterOptions) -> Self { + Self { + options, + entries: Vec::new(), + archive_comment: None, + archive_comment_password: None, + archive_metadata: None, + filter_policy: FilterPolicy::None, + recovery_percent: None, + progress: None, + } + } + + pub fn entry(mut self, entry: ArchiveEntry) -> Self { + self.entries.push(entry); + self + } + + pub fn entries(mut self, entries: impl IntoIterator) -> Self { + self.entries.extend(entries); + self + } + + pub fn archive_comment(mut self, comment: Option<&'a [u8]>) -> Self { + self.archive_comment = comment; + self.archive_comment_password = None; + self + } + + pub fn encrypted_archive_comment(mut self, comment: &'a [u8], password: &'a [u8]) -> Self { + self.archive_comment = Some(comment); + self.archive_comment_password = Some(password); + self + } + + pub fn archive_metadata(mut self, metadata: Option>) -> Self { + self.archive_metadata = metadata; + self + } + + pub fn filter_policy(mut self, policy: FilterPolicy) -> Self { + self.filter_policy = policy; + self + } + + pub fn recovery_percent(mut self, percent: Option) -> Self { + self.recovery_percent = percent; + self + } + + pub fn progress(mut self, progress: &'a dyn WriteProgress) -> Self { + self.progress = Some(ProgressReporter(progress)); + self + } + + /// Builds the archive in memory. Prefer [`Rar50Writer::write_to`], which + /// streams it instead. + pub fn finish(self) -> Result> { + self.finish_with_resources(&WriterResources::default()) + } + + pub fn finish_with_resources(self, resources: &WriterResources) -> Result> { + let mut out = crate::WriterOutput::new(resources); + self.write_to(&mut out, resources)?; + Ok(out.into_vec()) + } + + /// Writes the archive straight to `output` without ever holding it. + pub fn write_to(self, output: &mut dyn Write, resources: &WriterResources) -> Result<()> { + let mut extras = ArchiveExtras::default() + .with_recovery_percent(self.recovery_percent) + .with_filter_policy(self.filter_policy); + if let Some(comment) = self.archive_comment { + extras = match self.archive_comment_password { + Some(password) => extras.with_encrypted_comment(comment, password), + None => extras.with_comment(comment), + }; + } + if let Some(metadata) = self.archive_metadata { + extras = extras.with_metadata(metadata); + } + + write_streaming_archive_reporting( + &self.entries, + self.options, + extras, + resources, + self.progress, + output, + ) + } +} + +/// Everything this writer refuses, in one place, before anything is written. +/// +/// This replaced a six-by-two matrix of near-identical checks, one per shape of +/// member the builder accepts. Each built a set of allowed features and compared +/// it with the request, and several built it by assigning a flag to itself, +/// which accepted the flag whatever it said. +fn validate_plan(options: WriterOptions, shape: PlanShape) -> Result<()> { + if options.target.family() != crate::version::ArchiveFamily::Rar50Plus { + return Err(Error::UnsupportedVersion(options.target)); + } + crate::write_plan::validate_features(options.target, options.features, shape)?; + crate::write_plan::validate_compression_level(options.target, options.compression_level)?; + let _ = dictionary_size_for_options(options, 0, u64::MAX)?; + // Quick-open is an index of the headers, so it has nothing to index once + // they are encrypted. + if options.features.quick_open && options.features.header_encryption { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: WriterOption::Feature(crate::Feature::QuickOpen), + because: Some("with header encryption"), + }); + } + // Solid members share one dictionary and are coded as one chain, so the + // filter search never runs for them. Relations between two requests cannot + // be expressed in the capability table, which is why this lives here rather + // than in `supports`. + if shape.filtered && options.features.solid { + return Err(Error::UnsupportedWriterOption { + target: options.target, + option: WriterOption::Filter, + because: Some("in a solid archive"), + }); + } + Ok(()) +} + +fn validate_recovery_percent(percent: u64) -> Result<()> { + if !cfg!(feature = "recovery") { + return Err(Error::FeatureDisabled { + feature: "recovery", + }); + } + if !(1..=100).contains(&percent) { + return Err(Error::InvalidArgument( + "RAR 5 recovery percent must be in 1..=100", + )); + } + Ok(()) +} + +fn validate_nonempty_password(password: &[u8]) -> Result<()> { + crate::crypto::require_encryption()?; + + if password.is_empty() { + return Err(Error::InvalidArgument( + "RAR 5 encrypted writer needs a non-empty password", + )); + } + Ok(()) +} + +fn validate_file_entry(name: &[u8]) -> Result<()> { + if name.is_empty() { + return Err(Error::InvalidArgument("RAR 5 file name is empty")); + } + Ok(()) +} + +/// Checks one member and everything hanging off it. +/// +/// Both entry points run this now. It used to be six near-identical validators, +/// one per shape of member the builder took, and the streaming path ran none of +/// them beyond the name. +fn validate_entry(entry: &ArchiveEntry) -> Result<()> { + validate_file_entry(&entry.name)?; + if let Some(link) = &entry.redirection { + if !link.supports_header(entry.host_os, entry.attributes, entry.is_directory) + || (link.redirection_type >= 4 && entry.redirection_size.is_none()) + || entry.source.len()? != 0 + { + return Err(Error::InvalidArgument( + "redirections require supported target metadata and empty contents", + )); + } + } + if entry.redirection.is_none() && entry.redirection_size.is_some() { + return Err(Error::InvalidArgument( + "redirection size requires a redirection record", + )); + } + if entry.is_directory && entry.source.len()? != 0 { + return Err(Error::InvalidArgument( + "directory entries cannot carry file contents", + )); + } + if let Some(times) = entry.file_times { + times.encode()?; + if entry.mtime_nanoseconds.is_some() || (entry.mtime.is_some() && times.modified.is_some()) + { + return Err(Error::InvalidArgument( + "conflicting file modification timestamps", + )); + } + } + if let Some(nanos) = entry.mtime_nanoseconds { + if entry.mtime.is_none() || nanos >= 1_000_000_000 { + return Err(Error::InvalidArgument( + "fractional modification time requires seconds and nanoseconds below one second", + )); + } + } + if let Some(password) = &entry.password { + validate_nonempty_password(password)?; + } + entry.services.iter().try_for_each(validate_service) +} + +fn validate_service(service: &ServiceEntry) -> Result<()> { + // Encrypting a service record is only wired up for comments, so an + // encrypted ACL or STM would be written in the clear. + let allowed: &[&[u8]] = match service.password { + Some(_) => &[b"CMT"], + None => &[b"ACL", b"STM", b"CMT"], + }; + if !allowed.contains(&service.name.as_slice()) { + return Err(Error::UnsupportedFeature { + version: crate::ArchiveVersion::Rar50, + feature: "RAR 5 file service name", + }); + } + // An explicit empty comment is distinct from having no comment record. + if service.data.is_empty() && service.name != b"CMT" { + return Err(Error::InvalidArgument("RAR 5 file service data is empty")); + } + match &service.password { + Some(password) => validate_nonempty_password(password), + None => Ok(()), + } +} + +#[cfg(test)] +mod tests { + use super::VolumeSink; + + #[test] + fn source_integrity_cancellation_and_short_read_fail_before_hashing() { + struct Cancelled; + impl super::compress::CompressionProgress for Cancelled { + fn advance(&self, _: u64) -> bool { + false + } + fn is_cancelled(&self) -> bool { + true + } + } + let unopened = + crate::EntrySource::from_opener(1, || panic!("cancelled scan opened the source")); + let allowance = crate::codec::workspace::Allowance::default(); + assert!(matches!( + super::source_integrity_with_allowance(&unopened, 1, 16, &Cancelled, &allowance), + Err(crate::Error::Cancelled) + )); + + let short = crate::EntrySource::from_opener(2, || { + Ok(Box::new(std::io::Cursor::new(b"x".to_vec()))) + }); + let progress = |_: u64| true; + assert_eq!( + super::source_integrity_with_allowance(&short, 2, 16, &progress, &allowance) + .unwrap_err() + .kind(), + crate::ErrorKind::SourceChanged + ); + } + + #[test] + fn volume_compression_plan_refusal_does_not_open_sources_or_start_a_volume() { + let entries = [super::ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_opener(1, || panic!("plan refusal opened source")), + )]; + let resources = crate::WriterResources::default().with_max_preparation_bytes(0); + let mut volumes = super::CollectedVolumes::new(); + let error = super::write_streaming_volumes_to( + &entries, + super::WriterOptions::new( + crate::ArchiveVersion::Rar50, + crate::FeatureSet::store_only(), + ), + super::ArchiveExtras::default(), + 64, + &mut volumes, + &resources, + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert!(volumes.take().is_empty()); + } + + #[test] + fn collected_volumes_enforce_order_and_report_length_mismatch() { + let mut volumes = super::CollectedVolumes::new(); + assert!(matches!( + volumes.start_volume(1), + Err(crate::Error::WriterFailure( + "RAR 5 volumes arrived out of order" + )) + )); + let mut output = volumes.start_volume(0).unwrap(); + output.write_all(b"abc").unwrap(); + output.flush().unwrap(); + assert!(matches!( + volumes.finish_volume(0, 2), + Err(crate::Error::WriterFailure( + "RAR 5 volume length does not match what was written" + )) + )); + volumes.finish_volume(0, 3).unwrap(); + drop(output); + assert_eq!(volumes.take(), [b"abc".to_vec()]); + } + + #[test] + fn writer_plan_rejects_wrong_family_and_solid_filters_before_opening_source() { + let entry = || { + super::ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_opener(1, || panic!("invalid plan opened source")), + ) + }; + let wrong_family = super::Rar50Writer::new(super::WriterOptions::new( + crate::ArchiveVersion::Rar29, + crate::FeatureSet::store_only(), + )) + .entry(entry()) + .finish() + .unwrap_err(); + assert!(matches!( + wrong_family, + crate::Error::UnsupportedVersion(crate::ArchiveVersion::Rar29) + )); + + let mut features = crate::FeatureSet::store_only(); + features.solid = true; + let solid_filter = super::Rar50Writer::new(super::WriterOptions::new( + crate::ArchiveVersion::Rar50, + features, + )) + .entry(entry()) + .filter_policy(super::FilterPolicy::explicit(super::FilterKind::E8)) + .finish() + .unwrap_err(); + assert!(matches!( + solid_filter, + crate::Error::UnsupportedWriterOption { + option: crate::WriterOption::Filter, + .. + } + )); + } + + fn simple_entry(data: &[u8]) -> super::ArchiveEntry { + super::ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_bytes(data.to_vec()), + ) + } + + #[test] + fn malformed_member_metadata_is_rejected_before_serialization() { + let mut file = simple_entry(b"payload"); + file.redirection_size = Some(0); + assert_eq!( + super::validate_entry(&file).unwrap_err(), + crate::Error::InvalidArgument("redirection size requires a redirection record") + ); + + let link = super::super::FileRedirection { + redirection_type: 4, + flags: 0, + target_name: b"target".to_vec(), + }; + file.redirection_size = None; + file.redirection = Some(link.clone()); + assert_eq!( + super::validate_entry(&file).unwrap_err(), + crate::Error::InvalidArgument( + "redirections require supported target metadata and empty contents" + ) + ); + file.redirection_size = Some(0); + assert_eq!( + super::validate_entry(&file).unwrap_err(), + crate::Error::InvalidArgument( + "redirections require supported target metadata and empty contents" + ) + ); + file.source = crate::EntrySource::from_bytes(Vec::new()); + file.host_os = 99; + assert_eq!( + super::validate_entry(&file).unwrap_err(), + crate::Error::InvalidArgument( + "redirections require supported target metadata and empty contents" + ) + ); + file.host_os = 0; + super::validate_entry(&file).unwrap(); + + let mut directory = simple_entry(b"payload").with_directory(true); + assert_eq!( + super::validate_entry(&directory).unwrap_err(), + crate::Error::InvalidArgument("directory entries cannot carry file contents") + ); + directory.source = crate::EntrySource::from_bytes(Vec::new()); + super::validate_entry(&directory).unwrap(); + + let mut timestamped = simple_entry(b""); + timestamped.mtime_nanoseconds = Some(1); + assert!(super::validate_entry(×tamped).is_err()); + timestamped.mtime = Some(0); + timestamped.mtime_nanoseconds = Some(1_000_000_000); + assert!(super::validate_entry(×tamped).is_err()); + timestamped.mtime_nanoseconds = None; + timestamped.file_times = + Some(crate::FileTimes::from_unix_nanoseconds(Some(0), None, None).unwrap()); + assert_eq!( + super::validate_entry(×tamped).unwrap_err(), + crate::Error::InvalidArgument("conflicting file modification timestamps") + ); + timestamped.mtime = None; + timestamped.mtime_nanoseconds = Some(1); + assert_eq!( + super::validate_entry(×tamped).unwrap_err(), + crate::Error::InvalidArgument("conflicting file modification timestamps") + ); + } + + #[test] + fn unsupported_or_empty_member_services_are_rejected() { + for service in [ + super::ServiceEntry::new(b"BAD", b"data"), + super::ServiceEntry::new(b"ACL", b""), + super::ServiceEntry::new(b"CMT", b"data").with_password(b""), + ] { + assert!(super::validate_entry(&simple_entry(b"").with_service(service)).is_err()); + } + super::validate_entry( + &simple_entry(b"").with_service(super::ServiceEntry::new(b"CMT", b"")), + ) + .unwrap(); + } + + #[test] + fn volume_preflight_rejects_unsupported_member_and_archive_shapes() { + fn reject( + entries: &[super::ArchiveEntry], + options: super::WriterOptions, + extras: super::ArchiveExtras<'_>, + ) -> crate::Error { + let mut sink = super::CollectedVolumes::new(); + let error = super::write_streaming_volumes_to( + entries, + options, + extras, + 4096, + &mut sink, + &crate::WriterResources::default(), + ) + .unwrap_err(); + assert!(sink.take().is_empty()); + error + } + + let plain = simple_entry(b"payload"); + let encrypted = simple_entry(b"payload").with_password(b"secret"); + assert_eq!( + reject( + &[encrypted, plain.clone()], + super::WriterOptions::default(), + super::ArchiveExtras::default(), + ) + .kind(), + crate::ErrorKind::UnsupportedFeature + ); + + let locked = super::ArchiveExtras { + locked: true, + ..Default::default() + }; + assert_eq!( + reject( + std::slice::from_ref(&plain), + super::WriterOptions::default(), + locked + ), + crate::Error::InvalidArgument("archive lock flag is not supported in volume output") + ); + + let metadata = super::ArchiveExtras::default().with_metadata(super::ArchiveMetadataEntry { + name: None, + creation_time: Some(1), + }); + assert_eq!( + reject( + std::slice::from_ref(&plain), + super::WriterOptions::default(), + metadata + ) + .kind(), + crate::ErrorKind::UnsupportedFeature + ); + + let link = simple_entry(b"").with_redirection(Some(super::super::FileRedirection { + redirection_type: 4, + flags: 0, + target_name: b"target".to_vec(), + })); + assert_eq!( + reject( + &[link], + super::WriterOptions::default(), + super::ArchiveExtras::default() + ), + crate::Error::InvalidArgument("symbolic links are not supported in volume output") + ); + + let commented = + simple_entry(b"").with_service(super::ServiceEntry::new(b"CMT", b"file comment")); + assert_eq!( + reject( + &[commented], + super::WriterOptions::default(), + super::ArchiveExtras::default(), + ) + .kind(), + crate::ErrorKind::UnsupportedFeature + ); + + let mut features = crate::FeatureSet::store_only(); + features.header_encryption = true; + assert_eq!( + reject( + &[plain], + super::WriterOptions::new(crate::ArchiveVersion::Rar50, features), + super::ArchiveExtras::default(), + ), + if cfg!(feature = "encryption") { + crate::Error::NeedPassword + } else { + crate::Error::FeatureDisabled { + feature: "encryption", + } + } + ); + } + + #[test] + fn archive_preflight_rejects_duplicate_metadata_before_emission() { + let record = super::super::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: Some(1), + }; + let mut extras = + super::ArchiveExtras::default().with_metadata(super::ArchiveMetadataEntry { + name: None, + creation_time: Some(1), + }); + extras.metadata_record = Some(&record); + let mut output = Vec::new(); + let error = super::write_streaming_archive_to( + &[simple_entry(b"payload")], + super::WriterOptions::default(), + extras, + &crate::WriterResources::default(), + &mut output, + ) + .unwrap_err(); + assert_eq!( + error, + crate::Error::InvalidArgument("duplicate archive metadata settings") + ); + assert!(output.is_empty()); + } + + #[test] + fn volume_preflight_rejects_retained_metadata_before_opening_source_or_sink() { + let entry = super::ArchiveEntry::new( + b"file".to_vec(), + crate::EntrySource::from_opener(1, || panic!("metadata refusal opened source")), + ); + let record = super::super::ArchiveMetadataRecord { + flags: 2, + name: None, + creation_time: Some(1), + }; + let extras = super::ArchiveExtras { + metadata_record: Some(&record), + ..Default::default() + }; + let mut sink = super::CollectedVolumes::new(); + let error = super::write_streaming_volumes_to( + &[entry], + super::WriterOptions::default(), + extras, + 64, + &mut sink, + &crate::WriterResources::default(), + ) + .unwrap_err(); + assert!(matches!( + error, + crate::Error::UnsupportedWriterOption { + option: crate::WriterOption::ArchiveMetadata, + .. + } + )); + assert!(sink.take().is_empty()); + } + + #[test] + #[cfg(feature = "encryption")] + fn volume_header_password_can_encrypt_headers_without_encrypting_member_data() { + let mut features = crate::FeatureSet::store_only(); + features.header_encryption = true; + let extras = super::ArchiveExtras { + header_password: Some(b"password"), + ..Default::default() + }; + let mut sink = super::CollectedVolumes::new(); + super::write_streaming_volumes_to( + &[simple_entry(b"payload")], + super::WriterOptions::new(crate::ArchiveVersion::Rar50, features), + extras, + 64, + &mut sink, + &crate::WriterResources::default(), + ) + .unwrap(); + let parts = sink.take(); + assert!(!parts.is_empty()); + for part in parts { + assert!(matches!( + super::super::Archive::parse(&part), + Err(crate::Error::NeedPassword) + )); + let archive = + super::super::Archive::parse_with_password(&part, Some(b"password")).unwrap(); + assert!(archive.main.encrypted_headers); + assert!(archive.files().all(|file| !file.encrypted)); + } + } + + #[test] + #[cfg(feature = "encryption")] + fn header_encryption_rejects_conflicting_member_password_before_output() { + let mut features = crate::FeatureSet::store_only(); + features.header_encryption = true; + let options = super::WriterOptions::new(crate::ArchiveVersion::Rar50, features); + let extras = super::ArchiveExtras { + header_password: Some(b"header password"), + ..Default::default() + }; + let mut entry = simple_entry(b"payload"); + entry.password = Some(b"member password".to_vec()); + + let mut archive = Vec::new(); + let error = super::write_streaming_archive_to( + &[entry.clone()], + options, + extras.clone(), + &crate::WriterResources::default(), + &mut archive, + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument); + assert!(archive.is_empty()); + + let mut volumes = super::CollectedVolumes::new(); + let error = super::write_streaming_volumes_to( + &[entry], + options, + extras, + 64, + &mut volumes, + &crate::WriterResources::default(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument); + assert!(volumes.take().is_empty()); + } + + #[test] + #[cfg(feature = "encryption")] + fn quick_open_with_encrypted_headers_is_rejected_by_plan_validation() { + let mut features = crate::FeatureSet::store_only(); + features.quick_open = true; + features.header_encryption = true; + let options = super::WriterOptions::new(crate::ArchiveVersion::Rar50, features); + let error = super::validate_plan( + options, + crate::write_plan::PlanShape::new().compressed(true), + ) + .unwrap_err(); + assert!(matches!( + error, + crate::Error::UnsupportedWriterOption { + option: crate::write_plan::WriterOption::Feature(crate::Feature::QuickOpen), + .. + } + )); + } + + #[test] + fn empty_volume_set_is_rejected_before_opening_a_sink() { + let mut sink = super::CollectedVolumes::new(); + let error = super::write_streaming_volumes_to( + &[], + super::WriterOptions::default(), + super::ArchiveExtras::default(), + 4096, + &mut sink, + &crate::WriterResources::default(), + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument); + assert!(sink.take().is_empty()); + } + + #[test] + fn invalid_writer_inputs_and_internal_failures_have_distinct_categories() { + for error in [ + super::validate_file_entry(b"").unwrap_err(), + #[cfg(feature = "encryption")] + super::validate_nonempty_password(b"").unwrap_err(), + #[cfg(feature = "recovery")] + super::validate_recovery_percent(101).unwrap_err(), + super::filter_policy::dictionary_size_fields(0, 0).unwrap_err(), + super::filter_policy::dictionary_size_fields(1, 131073).unwrap_err(), + super::headers::header_encryption_password([&b"one"[..], &b"two"[..]].into_iter()) + .unwrap_err(), + ] { + assert_eq!(error.kind(), crate::ErrorKind::InvalidArgument, "{error}"); + } + #[cfg(not(feature = "encryption"))] + assert_eq!( + super::validate_nonempty_password(b"").unwrap_err(), + Error::FeatureDisabled { + feature: "encryption" + } + ); + #[cfg(not(feature = "recovery"))] + assert_eq!( + super::validate_recovery_percent(101).unwrap_err(), + Error::FeatureDisabled { + feature: "recovery" + } + ); + let mut volumes = super::CollectedVolumes::default(); + let error = super::VolumeSink::start_volume(&mut volumes, 1) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::WriterFailure); + assert_eq!(error.kind().code(), "WRITE_FAILED"); + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_allowance_admits_before_reading_and_preserves_cbc_tails() { + use crate::codec::workspace::Allowance; + let keys = Rar50Keys::derive(b"test password", [7; 16], 0).unwrap(); + for len in [0usize, 1, 15, 16, 17, 31, 32, 95, 128, 129] { + let input: Vec = (0..len).map(|n| n as u8).collect(); + let mut expected = input.clone(); + expected.resize(len.next_multiple_of(16), 0); + Rar50Cipher::new(keys.key, [9; 16]) + .encrypt_in_place(&mut expected) + .unwrap(); + for limit in [0, 31, 32] { + let allowance = Allowance::limited(limit); + let mut reader = std::io::Cursor::new(&input); + let mut output = Vec::new(); + let result = encrypt_reader_with_allowance( + &mut reader, + len as u64, + &mut output, + &keys, + [9; 16], + 32, + None, + &allowance, + ); + if len == 0 || limit == 32 { + result.unwrap(); + assert_eq!(output, expected); + assert_eq!(reader.position(), len as u64); + } else { + assert_eq!(result.unwrap_err().kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(reader.position(), 0); + assert!(output.is_empty()); + } + assert_eq!(allowance.used(), 0); + } + } + } + + #[test] + #[cfg(feature = "encryption")] + fn encryption_allowance_releases_buffers_on_io_failure_and_cancellation() { + use crate::codec::workspace::Allowance; + use std::sync::atomic::{AtomicBool, Ordering}; + struct Progress(AtomicBool); + impl crate::WriteProgress for Progress { + fn report(&self, _: crate::WriteProgressEvent<'_>) {} + fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) + } + } + struct Sink<'a>(&'a Progress, bool, Vec); + impl Write for Sink<'_> { + fn write(&mut self, data: &[u8]) -> std::io::Result { + if self.1 { + return Err(std::io::ErrorKind::BrokenPipe.into()); + } + self.2.extend_from_slice(data); + self.0 .0.store(true, Ordering::Relaxed); + Ok(data.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let keys = Rar50Keys::derive(b"test password", [7; 16], 0).unwrap(); + let allowance = Allowance::limited(32); + for fail_sink in [false, true] { + let progress = Progress(AtomicBool::new(false)); + let mut sink = Sink(&progress, fail_sink, Vec::new()); + let mut reader = std::io::Cursor::new([42u8; 96]); + let error = encrypt_reader_with_allowance( + &mut reader, + 96, + &mut sink, + &keys, + [9; 16], + 32, + Some(ProgressReporter(&progress)), + &allowance, + ) + .unwrap_err(); + if fail_sink { + assert!(matches!(error, Error::Io(_))); + } else { + assert!(matches!(error, Error::Cancelled)); + assert_eq!(sink.2.len(), 32); + } + assert_eq!(reader.position(), 32); + assert_eq!(allowance.used(), 0); + } + let result = encrypt_reader_with_allowance( + &mut std::io::Cursor::new([42u8; 7]), + 96, + &mut Vec::new(), + &keys, + [9; 16], + 32, + None, + &allowance, + ); + assert!(matches!(result, Err(Error::Io(_)))); + assert_eq!(allowance.used(), 0); + } + + use super::filter_policy::{ + encode_member_with_auto_size_filter_progress, encode_member_with_filter_policy_and_progress, + }; + use super::headers::{ + file_specific, write_block, write_end_header, write_hash_record_with_value, + write_main_header, + }; + use super::*; + use crate::codec::rar50::{encode_literal_only, encode_lz_member}; + use crate::codec::rar50::{encode_lz_member_with_options, EncodeOptions, Unpack50Encoder}; + use crate::filter_search::{ + auto_delta_filter_range, disjoint_filter_ranges, AUTO_DELTA_EDGE_SKIP, + }; + use crate::x86_filter_scan::auto_x86_filter_ranges; + use crate::{ArchiveVersion, FeatureSet}; + use crate::{WriteOperation, WriteProgressEvent}; + use std::cell::RefCell; + use std::fs; + use std::io::{Cursor, Result as IoResult, Write}; + use std::process::Command; + use std::rc::Rc; + use std::sync::atomic::{AtomicUsize, Ordering}; + + struct CollectWriter(Rc>>); + + #[test] + fn stored_writer_does_not_require_lz_workspace() { + let data = b"stored payload".repeat(1024); + let write = |limit| -> Result> { + let mut out = Vec::new(); + Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(0), + ) + .entries(vec![entry(b"payload", &data)]) + .write_to(&mut out, &WriterResources::new(limit))?; + Ok(out) + }; + let bytes = write(1024 * 1024).unwrap(); + assert_eq!(bytes, write(256 * 1024 * 1024).unwrap()); + let archive = crate::ArchiveReader::read_owned(bytes).unwrap(); + assert_eq!( + archive.read_member(b"payload", None).unwrap().unwrap(), + data + ); + } + + #[test] + fn the_writer_fits_the_dictionary_to_what_one_window_has_to_reach() { + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(3); + let fitted = |content: u64| { + dictionary_size_for_options(options, content, u64::MAX).expect("a legal dictionary") + }; + + // The smallest window that still reaches past the data, and never below + // the format's floor or above the cap the writer picks on its own. + assert_eq!(fitted(0), 128 * 1024); + assert_eq!(fitted(130_000), 128 * 1024); + assert_eq!(fitted(200_000), 256 * 1024); + assert_eq!(fitted(700_000), 1024 * 1024); + assert_eq!(fitted(64 * 1024 * 1024), 4 * 1024 * 1024); + + // What the caller asked for stands, in both directions. + assert_eq!( + dictionary_size_for_options(options.with_dictionary_size(4 * 1024 * 1024), 0, u64::MAX) + .unwrap(), + 4 * 1024 * 1024 + ); + } + + #[test] + fn the_cap_on_a_fitted_dictionary_climbs_with_the_level() { + let plenty = 64 * 1024 * 1024; + let capped = |level: u8| { + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(level); + dictionary_size_for_options(options, plenty, u64::MAX).expect("a legal dictionary") + }; + + assert_eq!(capped(1), 1024 * 1024); + assert_eq!(capped(2), 4 * 1024 * 1024); + assert_eq!(capped(3), 4 * 1024 * 1024); + assert_eq!(capped(4), 8 * 1024 * 1024); + assert_eq!(capped(5), 16 * 1024 * 1024); + + // An absent level is the default level, and picks the same window it + // would if the default had been spelled out. + let absent = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()); + assert_eq!( + dictionary_size_for_options(absent, plenty, u64::MAX).unwrap(), + capped(3), + ); + } + + #[test] + fn the_workspace_charge_covers_what_a_member_measured() { + let block = crate::codec::rar50::LZ_BLOCK_SIZE; + // Peak resident bytes over the member, one encode per row, taken with + // `/proc/self/status` VmHWM so the allocator could not be involved. + // Anything that raises what the encoder holds has to move these too. + let measured: [(u64, u64); 5] = [ + (256 * 1024, 6_197_248), + (1024 * 1024, 9_170_944), + (3 * 1024 * 1024, 20_152_320), + (4 * 1024 * 1024, 20_234_240), + (8 * 1024 * 1024, 36_941_824), + ]; + for (dictionary, peak) in measured { + let charged = streaming_lz_workspace(dictionary, block, false); + assert!( + charged >= peak, + "a {dictionary}-byte dictionary measured {peak} against a charge of {charged}", + ); + // Streaming runs also retain input/history buffers not present in + // these single-member measurements. + assert!( + charged < peak * 4, + "a {dictionary}-byte dictionary is charged {charged} for a measured {peak}", + ); + } + } + + /// The same measurement for a parse that searches a tree, which holds two + /// links per window position where a chain holds one. Charging the chain's + /// four bytes for it let a fitted dictionary pick a window the budget could + /// not hold: at a 32 MiB limit a 16 MiB member peaked at 43 MB. + #[test] + fn the_workspace_charge_covers_a_tree_search_too() { + let block = crate::codec::rar50::LZ_BLOCK_SIZE; + // Peak resident bytes over the member, 16 MiB of manpage text at + // level 5, which is the only level that parses optimally. + let measured: [(u64, u64); 4] = [ + (256 * 1024, 19_668_992), + (1024 * 1024, 21_794_816), + (4 * 1024 * 1024, 47_030_272), + (8 * 1024 * 1024, 75_390_976), + ]; + for (dictionary, peak) in measured { + let charged = streaming_lz_workspace(dictionary, block, true); + let chain = streaming_lz_workspace(dictionary, block, false); + assert!( + charged > chain, + "a tree is charged {charged} against a chain's {chain}", + ); + // The two smallest windows measure above their charge: what is over + // is the member copies the whole-member path holds, which + // `whole_member_workspace` charges for separately and which no + // window size changes. + let copies = 17 * 1024 * 1024; + assert!( + charged + copies >= peak, + "a {dictionary}-byte dictionary measured {peak} against a charge of {charged}", + ); + } + } + + #[test] + fn the_workspace_charge_never_falls_as_the_dictionary_grows() { + let block = crate::codec::rar50::LZ_BLOCK_SIZE; + let mut previous = 0; + let mut dictionary = 128 * 1024u64; + while dictionary <= 64 * 1024 * 1024 { + for optimal_parse in [false, true] { + let charged = streaming_lz_workspace(dictionary, block, optimal_parse); + assert!( + charged >= previous, + "{dictionary} charged less than the size below it" + ); + if !optimal_parse { + previous = charged; + } + } + // Every size the format allows, not just the powers of two, because + // the rounding inside is the whole reason this function exists. + dictionary += 128 * 1024; + } + } + + #[test] + fn a_fitted_dictionary_shrinks_to_the_workspace_budget() { + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(3); + // Derived exactly as the writer derives it, so the budget below is the + // one that admits a 256 KiB window and nothing larger. Spelling the + // parameters out here instead would make this test pass or fail on + // whether the ladder had moved since. + let block = crate::codec::rar50::MAX_LZ_BLOCK_SIZE; + let parse = encode_options_for_level(Some(3), DEFAULT_RAR50_DICTIONARY_SIZE) + .unwrap() + .optimal_parse; + let room_for_256k = streaming_lz_workspace(256 * 1024, block, parse); + + // A budget that cannot hold the fitted window takes the largest one it + // can, rather than failing a write the old 128 KiB default would have + // finished. + let fitted = dictionary_size_for_options(options, 8 * 1024 * 1024, room_for_256k).unwrap(); + + assert_eq!(fitted, 256 * 1024); + assert!(streaming_lz_workspace(fitted, block, parse) <= room_for_256k); + // A dictionary the caller named is used as asked, so the write fails + // later saying what it needed instead of quietly writing something else. + assert_eq!( + dictionary_size_for_options( + options.with_dictionary_size(4 * 1024 * 1024), + 8 * 1024 * 1024, + room_for_256k + ) + .unwrap(), + 4 * 1024 * 1024 + ); + } + + fn encode_member_with_filter_policy( + data: &[u8], + algorithm_version: u8, + policy: &FilterPolicy, + options: EncodeOptions, + ) -> Result> { + encode_member_with_filter_policy_and_progress( + data, + algorithm_version, + policy, + options, + None, + ) + } + + fn encode_member_with_auto_size_filter( + data: &[u8], + algorithm_version: u8, + options: EncodeOptions, + ) -> Result> { + encode_member_with_auto_size_filter_progress(data, algorithm_version, options, None) + } + + fn encode_member_with_filter_spec( + data: &[u8], + algorithm_version: u8, + filter: FilterSpec, + options: EncodeOptions, + ) -> crate::codec::Result> { + Unpack50Encoder::with_options(options).encode_member_with_filter( + data, + algorithm_version, + filter, + ) + } + + fn encode_member_with_filter_specs( + data: &[u8], + algorithm_version: u8, + filters: &[FilterSpec], + options: EncodeOptions, + ) -> crate::codec::Result> { + Unpack50Encoder::with_options(options).encode_member_with_filters( + data, + algorithm_version, + filters, + ) + } + + /// Builds a member from bytes the test already holds. + fn entry(name: &[u8], data: &[u8]) -> ArchiveEntry { + ArchiveEntry::new( + name.to_vec(), + EntrySource::from_bytes(std::sync::Arc::<[u8]>::from(data.to_vec())), + ) + } + + #[test] + fn compressed_writer_reports_determinate_progress() { + let data: Vec = (0usize..128 * 1024) + .map(|i| (i.wrapping_mul(37) % 251) as u8) + .collect(); + let entry = entry(b"payload.bin", &data) + .with_attributes(0x20) + .with_host_os(1); + let last = std::sync::atomic::AtomicU64::new(0); + let advances = AtomicUsize::new(0); + let intermediate = std::sync::atomic::AtomicBool::new(false); + let reporter = |event: WriteProgressEvent<'_>| { + if let WriteProgressEvent::Advanced { + operation: WriteOperation::Compression, + completed_bytes, + total_bytes, + .. + } = event + { + assert!(completed_bytes >= last.swap(completed_bytes, Ordering::Relaxed)); + assert!(completed_bytes <= total_bytes); + if completed_bytes < total_bytes { + intermediate.store(true, Ordering::Relaxed); + } + advances.fetch_add(1, Ordering::Relaxed); + } + }; + + Rar50Writer::new(WriterOptions::new( + ArchiveVersion::Rar70, + FeatureSet::default(), + )) + .entries([entry].to_vec()) + .filter_policy(FilterPolicy::Auto) + .progress(&reporter) + .finish() + .unwrap(); + + assert!(advances.load(Ordering::Relaxed) >= 1); + assert!(intermediate.load(Ordering::Relaxed)); + // Progress is now counted in input bytes, however many passes the + // filter search makes over them. + assert_eq!(last.load(Ordering::Relaxed), data.len() as u64); + } + + #[test] + #[cfg(feature = "recovery")] + fn recovery_writer_reports_determinate_pass_progress() { + let entry = entry(b"payload.bin", b"recovery progress payload") + .with_attributes(0x20) + .with_host_os(1); + let starts = AtomicUsize::new(0); + let advances = AtomicUsize::new(0); + let finishes = AtomicUsize::new(0); + let reporter = |event: WriteProgressEvent<'_>| match event { + WriteProgressEvent::OperationStarted { + operation: WriteOperation::Recovery, + total_bytes: Some(total), + .. + } => { + assert!(total > 0); + starts.fetch_add(1, Ordering::Relaxed); + } + WriteProgressEvent::Advanced { + operation: WriteOperation::Recovery, + completed_bytes, + total_bytes, + .. + } => { + assert!(completed_bytes <= total_bytes); + advances.fetch_add(1, Ordering::Relaxed); + } + WriteProgressEvent::OperationFinished { + operation: WriteOperation::Recovery, + .. + } => { + finishes.fetch_add(1, Ordering::Relaxed); + } + _ => {} + }; + let features = FeatureSet::store_only(); + + Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, features).with_compression_level(0), + ) + .entries([entry].to_vec()) + .recovery_percent(Some(10)) + .progress(&reporter) + .finish() + .unwrap(); + + assert!(starts.load(Ordering::Relaxed) >= 1); + assert!(advances.load(Ordering::Relaxed) >= 1); + assert_eq!( + starts.load(Ordering::Relaxed), + finishes.load(Ordering::Relaxed) + ); + } + + impl Write for CollectWriter { + fn write(&mut self, buf: &[u8]) -> IoResult { + self.0.borrow_mut().extend_from_slice(buf); + Ok(buf.len()) + } + + fn flush(&mut self) -> IoResult<()> { + Ok(()) + } + } + + #[derive(Debug, Clone, PartialEq, Eq)] + // Historical numeric snapshots; timestamp presence has dedicated regression tests. + struct CollectedEntry { + name: Vec, + data: Vec, + file_time: u32, + attr: u64, + host_os: u64, + is_directory: bool, + } + + fn collect_extract(archive: &Archive) -> Result> { + let entries = RefCell::new(Vec::new()); + archive.extract_to(crate::ArchiveReadOptions::default(), |meta| { + let data = Rc::new(RefCell::new(Vec::new())); + entries.borrow_mut().push((meta.clone(), Rc::clone(&data))); + Ok(Box::new(CollectWriter(data))) + })?; + Ok(entries + .into_inner() + .into_iter() + .map(|(meta, data)| CollectedEntry { + name: meta.name, + data: data.borrow().clone(), + file_time: meta.file_time.unwrap_or(0), + attr: meta.attr, + host_os: meta.host_os, + is_directory: meta.is_directory, + }) + .collect()) + } + + #[test] + fn streaming_writer_round_trips_across_input_blocks() { + let data = b"bounded streaming member data\n".repeat(80_000); + let entry = ArchiveEntry::new( + b"large.txt".to_vec(), + EntrySource::from_bytes(Arc::<[u8]>::from(data.clone())), + ) + .with_mtime(None) + .with_attributes(0x20) + .with_host_os(1); + let mut bytes = Vec::new(); + write_streaming_archive_to( + &[entry], + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()), + ArchiveExtras::default(), + &WriterResources::default(), + &mut bytes, + ) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let extracted = collect_extract(&archive).unwrap(); + assert_eq!(extracted.len(), 1); + assert_eq!(extracted[0].name, b"large.txt"); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn streaming_writer_rejects_workspace_larger_than_budget() { + let entry = ArchiveEntry::new( + b"small.txt".to_vec(), + EntrySource::from_bytes(Arc::<[u8]>::from(&b"small"[..])), + ) + .with_mtime(None) + .with_attributes(0x20) + .with_host_os(1); + let result = write_streaming_archive_to( + &[entry], + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()), + ArchiveExtras::default(), + &WriterResources::new(1024), + &mut Vec::new(), + ); + assert!(matches!(result, Err(Error::MemoryLimitExceeded { .. }))); + } + + #[test] + fn streaming_writer_propagates_partial_output_failure_and_cleans_spools() { + struct FailingOutput { + remaining: usize, + written: usize, + } + impl Write for FailingOutput { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + if self.remaining == 0 { + return Err(std::io::ErrorKind::BrokenPipe.into()); + } + let count = bytes.len().min(self.remaining); + self.remaining -= count; + self.written += count; + Ok(count) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let scratch = crate::scratch::case("rar50-partial-output-failure"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let data = vec![42u8; 8192]; + let entry = ArchiveEntry::new(b"file".to_vec(), EntrySource::from_bytes(data)); + let mut output = FailingOutput { + remaining: 1024, + written: 0, + }; + let error = write_streaming_archive_to( + &[entry], + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(0), + ArchiveExtras::default(), + &resources, + &mut output, + ) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!(output.written, 1024); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[test] + fn parallel_streaming_blocks_are_byte_identical_to_serial_blocks() { + let mut data = Vec::new(); + for index in 0..52_000u32 { + data.extend_from_slice(b"parallel block identity payload "); + data.extend_from_slice(&index.to_le_bytes()); + } + // A stretch that does not move, so the two loops have to agree about + // growing a block and not only about cutting one every block_size. + data.extend(std::iter::repeat_n(0u8, 3 * 1024 * 1024)); + data.extend((0..400_000u32).map(|index| (index as u8).wrapping_mul(37))); + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()); + let dictionary_size = + dictionary_size_for_options(options, data.len() as u64, u64::MAX).unwrap(); + let algorithm_version = rar50_algorithm_version(options, dictionary_size).unwrap(); + let encode_options = + encode_options_for_level(options.compression_level, dictionary_size).unwrap(); + let block_size = crate::codec::rar50::LZ_BLOCK_SIZE; + let mut serial = Vec::new(); + crate::codec::rar50::encode_lz_reader_to( + &mut Cursor::new(&data), + data.len() as u64, + &mut serial, + algorithm_version, + encode_options, + block_size, + None, + ) + .unwrap(); + + let source = EntrySource::from_bytes(Arc::<[u8]>::from(data)); + let required = streaming_lz_workspace( + dictionary_size, + crate::codec::rar50::MAX_LZ_BLOCK_SIZE, + encode_options.optimal_parse, + ); + let mut prepared = compress::compress_members_reporting( + &[source], + compress::CompressPlan { + algorithm_version, + encode_options, + dictionary_size, + block_size, + solid: false, + method: 1, + filter_policy: FilterPolicy::None, + candidates: vec![encode_options].into(), + }, + &WriterResources::new(required.saturating_mul(4)), + &|_| true, + ) + .unwrap(); + let mut parallel = Vec::new(); + prepared[0].packed.copy_to(&mut parallel).unwrap(); + assert_eq!(parallel, serial); + } + + #[test] + fn streaming_entry_order_is_identical_at_one_and_many_job_budgets() { + let entries: Vec<_> = (0..4u8) + .map(|index| { + let mut data = vec![index; 1_300_000]; + data.extend((0..300_000).map(|offset| (offset as u8).wrapping_add(index))); + ArchiveEntry::new( + format!("entry-{index}.bin").into_bytes(), + EntrySource::from_bytes(Arc::<[u8]>::from(data)), + ) + .with_mtime(None) + .with_attributes(0x20) + .with_host_os(1) + }) + .collect(); + let options = WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()); + let dictionary_size = + dictionary_size_for_options(options, dictionary_reach(&entries, false), u64::MAX) + .unwrap(); + // Exactly what the writer charges itself, so the budget below admits one + // job and no more. Derived rather than written down, because a charge + // larger than the writer's would quietly make this a two-job test. + let required = streaming_lz_workspace( + dictionary_size, + 1024 * 1024, + encode_options_for_level(options.compression_level, dictionary_size) + .unwrap() + .optimal_parse, + ); + let mut one_job = Vec::new(); + write_streaming_archive_to( + &entries, + options, + ArchiveExtras::default(), + &WriterResources::new(required), + &mut one_job, + ) + .unwrap(); + let mut many_jobs = Vec::new(); + write_streaming_archive_to( + &entries, + options, + ArchiveExtras::default(), + &WriterResources::new(required.saturating_mul(4)), + &mut many_jobs, + ) + .unwrap(); + assert_eq!(many_jobs, one_job); + } + + #[test] + fn streaming_writer_rejects_a_source_larger_than_its_declared_size() { + let source = EntrySource::from_opener(4, || Ok(Box::new(Cursor::new(b"data!".to_vec())))); + let entry = ArchiveEntry::new(b"changing.bin".to_vec(), source) + .with_attributes(0x20) + .with_host_os(1); + let result = write_streaming_archive_to( + &[entry], + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()), + ArchiveExtras::default(), + &WriterResources::default(), + &mut Vec::new(), + ); + let error = result.unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::SourceChanged); + assert_eq!( + error.entry_context(), + Some((b"changing.bin".as_slice(), "compressing")) + ); + } + + #[test] + #[cfg(feature = "encryption")] + fn encrypted_streaming_writer_round_trips_across_input_blocks() { + let data = b"encrypted bounded streaming member data\n".repeat(40_000); + let entry = ArchiveEntry::new( + b"secret.txt".to_vec(), + EntrySource::from_bytes(Arc::<[u8]>::from(data.clone())), + ) + .with_mtime(None) + .with_attributes(0x20) + .with_host_os(1) + .with_password(b"password".to_vec()); + let features = FeatureSet::store_only(); + let mut bytes = Vec::new(); + write_streaming_archive_to( + &[entry], + WriterOptions::new(ArchiveVersion::Rar50, features), + ArchiveExtras::default(), + &WriterResources::default(), + &mut bytes, + ) + .unwrap(); + let archive = Archive::parse(&bytes).unwrap(); + let entries = RefCell::new(Vec::new()); + archive + .extract_to( + crate::ArchiveReadOptions::with_password(b"password"), + |meta| { + let output = Rc::new(RefCell::new(Vec::new())); + entries + .borrow_mut() + .push((meta.name.clone(), Rc::clone(&output))); + Ok(Box::new(CollectWriter(output))) + }, + ) + .unwrap(); + let entries = entries.into_inner(); + assert_eq!(entries.len(), 1); + assert_eq!(entries[0].0, b"secret.txt"); + assert_eq!(*entries[0].1.borrow(), data); + } + + #[test] + fn internal_literal_only_compressed_member_round_trips_through_rar50_reader() { + let data = b"RAR5 literal-only compressed format-layer experiment\n"; + let packed = encode_literal_only(data, 0).unwrap(); + let name = b"compressed.txt"; + + let mut archive = Vec::new(); + archive.extend_from_slice(RAR50_SIGNATURE); + write_main_header( + &mut archive, + 0, + None, + &[], + &crate::WriterResources::default(), + ) + .unwrap(); + + let mut extra = Vec::new(); + write_hash_record_with_value(&mut extra, blake2sp::hash(data)).unwrap(); + let compression_info = 1 << 7; // RAR5 v0, non-solid, method m1, 128 KiB dictionary. + let specific = file_specific( + name, + data.len() as u64, + crc32(data), + 0x20, + None, + compression_info, + 0, + false, + &crate::WriterResources::default(), + ) + .unwrap(); + write_block( + &mut archive, + HEAD_FILE, + HFL_EXTRA | HFL_DATA, + Some(packed.len() as u64), + &specific, + &extra, + &packed, + &crate::WriterResources::default(), + ) + .unwrap(); + write_end_header(&mut archive, 0, &crate::WriterResources::default()).unwrap(); + + let parsed = Archive::parse(&archive).unwrap(); + let file = parsed.files().next().unwrap(); + let info = file.decoded_compression_info().unwrap(); + assert_eq!(info.method, 1); + assert_eq!(info.dictionary_size, 128 * 1024); + + let extracted = collect_extract(&parsed).unwrap(); + assert_eq!(extracted[0].name, name); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn writer_stamps_requested_rar50_dictionary_size() { + let data = b"RAR5 dictionary-size writer option fixture".repeat(64); + let options = + WriterOptions::new(crate::ArchiveVersion::Rar50, crate::FeatureSet::default()) + .with_dictionary_size(512 * 1024); + let entries = [entry(b"dict.bin", &data) + .with_attributes(0x20) + .with_host_os(3)]; + let archive = Rar50Writer::new(options) + .entries(entries.to_vec()) + .finish() + .unwrap(); + + let parsed = Archive::parse(&archive).unwrap(); + let info = parsed + .files() + .next() + .unwrap() + .decoded_compression_info() + .unwrap(); + let extracted = collect_extract(&parsed).unwrap(); + + assert_eq!(info.algorithm_version, 0); + assert_eq!(info.dictionary_size, 512 * 1024); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn writer_uses_rar7_dictionary_fields_when_size_needs_v1_encoding() { + let data = b"RAR7 dictionary-size writer option fixture".repeat(64); + let options = + WriterOptions::new(crate::ArchiveVersion::Rar70, crate::FeatureSet::default()) + .with_dictionary_size(192 * 1024); + let entries = [entry(b"dict7.bin", &data) + .with_attributes(0x20) + .with_host_os(3)]; + let archive = Rar50Writer::new(options) + .entries(entries.to_vec()) + .finish() + .unwrap(); + + let parsed = Archive::parse(&archive).unwrap(); + let info = parsed + .files() + .next() + .unwrap() + .decoded_compression_info() + .unwrap(); + let extracted = collect_extract(&parsed).unwrap(); + + assert_eq!(info.algorithm_version, 1); + assert_eq!(info.dictionary_size, 192 * 1024); + assert_eq!(extracted[0].data, data); + } + + #[test] + fn writer_rejects_unencodable_rar50_dictionary_size() { + let options = + WriterOptions::new(crate::ArchiveVersion::Rar50, crate::FeatureSet::default()) + .with_dictionary_size(192 * 1024); + let entries = [entry(b"bad.bin", b"data data data data") + .with_attributes(0x20) + .with_host_os(3)]; + + assert!(matches!( + Rar50Writer::new(options).entries(entries.to_vec()).finish(), + Err(Error::InvalidArgument( + "RAR 5 v0 dictionary size must be a power-of-two multiple of 128 KiB" + )) + )); + } + + #[test] + fn only_the_bottom_of_the_ladder_settles_for_a_greedy_parse() { + // Level 1 is the rung that exists to be quick. Everything above it + // parses by shortest path, because on this corpus nothing else closes + // the distance to WinRAR at any rung: the parse is worth several + // percent and the search depth around it is worth tenths. + for level in 0..=1u8 { + let options = + encode_options_for_level(Some(level), DEFAULT_RAR50_DICTIONARY_SIZE).unwrap(); + assert!(!options.optimal_parse, "level {level} priced every path"); + } + for level in 2..=5u8 { + let options = + encode_options_for_level(Some(level), DEFAULT_RAR50_DICTIONARY_SIZE).unwrap(); + assert!(options.optimal_parse, "level {level} settled for greedy"); + } + assert!( + encode_options_for_level(None, DEFAULT_RAR50_DICTIONARY_SIZE) + .unwrap() + .optimal_parse, + "an absent level is the default level, which parses by shortest path", + ); + } + + #[test] + fn every_level_encodes_the_member_once() { + // Level 5 used to try levels four down to one as well and keep the + // smallest. Over the whole bench corpus that caught one byte, on one + // member, for four extra whole-member encodes. + for level in 0..=5u8 { + let candidates = + encode_option_candidates_for_level(Some(level), DEFAULT_RAR50_DICTIONARY_SIZE) + .unwrap(); + assert_eq!(candidates.len(), 1, "level {level} encodes more than once"); + } + } + + #[test] + fn a_filter_screen_does_not_pay_for_the_optimal_parse() { + use crate::filter_search::FilterSearch; + + let search = crate::rar50::write::filter_policy::Rar50Search { + algorithm_version: 0, + }; + let five = encode_options_for_level(Some(5), DEFAULT_RAR50_DICTIONARY_SIZE).unwrap(); + let screen = search.screen_options(five); + + assert!(!screen.optimal_parse); + assert_eq!(screen.max_match_candidates, five.max_match_candidates); + assert_eq!(screen.max_match_distance, five.max_match_distance); + } + + #[test] + fn the_ladder_never_packs_larger_as_it_climbs() { + // A rung that costs more time and returns more bytes is a bug, and it + // was one: level 4 used to return level 3's output for half again the + // time, because the shortest-path parse only started at level 5. + let long_tail = b"stable long match payload for RAR5 best-level search ".repeat(10); + let mut data = Vec::new(); + data.extend_from_slice(b"abc"); + data.extend_from_slice(&long_tail); + for index in 0..320usize { + data.extend_from_slice(b"abc"); + data.push((index as u8).wrapping_mul(37)); + data.extend_from_slice(b" near same-hash decoy "); + data.extend_from_slice(&(index as u32).to_le_bytes()); + } + data.extend_from_slice(b"abc"); + data.extend_from_slice(&long_tail); + + let mut previous: Option<(u8, usize)> = None; + for level in 1..=5u8 { + let options = + encode_options_for_level(Some(level), DEFAULT_RAR50_DICTIONARY_SIZE).unwrap(); + let packed = + encode_member_with_filter_policy(&data, 0, &FilterPolicy::None, options).unwrap(); + + if let Some((lower, size)) = previous { + assert!( + packed.len() <= size, + "level {level} packed larger than level {lower}: {} against {size}", + packed.len(), + ); + } + previous = Some((level, packed.len())); + + let mut decoder = crate::codec::rar50::Unpack50Decoder::new(); + let output = decoder + .decode_member( + &packed, + 0, + data.len(), + false, + crate::codec::rar50::DecodeMode::Lz, + ) + .unwrap(); + assert_eq!(output, data, "level {level} did not round trip"); + } + } + + #[test] + fn auto_x86_filter_ranges_select_dense_opcode_clusters() { + let mut data = vec![0u8; 100_000]; + data[1_000] = 0xe8; + data[7_000] = 0xe9; + for pos in [50_000, 50_064, 50_128, 50_192] { + data[pos] = 0xe8; + } + for pos in [70_000, 70_064, 70_128, 70_192] { + data[pos] = 0xe9; + } + + let e8_ranges = auto_x86_filter_ranges(&data, false); + assert!(e8_ranges + .iter() + .any(|range| range.start <= 50_000 && range.end >= 50_197)); + assert!(!e8_ranges + .iter() + .any(|range| range.start <= 1_000 && range.end >= 1_005)); + + let e8e9_ranges = auto_x86_filter_ranges(&data, true); + assert!(e8e9_ranges + .iter() + .any(|range| range.start <= 70_000 && range.end >= 70_197)); + } + + #[test] + fn auto_x86_filter_policy_can_emit_multiple_disjoint_ranges() { + let mut data = vec![0x41u8; 80_000]; + for cluster_start in [8_000, 60_000] { + for index in 0..8 { + let pos = cluster_start + index * 64; + data[pos] = 0xe8; + data[pos + 1..pos + 5].copy_from_slice(&(0x2000u32 + index as u32).to_le_bytes()); + } + } + let ranges = disjoint_filter_ranges(auto_x86_filter_ranges(&data, false)); + let filters: Vec<_> = ranges + .into_iter() + .map(|range| FilterSpec::range(FilterKind::E8, range)) + .collect(); + + let packed = + encode_member_with_filter_specs(&data, 0, &filters, EncodeOptions::default()).unwrap(); + let mut decoder = crate::codec::rar50::Unpack50Decoder::new(); + let output = decoder + .decode_member( + &packed, + 0, + data.len(), + false, + crate::codec::rar50::DecodeMode::Lz, + ) + .unwrap(); + + assert_eq!(filters.len(), 2); + assert_eq!(output, data); + } + + #[test] + fn auto_filter_policy_considers_ranged_delta_candidates() { + let mut data = vec![0x55u8; AUTO_DELTA_EDGE_SKIP]; + for sample in 0..256u16 { + let left = sample as u8; + let right = left.wrapping_add(1); + data.extend_from_slice(&[left, right]); + } + data.extend(std::iter::repeat_n(0xaa, AUTO_DELTA_EDGE_SKIP)); + let options = EncodeOptions::default(); + + let plain = encode_lz_member_with_options(&data, 0, options).unwrap(); + let ranged = encode_member_with_filter_spec( + &data, + 0, + FilterSpec::range( + FilterKind::Delta { channels: 2 }, + auto_delta_filter_range(&data, 2).unwrap(), + ), + options, + ) + .unwrap(); + let auto = encode_member_with_auto_size_filter(&data, 0, options).unwrap(); + + assert!(ranged.len() < plain.len()); + assert!(auto.len() <= ranged.len()); + let mut decoder = crate::codec::rar50::Unpack50Decoder::new(); + let output = decoder + .decode_member( + &auto, + 0, + data.len(), + false, + crate::codec::rar50::DecodeMode::Lz, + ) + .unwrap(); + assert_eq!(output, data); + } + + #[test] + fn explicit_filters_accept_large_members_after_filter_ranges_are_split() { + let data = vec![0u8; 4 * 1024 * 1024 + 1]; + let packed = encode_member_with_filter_policy( + &data, + 0, + &FilterPolicy::explicit(FilterKind::Delta { channels: 1 }), + EncodeOptions::new(0), + ) + .unwrap(); + let mut decoder = crate::codec::rar50::Unpack50Decoder::new(); + + assert_eq!( + decoder + .decode_member( + &packed, + 0, + data.len(), + false, + crate::codec::rar50::DecodeMode::Lz + ) + .unwrap(), + data + ); + } + + #[test] + #[ignore = "requires local rar command; used for reference-validating experimental RAR5 compressed output"] + fn reference_rar_accepts_internal_literal_only_compressed_member() { + let data = b"RAR5 literal-only compressed reference experiment\n"; + let packed = encode_literal_only(data, 0).unwrap(); + let name = b"compressed.txt"; + + let mut archive = Vec::new(); + archive.extend_from_slice(RAR50_SIGNATURE); + write_main_header( + &mut archive, + 0, + None, + &[], + &crate::WriterResources::default(), + ) + .unwrap(); + + let mut extra = Vec::new(); + write_hash_record_with_value(&mut extra, blake2sp::hash(data)).unwrap(); + let specific = file_specific( + name, + data.len() as u64, + crc32(data), + 0x20, + None, + 1 << 7, + 0, + false, + &crate::WriterResources::default(), + ) + .unwrap(); + write_block( + &mut archive, + HEAD_FILE, + HFL_EXTRA | HFL_DATA, + Some(packed.len() as u64), + &specific, + &extra, + &packed, + &crate::WriterResources::default(), + ) + .unwrap(); + write_end_header(&mut archive, 0, &crate::WriterResources::default()).unwrap(); + + let dir = crate::scratch::case("rars-rar50-literal-only"); + let path = dir.join("archive.rar"); + fs::write(&path, archive).unwrap(); + let output = match Command::new("rar").arg("t").arg(&path).output() { + Ok(output) => output, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + eprintln!("skipping reference test: local `rar` command is not installed"); + return; + } + Err(error) => panic!("failed to run rar: {error}"), + }; + if std::env::var_os("RARS_KEEP_REFERENCE_ARCHIVE").is_some() { + eprintln!("kept reference archive: {}", path.display()); + std::mem::forget(dir); + } + + assert!( + output.status.success(), + "rar rejected experimental RAR5 compressed output\nstdout:\n{}\nstderr:\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + } + + #[test] + #[ignore = "requires local rar command; used for reference-validating experimental RAR5 match output"] + fn reference_rar_accepts_internal_match_compressed_member() { + let data = b"RAR5 match compressed reference experiment\n".repeat(8); + let packed = encode_lz_member(&data, 0).unwrap(); + let name = b"compressed.txt"; + + let mut archive = Vec::new(); + archive.extend_from_slice(RAR50_SIGNATURE); + write_main_header( + &mut archive, + 0, + None, + &[], + &crate::WriterResources::default(), + ) + .unwrap(); + + let mut extra = Vec::new(); + write_hash_record_with_value(&mut extra, blake2sp::hash(&data)).unwrap(); + let specific = file_specific( + name, + data.len() as u64, + crc32(&data), + 0x20, + None, + 1 << 7, + 0, + false, + &crate::WriterResources::default(), + ) + .unwrap(); + write_block( + &mut archive, + HEAD_FILE, + HFL_EXTRA | HFL_DATA, + Some(packed.len() as u64), + &specific, + &extra, + &packed, + &crate::WriterResources::default(), + ) + .unwrap(); + write_end_header(&mut archive, 0, &crate::WriterResources::default()).unwrap(); + + let dir = crate::scratch::case("rars-rar50-match"); + let path = dir.join("archive.rar"); + fs::write(&path, archive).unwrap(); + let output = match Command::new("rar").arg("t").arg(&path).output() { + Ok(output) => output, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + eprintln!("skipping reference test: local `rar` command is not installed"); + return; + } + Err(error) => panic!("failed to run rar: {error}"), + }; + if std::env::var_os("RARS_KEEP_REFERENCE_ARCHIVE").is_some() { + eprintln!("kept reference archive: {}", path.display()); + std::mem::forget(dir); + } + + assert!( + output.status.success(), + "rar rejected experimental RAR5 match output\nstdout:\n{}\nstderr:\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + } + + #[test] + fn writer_options_default_targets_rar50_with_store_only_features() { + let options = WriterOptions::default(); + assert_eq!(options.target, crate::ArchiveVersion::Rar50); + assert_eq!(options.features, crate::FeatureSet::store_only()); + } +} diff --git a/arca-rar/vendor/rars/src/rar50/write/plan.rs b/arca-rar/vendor/rars/src/rar50/write/plan.rs new file mode 100644 index 00000000..2f4509b4 --- /dev/null +++ b/arca-rar/vendor/rars/src/rar50/write/plan.rs @@ -0,0 +1,236 @@ +//! Codec settings and execution decisions, resolved before scheduling work. + +use super::FilterPolicy; +use crate::codec::rar50::EncodeOptions; +use crate::streaming::preparation::Records; +use crate::{Result, WriterResources}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(super) enum FallbackReason { + AutomaticFilterWorkspace { required: u64, limit: u64 }, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(super) enum Execution { + WholeMember, + Blocks { fallback: FallbackReason }, +} + +#[derive(Debug, Clone, Copy)] +pub(super) struct MemberPlan { + pub(super) execution: Execution, + /// Whole-member workspace or one streaming job's workspace, never both. + pub(super) workspace: u64, +} + +pub(super) enum ExecutionPlan { + Stored, + Blocks { workspace: u64 }, + IndependentMembers(Records), +} + +impl ExecutionPlan { + #[cfg(test)] + pub(super) fn new( + settings: &CompressPlan, + sizes: impl ExactSizeIterator, + limit: u64, + ) -> Self { + Self::with_resources(settings, sizes, &WriterResources::new(limit)).unwrap() + } + + pub(super) fn with_resources( + settings: &CompressPlan, + sizes: impl ExactSizeIterator, + resources: &WriterResources, + ) -> Result { + let limit = resources.memory_limit(); + // Select the requested mode before estimating its active workspace. + if settings.method == 0 { + return Ok(Self::Stored); + } + let whole_members = !settings.solid + && (settings.filter_policy != FilterPolicy::None || settings.candidates.len() > 1); + if !whole_members { + return Ok(Self::Blocks { + workspace: streaming_workspace(settings, true), + }); + } + Ok(Self::IndependentMembers(Records::collect( + sizes.map(|size| { + let required = if size == 0 { + 0 + } else { + whole_member_workspace(size, settings) + }; + Ok( + if required <= limit || settings.filter_policy != FilterPolicy::Auto { + MemberPlan { + execution: Execution::WholeMember, + workspace: required, + } + } else { + MemberPlan { + execution: Execution::Blocks { + fallback: FallbackReason::AutomaticFilterWorkspace { + required, + limit, + }, + }, + // Automatic fallback uses only the base encoder candidate. + workspace: streaming_workspace(settings, false), + } + }, + ) + }), + resources, + )?)) + } + + #[cfg(test)] + fn members(&self) -> &[MemberPlan] { + match self { + Self::IndependentMembers(members) => members, + _ => panic!("expected independent member plan"), + } + } +} + +fn streaming_workspace(settings: &CompressPlan, include_candidates: bool) -> u64 { + let optimal = settings.encode_options.optimal_parse + || (include_candidates + && settings + .candidates + .iter() + .any(|options| options.optimal_parse)); + super::streaming_lz_workspace( + settings.dictionary_size, + crate::codec::rar50::MAX_LZ_BLOCK_SIZE, + optimal, + ) +} + +#[derive(Debug)] +#[cfg_attr(test, derive(Clone))] +pub(super) struct CompressPlan { + pub(super) algorithm_version: u8, + pub(super) encode_options: EncodeOptions, + pub(super) dictionary_size: u64, + pub(super) block_size: usize, + pub(super) solid: bool, + /// The RAR 5 compression method. Method zero means the members are stored + /// verbatim, so nothing is compressed at all. + pub(super) method: u8, + /// Filters and multi-candidate encoding both need the whole member at + /// once, so they only run for members that fit the memory budget. + pub(super) filter_policy: FilterPolicy, + pub(super) candidates: Records, +} + +/// Working memory a member needs to be filtered as a whole: the member, the +/// filtered copy, and the candidate packed outputs being compared. +pub(super) fn whole_member_workspace(input_size: u64, plan: &CompressPlan) -> u64 { + let optimal = plan.encode_options.optimal_parse + || plan.candidates.iter().any(|options| options.optimal_parse); + let reach = plan + .candidates + .iter() + .map(|options| options.max_match_distance as u64) + .chain(std::iter::once( + plan.encode_options.max_match_distance as u64, + )) + .max() + .unwrap_or(0) + .min(input_size) + .max(crate::codec::rar50::LZ_BLOCK_SIZE as u64); + let block = input_size.min(crate::codec::rar50::MAX_LZ_BLOCK_SIZE as u64) as usize; + // Input, transformed input and competing packed outputs stay live alongside + // the finder and the per-block token/parse workspace, not instead of them. + input_size + .saturating_mul(4) + .saturating_add(super::streaming_lz_workspace(reach, block, optimal)) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn settings() -> CompressPlan { + let encode_options = EncodeOptions::new(8).with_max_match_distance(128 * 1024); + CompressPlan { + algorithm_version: 0, + encode_options, + dictionary_size: 128 * 1024, + block_size: crate::codec::rar50::LZ_BLOCK_SIZE, + solid: false, + method: 1, + filter_policy: FilterPolicy::Auto, + candidates: vec![encode_options].into(), + } + } + + #[test] + fn automatic_fallback_records_the_admission_boundary_and_reason() { + let settings = settings(); + let size = 2 * 1024 * 1024; + let required = whole_member_workspace(size, &settings); + let at_limit = ExecutionPlan::new(&settings, [size].into_iter(), required); + assert_eq!(at_limit.members()[0].execution, Execution::WholeMember); + let below = ExecutionPlan::new(&settings, [size].into_iter(), required - 1); + assert_eq!( + below.members()[0].execution, + Execution::Blocks { + fallback: FallbackReason::AutomaticFilterWorkspace { + required, + limit: required - 1 + }, + } + ); + assert!(below.members()[0].workspace < required); + } + + #[test] + fn explicit_filters_and_candidate_trials_cannot_silently_fall_back() { + let mut settings = settings(); + settings.filter_policy = + FilterPolicy::Explicit(crate::FilterSpec::whole(crate::FilterKind::Delta { + channels: 1, + })); + for filter in [settings.filter_policy.clone(), FilterPolicy::None] { + settings.filter_policy = filter; + settings + .candidates + .push_growing(settings.encode_options) + .unwrap(); + let execution = ExecutionPlan::new(&settings, [16].into_iter(), 1); + assert_eq!(execution.members()[0].execution, Execution::WholeMember); + assert!(execution.members()[0].workspace > 1); + } + } + + #[test] + fn stored_empty_and_solid_modes_do_not_acquire_whole_member_workspace() { + let mut settings = settings(); + let empty = ExecutionPlan::new(&settings, [0].into_iter(), 0); + assert_eq!(empty.members()[0].workspace, 0); + assert_eq!(empty.members()[0].execution, Execution::WholeMember); + settings.method = 0; + let stored = ExecutionPlan::new(&settings, [u64::MAX].into_iter(), 0); + assert!(matches!(stored, ExecutionPlan::Stored)); + settings.method = 1; + settings.solid = true; + let solid = ExecutionPlan::new(&settings, [16, u64::MAX].into_iter(), u64::MAX); + assert!(matches!(solid, ExecutionPlan::Blocks { workspace } if workspace > 0)); + } + + #[test] + fn independent_member_planning_respects_the_execution_ledger() { + let ledger = crate::codec::workspace::Allowance::limited(0); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + let error = ExecutionPlan::with_resources(&settings(), [1].into_iter(), &resources) + .err() + .unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(ledger.used(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/read_control.rs b/arca-rar/vendor/rars/src/read_control.rs new file mode 100644 index 00000000..f36c0f75 --- /dev/null +++ b/arca-rar/vendor/rars/src/read_control.rs @@ -0,0 +1,367 @@ +//! Cooperative reader cancellation, with observation local to an operation. +use crate::{Error, Result}; +use std::io::{self, Read, Seek, SeekFrom, Write}; +use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, +}; + +/// A shared one-way cancellation signal for archive readers. +/// Clone the token to cancel from another thread or an input/output callback. +/// Supply it through [`crate::ArchiveReadOptions::with_cancellation`]. A token +/// cannot be reset; create a new one for another operation after cancellation. +/// Parsing does not retain the token or apply it to later extraction. +/// +/// Readers check before starting work, between headers and members, around +/// output callbacks, during bounded reads/writes, and periodically in decoder, +/// filter and VM loops. Parallel extraction joins admitted workers before +/// returning; workers check the signal before decoding and during codec work. +/// +/// Cancellation is cooperative, without a wall-clock deadline. Blocked caller +/// I/O, key derivation, allocation, copies and individual checksum/crypto library +/// operations cannot be preempted. Once observed, cancellation returns +/// [`Error::Cancelled`] (possibly with entry/volume context). An unrelated error +/// is not replaced merely because the signal was set concurrently. +/// +/// Partial output and earlier extracted members can remain. The call aborts; +/// it does not resume solid state, roll back sinks or refund output budgets. +#[derive(Clone, Debug, Default)] +pub struct ReadCancellation(Arc, Option>); + +impl ReadCancellation { + /// Creates an uncancelled signal. + pub fn new() -> Self { + Self::default() + } + /// Create a signal which observes this token as well as its own cancellation. + /// Cancelling the child never cancels its parent or siblings. This lets a + /// scoped operation stop its workers without poisoning a caller-owned token. + pub fn child(&self) -> Self { + Self( + Arc::new(AtomicBool::new(false)), + Some(Arc::new(self.clone())), + ) + } + /// Signals cancellation to every clone. Calling this repeatedly is harmless. + pub fn cancel(&self) { + self.0.store(true, Ordering::Relaxed); + } + /// Returns whether any clone has signalled cancellation. + pub fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) + || self.1.as_ref().is_some_and(|parent| parent.is_cancelled()) + } +} + +#[derive(Clone, Debug, Default)] +pub(crate) struct ReadControl(Option>); + +#[derive(Debug)] +struct Observation { + token: ReadCancellation, + observed: AtomicBool, + #[cfg(test)] + checks_remaining: std::sync::atomic::AtomicUsize, +} + +impl ReadControl { + #[cfg(feature = "recovery")] + pub(crate) fn cancellation(&self) -> Option<&ReadCancellation> { + self.0.as_ref().map(|state| &state.token) + } + pub(crate) fn is_enabled(&self) -> bool { + self.0.is_some() + } + pub(crate) fn new(token: Option<&ReadCancellation>) -> Self { + Self(token.map(|token| { + Arc::new(Observation { + token: token.clone(), + observed: AtomicBool::new(false), + #[cfg(test)] + checks_remaining: std::sync::atomic::AtomicUsize::new(usize::MAX), + }) + })) + } + pub(crate) fn check(&self) -> Result<()> { + if let Some(state) = &self.0 { + #[cfg(test)] + { + let mut remaining = state.checks_remaining.load(Ordering::Relaxed); + while remaining != usize::MAX { + match state.checks_remaining.compare_exchange_weak( + remaining, + remaining.saturating_sub(1), + Ordering::Relaxed, + Ordering::Relaxed, + ) { + Ok(0) => { + state.token.cancel(); + break; + } + Ok(_) => break, + Err(actual) => remaining = actual, + } + } + } + if state.token.is_cancelled() { + state.observed.store(true, Ordering::Relaxed); + return Err(Error::Cancelled); + } + } + Ok(()) + } + /// Test-only checkpoint scheduling avoids races and wall-clock sleeps. + #[cfg(test)] + pub(crate) fn cancel_after_checks(&self, successful_checks: usize) { + self.0 + .as_ref() + .expect("configured token") + .checks_remaining + .store(successful_checks, Ordering::Relaxed); + } + pub(crate) fn finish(&self, result: Result) -> Result { + // Do not turn a real error into cancellation just because the token was + // signalled later. Restore only cancellation actually observed by this work. + if self + .0 + .as_ref() + .is_some_and(|s| s.observed.load(Ordering::Relaxed)) + { + match result { + Err(e) if e.kind() == crate::ErrorKind::Cancelled => Err(e), + _ => Err(Error::Cancelled), + } + } else { + result + } + } + pub(crate) fn check_codec(&self) -> crate::codec::Result<()> { + self.check().map_err(|_| crate::codec::Error::Cancelled) + } + pub(crate) fn reader(&self, reader: R) -> ControlledReader { + ControlledReader { + reader, + control: self.clone(), + } + } + pub(crate) fn write_all( + &self, + writer: &mut (impl Write + ?Sized), + bytes: &[u8], + ) -> io::Result<()> { + if !self.is_enabled() { + return writer.write_all(bytes); + } + let mut remaining = bytes; + while !remaining.is_empty() { + self.check().map_err(io::Error::other)?; + match writer.write(&remaining[..remaining.len().min(64 * 1024)]) { + Ok(0) => return Err(io::ErrorKind::WriteZero.into()), + Ok(n) => remaining = &remaining[n..], + Err(e) if e.kind() == io::ErrorKind::Interrupted => continue, + Err(e) => return Err(e), + } + } + self.check().map_err(io::Error::other) + } + pub(crate) fn poller(&self) -> Poller { + Poller { + control: self.clone(), + steps: 0, + next_position: 0, + } + } +} + +pub(crate) struct ControlledReader { + reader: R, + control: ReadControl, +} +impl Read for ControlledReader { + fn read(&mut self, bytes: &mut [u8]) -> io::Result { + if self.control.0.is_none() { + return self.reader.read(bytes); + } + self.control.check().map_err(io::Error::other)?; + let len = bytes.len().min(64 * 1024); + self.reader.read(&mut bytes[..len]) + } +} +impl Seek for ControlledReader { + fn seek(&mut self, pos: SeekFrom) -> io::Result { + self.control.check().map_err(io::Error::other)?; + self.reader.seek(pos) + } +} + +pub(crate) struct Poller { + control: ReadControl, + steps: usize, + next_position: usize, +} +impl Poller { + // Bound both no-output symbol work and runs that expand large matches. + pub(crate) fn check(&mut self, position: usize) -> Result<()> { + if self.control.0.is_none() { + return Ok(()); + } + if self.steps == 0 || position >= self.next_position { + self.control.check()?; + self.steps = 4096; + self.next_position = position.saturating_add(64 * 1024); + } + self.steps -= 1; + Ok(()) + } + pub(crate) fn check_codec(&mut self, position: usize) -> crate::codec::Result<()> { + self.check(position) + .map_err(|_| crate::codec::Error::Cancelled) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn child_cancellation_is_local_but_parent_cancellation_propagates() { + let parent = ReadCancellation::new(); + let first = parent.child(); + let second = parent.child(); + let nested = second.child(); + first.cancel(); + assert!(!parent.is_cancelled()); + assert!(!second.is_cancelled()); + assert!(!nested.is_cancelled()); + parent.cancel(); + assert!(second.is_cancelled()); + assert!(nested.is_cancelled()); + assert!(parent.child().is_cancelled()); + } + + #[test] + fn cancellation_observation_is_local_and_survives_error_adapters() { + let token = ReadCancellation::new(); + let observed = ReadControl::new(Some(&token)); + let unrelated = ReadControl::new(Some(&token)); + token.clone().cancel(); + assert!(observed.check().is_err()); + assert_eq!( + observed + .finish::<()>(Err(Error::WrongPasswordOrCorruptData)) + .unwrap_err() + .kind(), + crate::ErrorKind::Cancelled + ); + assert!(matches!( + unrelated.finish::<()>(Err(Error::WrongPasswordOrCorruptData)), + Err(Error::WrongPasswordOrCorruptData) + )); + } + + #[test] + fn reader_bounds_reads_and_preserves_the_cancellation_sentinel() { + struct Source { + token: ReadCancellation, + calls: usize, + } + impl Read for Source { + fn read(&mut self, bytes: &mut [u8]) -> io::Result { + self.calls += 1; + assert!(bytes.len() <= 64 * 1024); + self.token.cancel(); + bytes.fill(42); + Ok(bytes.len()) + } + } + let token = ReadCancellation::new(); + let control = ReadControl::new(Some(&token)); + let mut source = Source { token, calls: 0 }; + let mut reader = control.reader(&mut source); + let mut bytes = vec![0; 128 * 1024]; + assert_eq!(reader.read(&mut bytes).unwrap(), 64 * 1024); + let err = Error::from(reader.read(&mut bytes).unwrap_err()); + assert_eq!(err.kind(), crate::ErrorKind::Cancelled); + assert_eq!(source.calls, 1); + } + + #[test] + fn polling_bounds_both_output_and_no_output_work() { + for output in [false, true] { + let token = ReadCancellation::new(); + let control = ReadControl::new(Some(&token)); + control.cancel_after_checks(1); + let mut poller = control.poller(); + poller.check(0).unwrap(); + if output { + assert!(poller.check(64 * 1024).is_err()); + } else { + for _ in 1..4096 { + poller.check(0).unwrap(); + } + assert!(poller.check(0).is_err()); + } + } + } + + #[test] + fn controlled_write_retries_interrupts_and_preserves_failures() { + struct ScriptedWriter { + replies: std::collections::VecDeque>, + written: Vec, + } + impl Write for ScriptedWriter { + fn write(&mut self, bytes: &[u8]) -> io::Result { + let count = self.replies.pop_front().expect("unexpected write")?; + self.written.extend_from_slice(&bytes[..count]); + Ok(count) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + + let token = ReadCancellation::new(); + let control = ReadControl::new(Some(&token)); + let mut writer = ScriptedWriter { + replies: [Err(io::ErrorKind::Interrupted.into()), Ok(1), Ok(2)].into(), + written: Vec::new(), + }; + control.write_all(&mut writer, b"abc").unwrap(); + assert_eq!(writer.written, b"abc"); + assert!(writer.replies.is_empty()); + + for (reply, kind) in [ + (Ok(0), io::ErrorKind::WriteZero), + ( + Err(io::ErrorKind::BrokenPipe.into()), + io::ErrorKind::BrokenPipe, + ), + ] { + let mut writer = ScriptedWriter { + replies: [reply].into(), + written: Vec::new(), + }; + assert_eq!( + control.write_all(&mut writer, b"x").unwrap_err().kind(), + kind + ); + assert!(writer.written.is_empty()); + } + + struct CancelAfterWrite(ReadCancellation); + impl Write for CancelAfterWrite { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.0.cancel(); + Ok(bytes.len().min(1)) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + let error = control + .write_all(&mut CancelAfterWrite(token), b"abc") + .unwrap_err(); + assert_eq!(Error::from(error).kind(), crate::ErrorKind::Cancelled); + } +} diff --git a/arca-rar/vendor/rars/src/reader_scratch.rs b/arca-rar/vendor/rars/src/reader_scratch.rs new file mode 100644 index 00000000..a67ada11 --- /dev/null +++ b/arca-rar/vendor/rars/src/reader_scratch.rs @@ -0,0 +1,49 @@ +use std::path::PathBuf; + +/// Opt-in disk scratch for large RAR5/7 compressed members. +/// +/// Files are privately created in an existing caller-selected directory and +/// removed on drop (cleanup errors cannot be reported from Drop). Scratch may +/// contain decrypted data. The directory must remain trusted and available. +/// Bare WebAssembly rejects this disk policy; it never substitutes RAM storage. +/// +/// ```no_run +/// # fn extract(archive: &rars::Archive) -> rars::Result<()> { +/// let scratch = rars::Rar50Scratch::new("/path/to/private/scratch", 4 * 1024 * 1024 * 1024) +/// .with_filter_memory_limit(8 * 1024 * 1024); +/// let options = rars::ArchiveReadOptions::new() +/// .with_rar50_buffered_decode_limit(1024 * 1024) +/// .with_rar50_scratch(&scratch); +/// archive.extract_to_with_options(options, |_| Ok(Box::new(std::io::sink())))?; +/// # Ok(()) +/// # } +/// ``` +#[derive(Debug, Clone)] +pub struct Rar50Scratch { + pub(crate) directory: PathBuf, + pub(crate) max_bytes: u64, + pub(crate) filter_memory_limit: u64, +} + +impl Rar50Scratch { + /// Limits combined logical scratch-file lengths for one member, including + /// raw output, transformed output and filter records. Files are released + /// between members; filesystem allocation overhead is outside this quota. + /// Admission reserves room for twice the declared member size. Filter + /// records require an additional 24 bytes each as they are encountered. + pub fn new(directory: impl Into, max_bytes: u64) -> Self { + Self { + directory: directory.into(), + max_bytes, + filter_memory_limit: 8 * 1024 * 1024, + } + } + + /// Bounds temporary filter data (default 8 MiB). Each filter range requires + /// at most twice its length; a larger range is refused before allocation. + /// Dictionary/history, compressed blocks and fixed I/O buffers are separate. + pub fn with_filter_memory_limit(mut self, bytes: u64) -> Self { + self.filter_memory_limit = bytes; + self + } +} diff --git a/arca-rar/vendor/rars/src/reader_signature_tests.rs b/arca-rar/vendor/rars/src/reader_signature_tests.rs new file mode 100644 index 00000000..10ef9b66 --- /dev/null +++ b/arca-rar/vendor/rars/src/reader_signature_tests.rs @@ -0,0 +1,151 @@ +use super::*; +use std::io::{self, Cursor, Seek, SeekFrom}; + +struct Observed { + input: Cursor>, + bytes: usize, + refuse_after: Option, +} + +impl Read for Observed { + fn read(&mut self, output: &mut [u8]) -> io::Result { + if self.refuse_after.is_some_and(|end| self.bytes >= end) { + return Err(io::ErrorKind::PermissionDenied.into()); + } + let count = output.len().min(3); + let count = self.input.read(&mut output[..count])?; + self.bytes += count; + Ok(count) + } +} + +#[test] +fn strong_standard_signatures_read_only_the_fixed_prefix() { + for signature in [detect::RAR15_SIGNATURE.as_slice(), detect::RAR50_SIGNATURE] { + let mut data = vec![42; 2 * 1024 * 1024]; + data[..signature.len()].copy_from_slice(signature); + let mut source = Observed { + input: Cursor::new(data), + bytes: 0, + refuse_after: Some(8), + }; + let actual = read_archive_signature(&mut source, 2 * 1024 * 1024) + .unwrap() + .unwrap(); + assert_eq!(actual, detect_archive_family(signature).unwrap()); + assert_eq!(source.bytes, 8); + } +} + +#[test] +fn signature_prefix_retains_full_scan_precedence_and_short_inputs() { + for bytes in [ + b"".as_slice(), + b"Rar!\x1a\x07", + b"Rar!\x1a\x07\x00", + b"Rar!\x1a\x07\x01\x00", + b"RE~^", + b"RE~^payload Rar!\x1a\x07\x01\x00later", + b"RE~^payload Rar!\x1a\x07\x00later", + b"stub Rar!\x1a\x07\x01\x00later", + b"stub RE~^payload", + b"stub RE~^ Rar!\x1a\x07\x00payload", + b"not an archive", + ] { + for len in 0..=bytes.len() { + let expected = find_archive_start(&bytes[..len], SFX_SCAN_LIMIT); + let actual = read_archive_signature(&mut &bytes[..len], len); + assert_eq!(actual.unwrap(), expected); + } + } +} + +#[test] +fn sfx_prefix_fallback_keeps_existing_scan_length_and_io_errors() { + let mut bytes = vec![0; 300 * 1024]; + bytes.extend_from_slice(detect::RAR50_SIGNATURE); + let mut source = Observed { + input: Cursor::new(bytes.clone()), + bytes: 0, + refuse_after: None, + }; + assert_eq!( + read_archive_signature(&mut source, bytes.len()).unwrap(), + find_archive_start(&bytes, SFX_SCAN_LIMIT) + ); + assert_eq!(source.bytes, bytes.len()); + source.input.set_position(0); + source.bytes = 0; + source.refuse_after = Some(8); + assert!(matches!( + read_archive_signature(&mut source, bytes.len()), + Err(Error::Io(_)) + )); +} + +#[test] +fn reader_prefix_retains_cancellation_io_error_and_eof_ordering() { + struct Callback { + input: Cursor>, + token: ReadCancellation, + fail: bool, + advertised_len: u64, + } + impl Read for Callback { + fn read(&mut self, output: &mut [u8]) -> io::Result { + let count = output.len().min(3); + let count = self.input.read(&mut output[..count])?; + if self.input.position() == 8 { + self.token.cancel(); + if self.fail { + return Err(io::ErrorKind::PermissionDenied.into()); + } + } + Ok(count) + } + } + impl Seek for Callback { + fn seek(&mut self, position: SeekFrom) -> io::Result { + match position { + SeekFrom::End(0) => self.input.seek(SeekFrom::Start(self.advertised_len)), + position => self.input.seek(position), + } + } + } + for fail in [false, true] { + let token = ReadCancellation::new(); + let reader = Callback { + input: Cursor::new(detect::RAR50_SIGNATURE.to_vec()), + token: token.clone(), + fail, + advertised_len: 32, + }; + let error = ArchiveReader::read_reader_with_options( + reader, + ArchiveReadOptions::new().with_cancellation(&token), + ) + .unwrap_err(); + assert!(token.is_cancelled()); + assert_eq!( + error.kind(), + if fail { + ErrorKind::Io + } else { + ErrorKind::Cancelled + } + ); + if fail { + assert!( + matches!(error, Error::Io(ref source) if source.kind == io::ErrorKind::PermissionDenied) + ); + } + } + let reader = Callback { + input: Cursor::new(b"Rar!".to_vec()), + token: ReadCancellation::new(), + fail: false, + advertised_len: 32, + }; + let error = ArchiveReader::read_reader(reader).unwrap_err(); + assert!(matches!(error, Error::Io(ref source) if source.kind == io::ErrorKind::UnexpectedEof)); +} diff --git a/arca-rar/vendor/rars/src/recovery/mod.rs b/arca-rar/vendor/rars/src/recovery/mod.rs new file mode 100644 index 00000000..1db76fcd --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/mod.rs @@ -0,0 +1,8 @@ +//! Recovery-record primitives shared by RAR writer and repair code. +//! +//! RAR 5 recovery data uses GF(2^16) with reduction polynomial `0x1100b` +//! and a Cauchy encoder matrix. This crate intentionally exposes the field +//! and matrix building blocks before wiring them into archive serialization. + +pub mod rar3; +pub mod rar5; diff --git a/arca-rar/vendor/rars/src/recovery/rar3.rs b/arca-rar/vendor/rars/src/recovery/rar3.rs new file mode 100644 index 00000000..08ab7325 --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar3.rs @@ -0,0 +1,9 @@ +//! Recovery diagnostics remain available without recovery execution. + +mod errors; +pub use errors::{Error, Result}; + +#[cfg(feature = "recovery")] +mod implementation; +#[cfg(feature = "recovery")] +pub use implementation::*; diff --git a/arca-rar/vendor/rars/src/recovery/rar3/errors.rs b/arca-rar/vendor/rars/src/recovery/rar3/errors.rs new file mode 100644 index 00000000..61c28def --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar3/errors.rs @@ -0,0 +1,25 @@ +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + InvalidParitySize, + InvalidCodewordSize, + TooManyErasures, + DecodeFailed, +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::InvalidParitySize => f.write_str("RAR 3 recovery parity size is invalid"), + Self::InvalidCodewordSize => f.write_str("RAR 3 recovery codeword size is invalid"), + Self::TooManyErasures => { + f.write_str("RAR 3 recovery data cannot repair this many erasures") + } + Self::DecodeFailed => f.write_str("RAR 3 recovery decode failed"), + } + } +} + +impl std::error::Error for Error {} + +pub type Result = std::result::Result; diff --git a/arca-rar/vendor/rars/src/recovery/rar3/implementation.rs b/arca-rar/vendor/rars/src/recovery/rar3/implementation.rs new file mode 100644 index 00000000..033f1993 --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar3/implementation.rs @@ -0,0 +1,482 @@ +use super::{Error, Result}; + +const MAX_PARITY: usize = 255; +const MAX_POLYNOMIAL: usize = 512; +const PRIMITIVE_POLYNOMIAL: u16 = 0x11d; + +#[derive(Debug, Clone)] +pub(crate) struct RSCoder8 { + parity_size: usize, + gf_exp: [u8; MAX_POLYNOMIAL], + gf_log: [u16; MAX_PARITY + 1], + generator: Vec, +} + +impl RSCoder8 { + pub(crate) fn new(parity_size: usize) -> Result { + if parity_size == 0 || parity_size > MAX_PARITY { + return Err(Error::InvalidParitySize); + } + let mut coder = Self { + parity_size, + gf_exp: [0; MAX_POLYNOMIAL], + gf_log: [0; MAX_PARITY + 1], + generator: vec![0; parity_size], + }; + coder.init_field(); + coder.init_generator(); + Ok(coder) + } + + #[cfg(test)] + fn encode(&self, data: &[u8]) -> Vec { + let mut shift = vec![0u8; self.parity_size + 1]; + for &byte in data { + let feedback = byte ^ shift[self.parity_size - 1]; + for index in (1..self.parity_size).rev() { + shift[index] = shift[index - 1] ^ self.mul(self.generator[index], feedback); + } + shift[0] = self.mul(self.generator[0], feedback); + } + (0..self.parity_size) + .map(|index| shift[self.parity_size - index - 1]) + .collect() + } + + pub(crate) fn correct_erasures(&self, codeword: &mut [u8], erasures: &[usize]) -> Result<()> { + if codeword.is_empty() || codeword.len() > MAX_PARITY { + return Err(Error::InvalidCodewordSize); + } + if erasures.len() > self.parity_size { + return Err(Error::TooManyErasures); + } + if erasures.iter().any(|&index| index >= codeword.len()) { + return Err(Error::InvalidCodewordSize); + } + + let mut syndromes = vec![0u8; self.parity_size]; + let mut all_zero = true; + for (index, syndrome) in syndromes.iter_mut().enumerate() { + let factor = self.gf_exp[index + 1]; + let mut sum = 0; + for &byte in codeword.iter() { + sum = byte ^ self.mul(factor, sum); + } + *syndrome = sum; + all_zero &= sum == 0; + } + if all_zero { + return Ok(()); + } + if erasures.is_empty() { + return Err(Error::DecodeFailed); + } + + let mut locator = vec![0u8; self.parity_size + 1]; + locator[0] = 1; + for &erasure in erasures { + let multiplier = self.gf_exp[codeword.len() - erasure - 1]; + for index in (1..=self.parity_size).rev() { + locator[index] ^= self.mul(multiplier, locator[index - 1]); + } + } + + let mut error_locs = Vec::new(); + let mut denominators = Vec::new(); + for root in (MAX_PARITY - codeword.len())..=MAX_PARITY { + let mut sum = 0; + for (power, &coefficient) in locator.iter().enumerate() { + sum ^= self.mul(self.gf_exp[(power * root) % MAX_PARITY], coefficient); + } + if sum == 0 { + let loc = MAX_PARITY - root; + error_locs.push(loc); + let mut denominator = 0; + for index in (1..=self.parity_size).step_by(2) { + denominator ^= self.mul( + locator[index], + self.gf_exp[(root * (index - 1)) % MAX_PARITY], + ); + } + denominators.push(denominator); + } + } + // Each validated erasure supplies a root in this range. The locator's + // constant term is one, so it has at most parity_size distinct roots. + let evaluator = self.multiply_polynomials(&locator, &syndromes); + for (&loc, &denominator) in error_locs.iter().zip(&denominators) { + if denominator == 0 { + return Err(Error::DecodeFailed); + } + let data_pos = codeword + .len() + .checked_sub(loc + 1) + .ok_or(Error::DecodeFailed)?; + let dloc = MAX_PARITY - loc; + let mut numerator = 0; + for (index, &coefficient) in evaluator.iter().enumerate() { + numerator ^= self.mul(coefficient, self.gf_exp[(dloc * index) % MAX_PARITY]); + } + let correction = self.mul( + numerator, + self.gf_exp[MAX_PARITY - usize::from(self.gf_log[denominator as usize])], + ); + codeword[data_pos] ^= correction; + } + Ok(()) + } + + fn init_field(&mut self) { + let mut value = 1u16; + for index in 0..MAX_PARITY { + self.gf_log[value as usize] = index as u16; + self.gf_exp[index] = value as u8; + value <<= 1; + if value > 0xff { + value ^= PRIMITIVE_POLYNOMIAL; + } + } + for index in MAX_PARITY..MAX_POLYNOMIAL { + self.gf_exp[index] = self.gf_exp[index - MAX_PARITY]; + } + } + + fn init_generator(&mut self) { + let mut current = vec![0u8; self.parity_size]; + current[0] = 1; + for index in 1..=self.parity_size { + let mut factor = vec![0u8; self.parity_size]; + factor[0] = self.gf_exp[index]; + if self.parity_size > 1 { + factor[1] = 1; + } + self.generator = self.multiply_polynomials(&factor, ¤t); + current.clone_from(&self.generator); + } + } + + fn multiply_polynomials(&self, left: &[u8], right: &[u8]) -> Vec { + let mut out = vec![0u8; self.parity_size]; + for left_index in 0..self.parity_size { + if left.get(left_index).copied().unwrap_or(0) == 0 { + continue; + } + for right_index in 0..(self.parity_size - left_index) { + out[left_index + right_index] ^= self.mul( + left[left_index], + right.get(right_index).copied().unwrap_or(0), + ); + } + } + out + } + + fn mul(&self, left: u8, right: u8) -> u8 { + if left == 0 || right == 0 { + 0 + } else { + self.gf_exp[usize::from(self.gf_log[left as usize] + self.gf_log[right as usize])] + } + } +} + +pub fn reconstruct_data_volumes( + data_volumes: &[Option<&[u8]>], + recovery_count: usize, + recovery_volumes: &[(usize, &[u8])], +) -> Result>> { + if data_volumes.is_empty() || data_volumes.len() + recovery_count > MAX_PARITY { + return Err(Error::InvalidCodewordSize); + } + if recovery_volumes.is_empty() || recovery_count == 0 { + return Err(Error::InvalidParitySize); + } + let shard_len = recovery_volumes[0].1.len(); + if recovery_volumes + .iter() + .any(|&(index, data)| index >= recovery_count || data.len() != shard_len) + { + return Err(Error::InvalidCodewordSize); + } + if data_volumes + .iter() + .flatten() + .any(|data| data.len() > shard_len) + { + return Err(Error::InvalidCodewordSize); + } + + let mut recovery_by_index = vec![None; recovery_count]; + for &(index, data) in recovery_volumes { + if recovery_by_index[index].replace(data).is_some() { + return Err(Error::InvalidCodewordSize); + } + } + + let missing_data: Vec<_> = data_volumes + .iter() + .enumerate() + .filter_map(|(index, data)| data.is_none().then_some(index)) + .collect(); + if missing_data.is_empty() { + return Ok(data_volumes + .iter() + .map(|data| { + // No missing data volumes were found above. + let data = data.expect("every data volume is present"); + let mut out = vec![0; shard_len]; + out[..data.len()].copy_from_slice(data); + out + }) + .collect()); + } + + let missing_recovery: Vec<_> = recovery_by_index + .iter() + .enumerate() + .filter_map(|(index, data)| data.is_none().then_some(data_volumes.len() + index)) + .collect(); + let mut erasures = missing_data.clone(); + erasures.extend(missing_recovery); + if erasures.len() > recovery_count { + return Err(Error::TooManyErasures); + } + + let coder = RSCoder8::new(recovery_count)?; + let mut out: Vec> = data_volumes + .iter() + .map(|data| { + let mut shard = vec![0; shard_len]; + if let Some(data) = data { + shard[..data.len()].copy_from_slice(data); + } + shard + }) + .collect(); + + for offset in 0..shard_len { + let mut codeword = vec![0; data_volumes.len() + recovery_count]; + for (index, data) in data_volumes.iter().enumerate() { + if let Some(data) = data { + codeword[index] = data.get(offset).copied().unwrap_or(0); + } + } + for (index, data) in recovery_by_index.iter().enumerate() { + if let Some(data) = data { + codeword[data_volumes.len() + index] = data[offset]; + } + } + coder.correct_erasures(&mut codeword, &erasures)?; + for &index in &missing_data { + out[index][offset] = codeword[index]; + } + } + + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::{reconstruct_data_volumes, Error, RSCoder8}; + + #[test] + fn rs8_encoder_matches_unrar_generator_shape() { + let coder = RSCoder8::new(11).unwrap(); + assert_eq!( + coder.generator, + vec![97, 180, 203, 151, 195, 196, 219, 7, 113, 50, 69] + ); + } + + #[test] + fn rs8_reconstructs_single_erased_data_symbol() { + let coder = RSCoder8::new(4).unwrap(); + let data = b"rar recovery data"; + let parity = coder.encode(data); + let mut codeword = [data.as_slice(), parity.as_slice()].concat(); + let original = codeword.clone(); + codeword[3] ^= 0xa5; + + coder.correct_erasures(&mut codeword, &[3]).unwrap(); + + assert_eq!(codeword, original); + } + + #[test] + fn rs8_reconstructs_multiple_erased_symbols_including_parity() { + let coder = RSCoder8::new(5).unwrap(); + let data = b"rar3-rs8"; + let parity = coder.encode(data); + let mut codeword = [data.as_slice(), parity.as_slice()].concat(); + let original = codeword.clone(); + codeword[1] = 0; + codeword[7] = 0; + codeword[10] = 0; + + coder.correct_erasures(&mut codeword, &[1, 7, 10]).unwrap(); + + assert_eq!(codeword, original); + } + + #[test] + fn rs8_rejects_more_erasures_than_parity_symbols() { + let coder = RSCoder8::new(2).unwrap(); + let mut codeword = b"abcde".to_vec(); + + assert_eq!( + coder.correct_erasures(&mut codeword, &[0, 1, 2]), + Err(Error::TooManyErasures) + ); + } + + #[test] + fn rs8_rejects_invalid_parameters_and_corrupt_unmarked_codewords() { + assert_eq!(RSCoder8::new(0).unwrap_err(), Error::InvalidParitySize); + assert_eq!(RSCoder8::new(256).unwrap_err(), Error::InvalidParitySize); + + let coder = RSCoder8::new(1).unwrap(); + assert_eq!( + coder.correct_erasures(&mut [], &[]), + Err(Error::InvalidCodewordSize) + ); + assert_eq!( + coder.correct_erasures(&mut [0; 256], &[]), + Err(Error::InvalidCodewordSize) + ); + assert_eq!( + coder.correct_erasures(&mut [0; 2], &[2]), + Err(Error::InvalidCodewordSize) + ); + assert_eq!(coder.correct_erasures(&mut [0; 2], &[]), Ok(())); + assert_eq!( + coder.correct_erasures(&mut [1, 0], &[]), + Err(Error::DecodeFailed) + ); + } + + #[test] + fn rs8_reports_each_failure_category() { + for (error, message) in [ + ( + Error::InvalidParitySize, + "RAR 3 recovery parity size is invalid", + ), + ( + Error::InvalidCodewordSize, + "RAR 3 recovery codeword size is invalid", + ), + ( + Error::TooManyErasures, + "RAR 3 recovery data cannot repair this many erasures", + ), + (Error::DecodeFailed, "RAR 3 recovery decode failed"), + ] { + assert_eq!(error.to_string(), message); + } + } + + #[test] + fn rs8_rejects_duplicate_erasure_positions() { + for parity in 2..=4 { + let coder = RSCoder8::new(parity).unwrap(); + for codeword_len in 2..=8 { + for index in 0..codeword_len { + let mut codeword = vec![0; codeword_len]; + codeword[0] = 1; + assert!( + coder + .correct_erasures(&mut codeword, &[index, index]) + .is_err(), + "parity={parity}, length={codeword_len}, index={index}" + ); + } + } + } + } + + #[test] + fn rev3_rejects_invalid_shard_geometry_and_duplicate_recovery_indices() { + let present = [1u8, 2]; + let recovery = [3u8, 4]; + type Case<'a> = ( + &'a [Option<&'a [u8]>], + usize, + &'a [(usize, &'a [u8])], + Error, + ); + let cases: &[Case<'_>] = &[ + (&[], 1, &[(0, &recovery)], Error::InvalidCodewordSize), + (&[None], 255, &[(0, &recovery)], Error::InvalidCodewordSize), + (&[None], 0, &[(0, &recovery)], Error::InvalidParitySize), + (&[None], 1, &[], Error::InvalidParitySize), + (&[None], 1, &[(1, &recovery)], Error::InvalidCodewordSize), + ( + &[None], + 1, + &[(0, &recovery), (0, &present[..1])], + Error::InvalidCodewordSize, + ), + ( + &[Some(&present)], + 1, + &[(0, &recovery[..1])], + Error::InvalidCodewordSize, + ), + ( + &[None], + 1, + &[(0, &recovery), (0, &recovery)], + Error::InvalidCodewordSize, + ), + (&[None, None], 1, &[(0, &recovery)], Error::TooManyErasures), + ]; + for &(data, count, shards, ref expected) in cases { + assert_eq!( + reconstruct_data_volumes(data, count, shards), + Err(expected.clone()) + ); + } + } + + #[test] + fn rev3_returns_healthy_padded_data_without_decoding() { + let actual = b"a"; + let recovery = b"rs"; + assert_eq!( + reconstruct_data_volumes(&[Some(actual)], 1, &[(0, recovery)]), + Ok(vec![b"a\0".to_vec()]) + ); + } + + #[test] + fn rev3_reconstructs_missing_data_volume_from_recovery_volume() { + let data = [ + b"volume-one".as_slice(), + b"volume-two".as_slice(), + b"volume-three".as_slice(), + ]; + let recovery_count = 2; + let coder = RSCoder8::new(recovery_count).unwrap(); + let shard_len = data.iter().map(|shard| shard.len()).max().unwrap(); + let mut recovery = vec![vec![0; shard_len]; recovery_count]; + for offset in 0..shard_len { + let column: Vec<_> = data + .iter() + .map(|shard| shard.get(offset).copied().unwrap_or(0)) + .collect(); + let encoded = coder.encode(&column); + for (row, byte) in recovery.iter_mut().zip(encoded) { + row[offset] = byte; + } + } + + let repaired = reconstruct_data_volumes( + &[Some(data[0]), None, Some(data[2])], + recovery_count, + &[(0, recovery[0].as_slice())], + ) + .unwrap(); + + assert_eq!(&repaired[1][..data[1].len()], data[1]); + } +} diff --git a/arca-rar/vendor/rars/src/recovery/rar5.rs b/arca-rar/vendor/rars/src/recovery/rar5.rs new file mode 100644 index 00000000..5c3ff0e1 --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar5.rs @@ -0,0 +1,12 @@ +//! Recovery diagnostics remain available without recovery execution. + +mod checksum; +pub use checksum::{crc64_rar_state, crc64_xz}; + +mod errors; +pub use errors::{Error, Result}; + +#[cfg(feature = "recovery")] +mod implementation; +#[cfg(feature = "recovery")] +pub use implementation::*; diff --git a/arca-rar/vendor/rars/src/recovery/rar5/checksum.rs b/arca-rar/vendor/rars/src/recovery/rar5/checksum.rs new file mode 100644 index 00000000..947b1968 --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar5/checksum.rs @@ -0,0 +1,24 @@ +//! Checksum utilities independent of recovery generation and repair. + +const CRC64_XZ_POLY: u64 = 0xc96c_5795_d787_0f42; +pub(super) const CRC64_XZ_INIT: u64 = 0xffff_ffff_ffff_ffff; + +pub fn crc64_xz(data: &[u8]) -> u64 { + crc64_update(data, CRC64_XZ_INIT) ^ CRC64_XZ_INIT +} + +pub(super) fn crc64_update(data: &[u8], initial: u64) -> u64 { + let mut crc = initial; + for &byte in data { + crc ^= byte as u64; + for _ in 0..8 { + let mask = 0u64.wrapping_sub(crc & 1); + crc = (crc >> 1) ^ (CRC64_XZ_POLY & mask); + } + } + crc +} + +pub fn crc64_rar_state(data: &[u8]) -> u64 { + crc64_update(data, 0) +} diff --git a/arca-rar/vendor/rars/src/recovery/rar5/errors.rs b/arca-rar/vendor/rars/src/recovery/rar5/errors.rs new file mode 100644 index 00000000..79ddcf3b --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar5/errors.rs @@ -0,0 +1,79 @@ +#[derive(Debug, Clone, PartialEq, Eq)] +#[non_exhaustive] +pub enum Error { + Cancelled, + BadRecoveryChunk, + OddShardSize, + PlanOverflow, + PrefixExceedsPlan, + TooManyDamagedShards, + ShardSizeMismatch, + TooManyShards, + SingularElement, + RebuildTooLarge, + /// A repair solve, padded reconstruction or record rebuild exceeds its + /// workspace admission ceiling, which scales with the bytes supplied. + /// This is not a process-RAM quota. + RepairWorkspaceLimitExceeded { + limit: u64, + required: u64, + }, + Io(std::io::ErrorKind), + /// Preserve a structured archive error from workspace admission, a reader or a sink. + TypedIo(Box), +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Cancelled => f.write_str("RAR 5 recovery cancelled"), + Self::BadRecoveryChunk => f.write_str("RAR 5 recovery chunk is invalid"), + Self::OddShardSize => f.write_str("RAR 5 recovery shard size is odd"), + Self::PlanOverflow => f.write_str("RAR 5 recovery plan overflows"), + Self::PrefixExceedsPlan => { + f.write_str("RAR 5 recovery prefix exceeds planned shard capacity") + } + Self::TooManyDamagedShards => { + f.write_str("RAR 5 recovery data cannot repair this many damaged shards") + } + Self::ShardSizeMismatch => f.write_str("RAR 5 recovery shard sizes differ"), + Self::TooManyShards => f.write_str("RAR 5 recovery shard count is invalid"), + Self::SingularElement => f.write_str("RAR 5 recovery matrix is singular"), + Self::RebuildTooLarge => { + f.write_str("RAR 5 recovery record is too large to rebuild in memory") + } + Self::RepairWorkspaceLimitExceeded { limit, required } => write!( + f, + "RAR 5 recovery repair workspace limit {limit} bytes exceeded (requires {required})" + ), + Self::Io(kind) => write!(f, "RAR 5 recovery I/O failed: {kind}"), + Self::TypedIo(error) => std::fmt::Display::fmt(error, f), + } + } +} + +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + Self::TypedIo(error) => Some(error.as_ref()), + _ => None, + } + } +} + +impl From for Error { + fn from(error: std::io::Error) -> Self { + match error.downcast::() { + Ok(error) => Self::TypedIo(Box::new(error)), + Err(error) => Self::Io(error.kind()), + } + } +} + +impl From for Error { + fn from(error: crate::codec::Error) -> Self { + Self::TypedIo(Box::new(error.into())) + } +} + +pub type Result = std::result::Result; diff --git a/arca-rar/vendor/rars/src/recovery/rar5/implementation.rs b/arca-rar/vendor/rars/src/recovery/rar5/implementation.rs new file mode 100644 index 00000000..7e73f50e --- /dev/null +++ b/arca-rar/vendor/rars/src/recovery/rar5/implementation.rs @@ -0,0 +1,4789 @@ +use super::checksum::{crc64_update, CRC64_XZ_INIT}; +#[cfg(test)] +use super::{crc64_rar_state, crc64_xz}; +use super::{Error, Result}; + +use crate::codec::workspace::{Allowance, Budget, Buffer}; +const FIELD_SIZE: usize = 65_535; +const FIELD_MASK: u32 = 0xffff; +const PRIMITIVE_POLYNOMIAL: u32 = 0x1100b; +const ZERO_LOG_SENTINEL: u32 = (FIELD_SIZE * 2) as u32; +const MAX_WINRAR602_DATA_SHARDS: u64 = 200; +const KIB: u64 = 1024; +const RAR5_RECOVERY_CHUNK_FIXED_HEADER_SIZE: u64 = 0x48; +/// Resident parity a record rebuild may allocate. The archive itself is +/// already in memory by the time a rebuild starts, so this bounds the extra. +const MAX_REBUILD_PARITY_BYTES: u64 = 256 * 1024 * 1024; +/// Solve/reconstruction allocations and resident rebuild workspace a repair +/// may admit however small its input. Input and parsed record storage, shared +/// GF tables, final collected archive output, allocator overhead and control +/// storage are outside this bound. +const REPAIR_WORKSPACE_FLOOR_BYTES: u64 = 256 * 1024 * 1024; +/// Genuine geometry needs about twice the bytes it was given: damaged shards +/// are bounded by the parity supplied for them, and padding by the data. Only +/// a record declaring far more than it carries can exceed this multiple. +const REPAIR_WORKSPACE_INPUT_FACTOR: u64 = 4; + +fn repair_workspace_limit(input_bytes: u64) -> u64 { + REPAIR_WORKSPACE_FLOOR_BYTES.max(input_bytes.saturating_mul(REPAIR_WORKSPACE_INPUT_FACTOR)) +} + +fn repair_workspace_sum(parts: &[u64]) -> Result { + parts.iter().try_fold(0u64, |total, &bytes| { + total.checked_add(bytes).ok_or(Error::PlanOverflow) + }) +} + +fn repair_workspace_product(count: u64, width: u64) -> Result { + count.checked_mul(width).ok_or(Error::PlanOverflow) +} + +fn admit_repair_workspace(required: u64, input_bytes: u64) -> Result<()> { + admit_repair_workspace_with_limit(required, repair_workspace_limit(input_bytes)) +} + +fn admit_repair_workspace_with_limit(required: u64, limit: u64) -> Result<()> { + if required > limit { + return Err(Error::RepairWorkspaceLimitExceeded { limit, required }); + } + Ok(()) +} + +/// Count a conservative sum, rather than requiring individual vectors to fit. +/// Inversion holds the original equations, a working copy and the inverse at +/// once. RHS rows, pivot copies and per-word scratch are counted too, together +/// with returned shard buffers and their descriptors. Metadata is small but +/// counted using the maximum growth of the damaged-index vector. +fn repair_solve_workspace_required( + data_count: usize, + damaged_count: usize, + shard_len: usize, + output_bytes: u64, + read_scratch: usize, +) -> Result { + let data_count = data_count as u64; + let damaged_count = damaged_count as u64; + let matrix_cells = repair_workspace_product(damaged_count, damaged_count)?; + let row_descriptors = (6 * std::mem::size_of::>() + + std::mem::size_of::<(std::ops::Range, Vec)>() + + 4 * std::mem::size_of::()) as u64; + let metadata = (std::mem::size_of::>() + + 2 * std::mem::size_of::() + + std::mem::size_of::()) as u64; + repair_workspace_sum(&[ + repair_workspace_product(matrix_cells, 3 * std::mem::size_of::() as u64)?, + // Per-row coefficients against every data column. + repair_workspace_product( + repair_workspace_product(damaged_count, data_count)?, + std::mem::size_of::() as u64, + )?, + repair_workspace_product(damaged_count, shard_len as u64)?, + repair_workspace_product(damaged_count, row_descriptors)?, + repair_workspace_product(data_count, metadata)?, + output_bytes, + read_scratch as u64, + ]) +} + +use crate::progress::ProgressReporter; +use crate::{WriteOperation, WriteProgressEvent}; + +fn shared_gf16() -> &'static Gf16 { + static GF16: std::sync::OnceLock = std::sync::OnceLock::new(); + GF16.get_or_init(Gf16::new) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub struct InlineRecoveryPlan { + pub data_shards: u64, + pub recovery_shards: u64, + pub group_count: u64, + pub header_size: u64, + pub shard_size: u64, +} + +impl InlineRecoveryPlan { + pub fn payload_size(self) -> Result { + self.recovery_shards + .checked_mul(self.shard_size) + .ok_or(Error::PlanOverflow) + } +} + +pub fn plan_inline_recovery( + archive_size: u64, + recovery_percent: u64, +) -> Result { + let pct = recovery_percent.min(100); + let data_shards = if archive_size >= 200 * KIB { + MAX_WINRAR602_DATA_SHARDS + } else { + archive_size.div_ceil(KIB).max(1) + }; + let mut recovery_shards = (2 * pct * data_shards) / 200; + recovery_shards = recovery_shards.min(data_shards); + if recovery_shards == 0 && archive_size < 200 * KIB { + recovery_shards = 1; + } + let mut group_count = archive_size.div_ceil(data_shards); + group_count += group_count & 1; + // data_shards is capped at 200 and group_count is at most + // ceil(size / 200) + 1 for large inputs, so both additions fit at u64::MAX. + let header_size = data_shards * 8 + RAR5_RECOVERY_CHUNK_FIXED_HEADER_SIZE; + let shard_size = header_size + group_count; + + Ok(InlineRecoveryPlan { + data_shards, + recovery_shards, + group_count, + header_size, + shard_size, + }) +} + +pub fn split_prefix_shard_ranges( + prefix_len: usize, + plan: InlineRecoveryPlan, +) -> Result>> { + let data_shards = usize::try_from(plan.data_shards).map_err(|_| Error::PlanOverflow)?; + let group_count = usize::try_from(plan.group_count).map_err(|_| Error::PlanOverflow)?; + let capacity = data_shards + .checked_mul(group_count) + .ok_or(Error::PlanOverflow)?; + if prefix_len > capacity { + return Err(Error::PrefixExceedsPlan); + } + + let mut ranges = Vec::with_capacity(data_shards); + for shard_index in 0..data_shards { + // Every shard index is below data_shards, whose full product with + // group_count was admitted above. + let start = (shard_index * group_count).min(prefix_len); + let end = start.saturating_add(group_count).min(prefix_len); + ranges.push(start..end); + } + Ok(ranges) +} + +pub fn split_prefix_shards(prefix: &[u8], plan: InlineRecoveryPlan) -> Result>> { + let group_count = usize::try_from(plan.group_count).map_err(|_| Error::PlanOverflow)?; + let ranges = split_prefix_shard_ranges(prefix.len(), plan)?; + let mut shards = Vec::with_capacity(ranges.len()); + for range in ranges { + let mut shard = vec![0u8; group_count]; + if range.start < range.end { + shard[..range.end - range.start].copy_from_slice(&prefix[range]); + } + shards.push(shard); + } + Ok(shards) +} + +pub fn encode_inline_recovery_parity( + archive_prefix: &[u8], + recovery_percent: u64, +) -> Result<(InlineRecoveryPlan, Vec>)> { + let plan = plan_inline_recovery(archive_prefix.len() as u64, recovery_percent)?; + let shards = split_prefix_shards(archive_prefix, plan)?; + let shard_refs: Vec<&[u8]> = shards.iter().map(Vec::as_slice).collect(); + // Planning caps recovery_shards at 200. + let parity = encode_parity_shards(&shard_refs, plan.recovery_shards as usize)?; + Ok((plan, parity)) +} + +pub fn build_structural_inline_recovery_data( + archive_prefix: &[u8], + recovery_percent: u64, +) -> Result> { + let mut out = Vec::new(); + build_streamed_inline_recovery( + &mut std::io::Cursor::new(archive_prefix), + archive_prefix.len() as u64, + recovery_percent, + RecoveryMemoryMode::Resident, + None, + &mut out, + None, + 1, + )?; + Ok(out) +} + +/// Builds recovery payload bytes with the geometry of `plan`, so a record +/// rebuilt during repair keeps the shape the archive was written with. +#[cfg(test)] +pub(crate) fn build_inline_recovery_data_for_plan( + archive_prefix: &[u8], + plan: InlineRecoveryPlan, +) -> Result> { + build_inline_recovery_data_for_plan_with_control( + archive_prefix, + plan, + &crate::read_control::ReadControl::default(), + ) +} + +pub(crate) fn build_inline_recovery_data_for_plan_with_control( + archive_prefix: &[u8], + plan: InlineRecoveryPlan, + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + let mut out = Vec::new(); + build_streamed_inline_recovery_for_plan( + &mut control.reader(std::io::Cursor::new(archive_prefix)), + archive_prefix.len() as u64, + plan, + RecoveryMemoryMode::Resident, + None, + &mut out, + None, + 1, + ) + .map_err(|error| { + if matches!( + control.finish::<()>(Err(error.clone().into())), + Err(crate::Error::Cancelled) + ) { + Error::Cancelled + } else { + error + } + })?; + check_repair(control)?; + Ok(out) +} + +/// Read buffer size for streaming recovery passes. Even, so words never +/// straddle a chunk boundary. +pub(crate) const RECOVERY_IO_BLOCK: usize = 256 * 1024; +/// Striped mode never claims more than this, however large the budget is. +#[cfg(any(test, feature = "write"))] +const STRIPE_BUDGET_CAP: u64 = 64 * 1024 * 1024; +/// Below this a stripe pass seeks far more than it reads, so rather than +/// thrash we report what striping would actually cost and let the caller +/// refuse the job. +#[cfg(any(test, feature = "write"))] +const MIN_STRIPE_LEN: u64 = 4 * 1024; + +/// How a recovery pass holds parity while it works. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum RecoveryMemoryMode { + /// Every parity row stays in memory and the body is read straight + /// through. Needs `recovery_shards * group_count` bytes. + Resident, + /// Parity is built one column stripe at a time and spilled to scratch + /// storage, so memory is bounded regardless of archive size. Costs one + /// seek per data shard per stripe. + // Reader repair uses resident parity; writers select bounded stripes. + #[cfg_attr(not(any(test, feature = "write")), expect(dead_code))] + Striped { stripe_len: usize }, +} + +/// Picks a memory mode for `plan` under `memory_limit`, returning the mode and +/// the number of bytes the caller should reserve for it. +#[cfg(any(test, feature = "write"))] +pub(crate) fn choose_recovery_memory_mode( + plan: InlineRecoveryPlan, + memory_limit: u64, +) -> Result<(RecoveryMemoryMode, u64)> { + let parity_bytes = plan + .recovery_shards + .checked_mul(plan.group_count) + .ok_or(Error::PlanOverflow)?; + let resident_bytes = parity_bytes.saturating_add(RECOVERY_IO_BLOCK as u64); + if resident_bytes <= memory_limit { + return Ok((RecoveryMemoryMode::Resident, resident_bytes)); + } + + // One buffer per parity row plus one for the data being read. + let rows = plan.recovery_shards.saturating_add(1).max(1); + let budget = memory_limit.min(STRIPE_BUDGET_CAP); + let mut stripe_len = (budget / rows).min(plan.group_count) & !1; + if stripe_len < MIN_STRIPE_LEN { + stripe_len = MIN_STRIPE_LEN.min(plan.group_count.max(2)); + } + stripe_len = stripe_len.max(2); + // The budget caps this width at 64 MiB on every supported host. + let stripe_len_usize = stripe_len as usize; + let required = rows.saturating_mul(stripe_len); + Ok(( + RecoveryMemoryMode::Striped { + stripe_len: stripe_len_usize, + }, + required, + )) +} + +/// Choose a phase geometry from actual managed capacity as well as the legacy +/// workspace policy. Both parity construction and later chunk framing must fit. +#[cfg(any(test, feature = "write"))] +pub(crate) fn choose_recovery_capacity_mode( + plan: InlineRecoveryPlan, + memory_limit: u64, + allowance: &crate::codec::workspace::Limited, +) -> Result<(RecoveryMemoryMode, u64)> { + use crate::codec::workspace::Limited; + let field = ((FIELD_SIZE * 4 + 1) * 2 + (FIELD_SIZE + 1) * 4) as u64; + let rows = plan.recovery_shards; + let descriptor = std::mem::size_of::>() as u64; + let fixed = field + .saturating_add(rows.saturating_mul(descriptor)) + .saturating_add(rows.saturating_mul(plan.data_shards).saturating_mul(2)) + .saturating_add(plan.data_shards.saturating_mul(8)); + let io = plan.group_count.max(1).min(RECOVERY_IO_BLOCK as u64); + let framing = fixed.saturating_add(io).saturating_add(plan.header_size); + let parity_descriptors = rows.saturating_mul(descriptor); + let resident = framing + .saturating_add(parity_descriptors) + .saturating_add(rows.saturating_mul(plan.group_count)); + let (legacy_mode, legacy_required) = choose_recovery_memory_mode(plan, memory_limit)?; + if matches!(legacy_mode, RecoveryMemoryMode::Resident) && resident <= allowance.available() { + return Ok((RecoveryMemoryMode::Resident, legacy_required)); + } + let stripe_fixed = fixed.saturating_add(parity_descriptors); + let minimum = + framing.max(stripe_fixed.saturating_add(rows.saturating_add(1).saturating_mul(2))); + allowance.check_capacity(minimum)?; + let width = allowance + .available() + .saturating_sub(stripe_fixed) + .min(memory_limit.min(STRIPE_BUDGET_CAP)) + / rows.saturating_add(1); + let stripe_len = width.min(plan.group_count).max(2) & !1; + Ok(( + RecoveryMemoryMode::Striped { + stripe_len: stripe_len as usize, + }, + rows.saturating_add(1).saturating_mul(stripe_len), + )) +} + +/// What a streaming recovery pass produced, so the caller can frame the +/// service block around the payload it just wrote. +#[derive(Debug, Clone, Copy)] +pub(crate) struct StreamedRecoveryOutput { + #[cfg_attr(not(any(test, feature = "write")), expect(dead_code))] + pub(crate) plan: InlineRecoveryPlan, + #[cfg_attr(not(any(test, feature = "write")), expect(dead_code))] + pub(crate) payload_len: u64, + #[cfg_attr(not(any(test, feature = "write")), expect(dead_code))] + pub(crate) payload_crc32: u32, +} + +pub(crate) trait ReadSeek: std::io::Read + std::io::Seek {} +impl ReadSeek for T {} + +pub(crate) trait ReadWriteSeek: std::io::Read + std::io::Write + std::io::Seek {} +impl ReadWriteSeek for T {} + +/// Builds the inline recovery payload for `body` and writes it to `sink`. +/// +/// The body is read exactly once to build parity, then each parity row is +/// framed into a `{RB}` chunk. Output is byte-identical to computing the whole +/// thing in memory; only the working set differs. +/// +/// `parity_scratch` must be supplied for [`RecoveryMemoryMode::Striped`] and +/// is where partial parity lives between stripes. +#[allow(clippy::too_many_arguments)] +pub(crate) fn build_streamed_inline_recovery( + body: &mut dyn ReadSeek, + body_len: u64, + recovery_percent: u64, + mode: RecoveryMemoryMode, + parity_scratch: Option<&mut dyn ReadWriteSeek>, + sink: &mut dyn std::io::Write, + progress: Option>, + pass: usize, +) -> Result { + let plan = plan_inline_recovery(body_len, recovery_percent)?; + build_streamed_inline_recovery_for_plan( + body, + body_len, + plan, + mode, + parity_scratch, + sink, + progress, + pass, + ) +} + +/// Same as [`build_streamed_inline_recovery`] with the geometry supplied +/// rather than derived from a percentage. +/// +/// Repair needs this: WinRAR accepts recovery percentages up to 1000%, which +/// [`plan_inline_recovery`] never produces, so a record rebuilt from surviving +/// chunks has to take its geometry from those chunks. +#[allow(clippy::too_many_arguments)] +pub(crate) fn build_streamed_inline_recovery_for_plan( + body: &mut dyn ReadSeek, + body_len: u64, + plan: InlineRecoveryPlan, + mode: RecoveryMemoryMode, + parity_scratch: Option<&mut dyn ReadWriteSeek>, + sink: &mut dyn std::io::Write, + progress: Option>, + pass: usize, +) -> Result { + streamed_recovery_with_allowance( + body, + body_len, + plan, + mode, + parity_scratch, + sink, + progress, + pass, + &Allowance::default(), + ) +} + +#[allow(clippy::too_many_arguments)] +pub(crate) fn streamed_recovery_with_allowance( + body: &mut dyn ReadSeek, + body_len: u64, + plan: InlineRecoveryPlan, + mode: RecoveryMemoryMode, + parity_scratch: Option<&mut dyn ReadWriteSeek>, + sink: &mut dyn std::io::Write, + progress: Option>, + pass: usize, + allowance: &B, +) -> Result { + check_recovery_cancelled(progress)?; + let payload_len = plan.payload_size()?; + if plan.header_size + != RAR5_RECOVERY_CHUNK_FIXED_HEADER_SIZE + .checked_add(plan.data_shards.checked_mul(8).ok_or(Error::PlanOverflow)?) + .ok_or(Error::PlanOverflow)? + { + return Err(Error::PlanOverflow); + } + if plan.shard_size + != plan + .header_size + .checked_add(plan.group_count) + .ok_or(Error::PlanOverflow)? + { + return Err(Error::PlanOverflow); + } + + // Fail on unrepresentable geometry before doing any work. + let total_size = u32::try_from(plan.shard_size).map_err(|_| Error::PlanOverflow)?; + // shard_size >= header_size was checked above, and shard_size fits u32. + let header_size_u32 = plan.header_size as u32; + let data_shards_u16 = u16::try_from(plan.data_shards).map_err(|_| Error::PlanOverflow)?; + let recovery_shards_u16 = + u16::try_from(plan.recovery_shards).map_err(|_| Error::PlanOverflow)?; + // Both shard counts fit u16; group_count and header_size are bounded by + // the admitted u32 shard_size. All four fit native usize, including i386. + let data_shards = plan.data_shards as usize; + let recovery_shards = plan.recovery_shards as usize; + let group_count = plan.group_count as usize; + let header_size = plan.header_size as usize; + if body_len > plan.group_count.saturating_mul(plan.data_shards) { + return Err(Error::PrefixExceedsPlan); + } + + if let Some(progress) = progress { + progress.report(WriteProgressEvent::OperationStarted { + operation: WriteOperation::Recovery, + total_bytes: Some(payload_len), + total_entries: None, + pass, + }); + } + + // Phase A budget is the parity bytes; phase B adds the chunk headers. + // group_count <= shard_size and payload_size admitted the product of + // recovery_shards and shard_size above. + let encode_units = plan.recovery_shards * plan.group_count; + let report = |completed: u64| { + check_recovery_cancelled(progress)?; + if let Some(progress) = progress { + progress.report(WriteProgressEvent::Advanced { + operation: WriteOperation::Recovery, + completed_bytes: completed.min(payload_len), + total_bytes: payload_len, + pass, + }); + } + check_recovery_cancelled(progress) + }; + + check_recovery_cancelled(progress)?; + let field = RecoveryField::new(allowance)?; + let gf = field.view(); + let matrix = encoder_matrix_with_allowance(data_shards, recovery_shards, &gf, allowance)?; + let mut shard_states = Buffer::filled(data_shards, 0u64, allowance)?; + + let mut rows = match mode { + RecoveryMemoryMode::Resident => { + let parity = encode_parity_resident( + body, + body_len, + &plan, + &matrix, + &mut shard_states, + encode_units, + &report, + &gf, + allowance, + )?; + ParityRows::Resident(parity) + } + RecoveryMemoryMode::Striped { stripe_len } => { + let scratch = parity_scratch.ok_or(Error::PlanOverflow)?; + encode_parity_striped( + body, + body_len, + &plan, + &matrix, + &mut shard_states, + stripe_len, + scratch, + encode_units, + &report, + &gf, + allowance, + )?; + ParityRows::Spooled { + scratch, + group_count: plan.group_count, + } + } + }; + + // Every chunk repeats the CRC state of parity row 0, so it has to be + // known before the first chunk can be framed. + let mut buffer = Buffer::filled(RECOVERY_IO_BLOCK.min(group_count.max(1)), 0u8, allowance)?; + let mut final_state = 0u64; + rows.for_each_chunk(0, &mut buffer, |chunk| { + final_state = crc64_update(chunk, final_state); + })?; + + let chunk_data_extent = body_len + .saturating_sub( + plan.group_count + .saturating_mul(plan.data_shards.saturating_sub(1)), + ) + .min(plan.group_count); + // The extent cannot exceed group_count, already bounded by shard_size. + let chunk_data_extent_u32 = chunk_data_extent as u32; + + let mut payload_crc32 = crate::crc32::Crc32::new(); + let mut written = 0u64; + for shard_index in 0..recovery_shards { + check_recovery_cancelled(progress)?; + let mut header = Buffer::filled(header_size, 0u8, allowance)?; + // The validated header size is exactly 0x48 + 8 * data_shards. + // Writing its fields directly removes impossible short writes to a + // fixed-size in-memory Cursor while retaining the RAR wire layout. + header[0x00..0x04].copy_from_slice(b"{RB}"); + header[0x0c..0x10].copy_from_slice(&total_size.to_le_bytes()); + header[0x10..0x14].copy_from_slice(&header_size_u32.to_le_bytes()); + header[0x14] = 1; + header[0x15] = 1; + header[0x1e..0x22].copy_from_slice(&chunk_data_extent_u32.to_le_bytes()); + header[0x22..0x2a].copy_from_slice(&body_len.to_le_bytes()); + header[0x2a..0x32].copy_from_slice(&plan.group_count.to_le_bytes()); + header[0x32..0x3a].copy_from_slice(&plan.shard_size.to_le_bytes()); + header[0x3a..0x3c].copy_from_slice(&data_shards_u16.to_le_bytes()); + header[0x3c..0x3e].copy_from_slice(&recovery_shards_u16.to_le_bytes()); + header[0x3e..0x40].copy_from_slice(&(shard_index as u16).to_le_bytes()); + for (index, &state) in shard_states.iter().enumerate() { + header[0x40 + index * 8..0x48 + index * 8].copy_from_slice(&state.to_le_bytes()); + } + header[header_size - 8..].copy_from_slice(&final_state.to_le_bytes()); + // The chunk CRC covers everything from 0x0c onwards, so compute it + // over the header and the parity row before either is emitted. + let mut chunk_crc = crc64_update(&header[0x0c..], CRC64_XZ_INIT); + rows.for_each_chunk(shard_index, &mut buffer, |chunk| { + chunk_crc = crc64_update(chunk, chunk_crc); + })?; + header[0x04..0x0c].copy_from_slice(&(chunk_crc ^ CRC64_XZ_INIT).to_le_bytes()); + + sink.write_all(&header)?; + payload_crc32.update(&header); + written += header.len() as u64; + + let mut sink_error = None; + rows.for_each_chunk(shard_index, &mut buffer, |chunk| { + if sink_error.is_some() { + return; + } + if let Err(error) = sink.write_all(chunk) { + sink_error = Some(error); + return; + } + payload_crc32.update(chunk); + })?; + if let Some(error) = sink_error { + return Err(error.into()); + } + written += plan.group_count; + + report(encode_units + (shard_index as u64 + 1) * plan.header_size)?; + } + + debug_assert_eq!(written, payload_len); + if let Some(progress) = progress { + progress.report(WriteProgressEvent::OperationFinished { + operation: WriteOperation::Recovery, + total_bytes: Some(payload_len), + total_entries: None, + pass, + }); + } + + Ok(StreamedRecoveryOutput { + plan, + payload_len, + payload_crc32: payload_crc32.finish(), + }) +} + +fn check_recovery_cancelled(progress: Option>) -> Result<()> { + if progress.is_some_and(ProgressReporter::is_cancelled) { + return Err(Error::Cancelled); + } + Ok(()) +} + +fn rows_with_allowance( + rows: usize, + width: usize, + allowance: &B, +) -> Result, B>> { + let mut out = Buffer::with_capacity(rows, allowance)?; + for _ in 0..rows { + out.push_admitted(Buffer::filled(width, 0u8, allowance)?); + } + Ok(out) +} + +enum RecoveryField { + Shared(&'static Gf16), + Owned { + exp: Buffer, + log: Buffer, + }, +} +impl RecoveryField { + fn new(allowance: &B) -> Result { + if !B::LIMITED { + return Ok(Self::Shared(shared_gf16())); + } + let mut exp = Buffer::filled(FIELD_SIZE * 4 + 1, 0u16, allowance)?; + let mut log = Buffer::filled(FIELD_SIZE + 1, 0u32, allowance)?; + initialize_field(&mut exp, &mut log); + Ok(Self::Owned { exp, log }) + } + fn view(&self) -> GfView<'_> { + match self { + Self::Shared(gf) => gf.view(), + Self::Owned { exp, log } => GfView { exp, log }, + } + } +} + +fn encoder_matrix_with_allowance( + data_shards: usize, + recovery_shards: usize, + gf: &GfView<'_>, + allowance: &B, +) -> Result, B>> { + if data_shards == 0 + || recovery_shards == 0 + || data_shards + .checked_add(recovery_shards) + .is_none_or(|sum| sum > FIELD_SIZE) + { + return Err(Error::TooManyShards); + } + let mut matrix = Buffer::with_capacity(recovery_shards, allowance)?; + for i in 0..recovery_shards { + let mut row = Buffer::filled(data_shards, 0u16, allowance)?; + for (j, cell) in row.iter_mut().enumerate() { + *cell = gf.inv(((i + data_shards) ^ j) as u16)?; + } + matrix.push_admitted(row); + } + Ok(matrix) +} + +/// Parity rows, wherever they happen to live. +enum ParityRows<'a, B: Budget> { + Resident(Buffer, B>), + Spooled { + scratch: &'a mut dyn ReadWriteSeek, + group_count: u64, + }, +} + +impl ParityRows<'_, B> { + /// Feeds row `index` to `visit` in buffer-sized pieces. + fn for_each_chunk( + &mut self, + index: usize, + buffer: &mut [u8], + mut visit: impl FnMut(&[u8]), + ) -> Result<()> { + match self { + Self::Resident(rows) => { + let row = &rows[index]; + if !row.is_empty() { + visit(row); + } + Ok(()) + } + Self::Spooled { + scratch, + group_count, + } => { + // The admitted payload contains every recovery row, and the + // caller supplies only row zero or an in-range shard index. + let start = index as u64 * *group_count; + scratch.seek(std::io::SeekFrom::Start(start))?; + let mut remaining = *group_count; + while remaining != 0 { + let want = remaining.min(buffer.len() as u64) as usize; + scratch.read_exact(&mut buffer[..want])?; + visit(&buffer[..want]); + remaining -= want as u64; + } + Ok(()) + } + } + } +} + +/// Accumulates `coefficient * source` into `destination` over GF(2^16). +/// +/// A trailing odd byte is treated as the low half of a word whose high half is +/// the zero padding every shard carries. +fn accumulate_scaled(destination: &mut [u8], source: &[u8], coefficient: u16, gf: &GfView<'_>) { + let words = source.len() / 2; + for word in 0..words { + let offset = word * 2; + let value = u16::from_le_bytes([source[offset], source[offset + 1]]); + let scaled = gf.mul(coefficient, value); + if scaled == 0 { + continue; + } + let current = u16::from_le_bytes([destination[offset], destination[offset + 1]]); + destination[offset..offset + 2].copy_from_slice(&(current ^ scaled).to_le_bytes()); + } + if !source.len().is_multiple_of(2) { + let offset = words * 2; + let value = u16::from_le_bytes([source[offset], 0]); + let scaled = gf.mul(coefficient, value); + if scaled != 0 { + let current = u16::from_le_bytes([destination[offset], destination[offset + 1]]); + destination[offset..offset + 2].copy_from_slice(&(current ^ scaled).to_le_bytes()); + } + } +} + +/// Single forward pass over the body, holding every parity row in memory. +#[allow(clippy::too_many_arguments)] +fn encode_parity_resident( + body: &mut dyn ReadSeek, + body_len: u64, + plan: &InlineRecoveryPlan, + matrix: &[Buffer], + shard_states: &mut [u64], + encode_units: u64, + report: &dyn Fn(u64) -> Result<()>, + gf: &GfView<'_>, + allowance: &B, +) -> Result, B>> { + // The streaming entry point admitted these as native-size values. + let group_count = plan.group_count as usize; + let recovery_shards = plan.recovery_shards as usize; + let mut parity = rows_with_allowance(recovery_shards, group_count, allowance)?; + if group_count == 0 || body_len == 0 { + return Ok(parity); + } + + let mut buffer = Buffer::filled(RECOVERY_IO_BLOCK.min(group_count), 0u8, allowance)?; + body.seek(std::io::SeekFrom::Start(0))?; + + let mut consumed = 0u64; + for (shard_index, state) in shard_states.iter_mut().enumerate() { + // The wire limits admit at most u16::MAX data shards of u32-sized + // groups, so every data-shard offset fits u64. + let shard_start = shard_index as u64 * plan.group_count; + if shard_start >= body_len { + break; + } + let shard_bytes = plan.group_count.min(body_len - shard_start); + + let mut offset = 0u64; + while offset < shard_bytes { + let want = (shard_bytes - offset).min(buffer.len() as u64) as usize; + body.read_exact(&mut buffer[..want])?; + *state = crc64_update(&buffer[..want], *state); + + let destination_offset = offset as usize; + for (row, parity_row) in matrix.iter().zip(parity.iter_mut()) { + accumulate_scaled( + &mut parity_row[destination_offset..], + &buffer[..want], + row[shard_index], + gf, + ); + } + + offset += want as u64; + consumed += want as u64; + report(scaled_progress(consumed, body_len, encode_units))?; + } + } + + Ok(parity) +} + +/// Column-stripe pass: bounded memory, one seek per data shard per stripe, +/// and the body still read exactly once in total. +#[allow(clippy::too_many_arguments)] +fn encode_parity_striped( + body: &mut dyn ReadSeek, + body_len: u64, + plan: &InlineRecoveryPlan, + matrix: &[Buffer], + shard_states: &mut [u64], + stripe_len: usize, + scratch: &mut dyn ReadWriteSeek, + encode_units: u64, + report: &dyn Fn(u64) -> Result<()>, + gf: &GfView<'_>, + allowance: &B, +) -> Result<()> { + let recovery_shards = plan.recovery_shards as usize; + if plan.group_count == 0 { + return Ok(()); + } + let stripe_len = stripe_len.max(2); + let mut stripe = rows_with_allowance(recovery_shards, stripe_len, allowance)?; + let mut buffer = Buffer::filled(stripe_len, 0u8, allowance)?; + let mut consumed = 0u64; + + let mut column = 0u64; + while column < plan.group_count { + let width = (plan.group_count - column).min(stripe_len as u64); + let width_usize = width as usize; + for row in stripe.iter_mut() { + row[..width_usize].fill(0); + } + + for (shard_index, state) in shard_states.iter_mut().enumerate() { + let shard_start = shard_index as u64 * plan.group_count; + let shard_bytes = plan.group_count.min(body_len.saturating_sub(shard_start)); + if column >= shard_bytes { + continue; + } + let span = width.min(shard_bytes - column); + let span_usize = span as usize; + + body.seek(std::io::SeekFrom::Start(shard_start + column))?; + body.read_exact(&mut buffer[..span_usize])?; + *state = crc64_update(&buffer[..span_usize], *state); + + for (row, stripe_row) in matrix.iter().zip(stripe.iter_mut()) { + accumulate_scaled(stripe_row, &buffer[..span_usize], row[shard_index], gf); + } + + consumed += span; + report(scaled_progress(consumed, body_len, encode_units))?; + } + + for (shard_index, stripe_row) in stripe.iter().enumerate() { + // position is within an admitted row of the complete payload. + let position = shard_index as u64 * plan.group_count + column; + scratch.seek(std::io::SeekFrom::Start(position))?; + scratch.write_all(&stripe_row[..width_usize])?; + } + + column += width; + } + + Ok(()) +} + +fn scaled_progress(consumed: u64, total: u64, units: u64) -> u64 { + // Both callers report only after consuming body bytes, so total is nonzero. + ((consumed as u128 * units as u128) / total as u128) as u64 +} + +#[derive(Debug, Clone)] +struct InlineRecoveryChunk { + plan: InlineRecoveryPlan, + protected_size: u64, + shard_index: usize, + data_shard_states: Vec, + parity: Vec, +} + +#[derive(Debug, Clone)] +struct FoundInlineRecoveryChunk { + offset: usize, + chunk: InlineRecoveryChunk, +} + +pub fn repair_inline_recovery_prefix( + archive_prefix: &[u8], + recovery_data: &[u8], +) -> Result> { + repair_inline_recovery_prefix_with_control( + archive_prefix, + recovery_data, + &crate::read_control::ReadControl::default(), + ) +} + +pub(crate) fn repair_inline_recovery_prefix_with_control( + archive_prefix: &[u8], + recovery_data: &[u8], + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + // The range path keeps empty shards and zero padding virtual. In particular, + // healthy prefixes must not allocate data_shards * group_count bytes merely + // because a recovery header describes that much capacity. + let repaired_shards = repair_inline_recovery_prefix_shards_with_control( + archive_prefix.len(), + recovery_data, + |range| Ok(archive_prefix[range].to_vec()), + control, + )?; + check_repair(control)?; + let mut repaired = archive_prefix.to_vec(); + for (range, shard) in repaired_shards { + check_repair(control)?; + repaired[range].copy_from_slice(&shard); + } + Ok(repaired) +} + +/// Repair damaged RAR5 inline-recovery data shards without materializing the +/// whole protected prefix. +/// +/// `read_range` receives byte ranges relative to the protected prefix and must +/// return the current bytes for each requested range. The returned pairs contain +/// only the damaged prefix ranges that need to be written back. +/// +/// An admission ceiling of four times `protected_size` plus the recovery data, +/// and at least 256 MiB, covers solve matrices and their working +/// copies, row descriptors, RHS/pivot/read scratch and returned repaired shard +/// buffers. Input and parsed recovery records, shared field tables, final +/// collected archive output, allocator overhead and control storage are excluded. +/// This is not a process-RAM limit. Oversized solves return +/// [`Error::RepairWorkspaceLimitExceeded`] before allocating their matrices. +/// Requested range scratch is admitted before discovery calls `read_range`; +/// additional allocations made by the caller's callback are outside the ceiling. +pub fn repair_inline_recovery_prefix_shards( + protected_size: usize, + recovery_data: &[u8], + read_range: F, +) -> Result, Vec)>> +where + F: FnMut(std::ops::Range) -> Result>, +{ + repair_inline_recovery_prefix_shards_with_control( + protected_size, + recovery_data, + read_range, + &crate::read_control::ReadControl::default(), + ) +} + +pub(crate) fn repair_inline_recovery_prefix_shards_with_control( + protected_size: usize, + recovery_data: &[u8], + read_range: F, + control: &crate::read_control::ReadControl, +) -> Result, Vec)>> +where + F: FnMut(std::ops::Range) -> Result>, +{ + repair_inline_recovery_prefix_shards_with_workspace_limit( + protected_size, + recovery_data, + read_range, + control, + repair_workspace_limit((protected_size as u64).saturating_add(recovery_data.len() as u64)), + ) +} + +fn repair_inline_recovery_prefix_shards_with_workspace_limit( + protected_size: usize, + recovery_data: &[u8], + mut read_range: F, + control: &crate::read_control::ReadControl, + workspace_limit: u64, +) -> Result, Vec)>> +where + F: FnMut(std::ops::Range) -> Result>, +{ + let mut poller = control.poller(); + check_repair(control)?; + let chunks = parse_available_inline_recovery_chunks_with_control(recovery_data, control)?; + let first = chunks.first().ok_or(Error::BadRecoveryChunk)?; + if first.protected_size != protected_size as u64 { + return Err(Error::BadRecoveryChunk); + } + if chunks.iter().any(|chunk| { + chunk.plan != first.plan + || chunk.protected_size != first.protected_size + || chunk.data_shard_states != first.data_shard_states + }) { + return Err(Error::BadRecoveryChunk); + } + + let plan = first.plan; + let shard_len = usize::try_from(plan.group_count).map_err(|_| Error::PlanOverflow)?; + let shard_ranges = split_prefix_shard_ranges(protected_size, plan)?; + // Admit the largest requested range before CRC discovery asks the caller + // to materialize it. Arbitrary additional callback allocations are outside + // our policy; the requested byte range is bounded here. + admit_repair_workspace_with_limit( + repair_solve_workspace_required( + shard_ranges.len(), + 0, + shard_len, + 0, + shard_len.min(protected_size), + )?, + workspace_limit, + )?; + let mut damaged = Vec::new(); + for (index, range) in shard_ranges.iter().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + let shard = read_range(range.clone())?; + if shard.len() != range.len() { + return Err(Error::ShardSizeMismatch); + } + if repair_crc(&shard, 0, control)? != first.data_shard_states[index] { + damaged.push(index); + } + } + if damaged.is_empty() { + return Ok(Vec::new()); + } + if damaged.len() > chunks.len() { + return Err(Error::TooManyDamagedShards); + } + + let output_bytes = damaged.iter().try_fold(0u64, |bytes, &index| { + bytes + .checked_add(shard_ranges[index].len() as u64) + .ok_or(Error::PlanOverflow) + })?; + admit_repair_workspace_with_limit( + repair_solve_workspace_required( + shard_ranges.len(), + damaged.len(), + shard_len, + output_bytes, + shard_len.min(protected_size), + )?, + workspace_limit, + )?; + + let recovery_rows: Vec<_> = chunks[..damaged.len()] + .iter() + .map(|chunk| (chunk.shard_index, chunk.parity.as_slice())) + .collect(); + let gf = shared_gf16(); + // Only damaged columns and available rows participate in the solve. A + // high row index is an index, not a request to allocate preceding rows. + let equations = recovery_equations(gf, shard_ranges.len(), &damaged, &recovery_rows, control)?; + let inverse = invert_linear_system_matrix_with_control(gf, &equations, control)?; + let word_count = shard_len / 2; + let mut rhs_by_row = Vec::with_capacity(recovery_rows.len()); + for (_, parity) in &recovery_rows { + let mut rhs = Vec::with_capacity(word_count); + for word in parity.as_chunks::<2>().0 { + poller.check(0).map_err(|_| Error::Cancelled)?; + rhs.push(u16::from_le_bytes([word[0], word[1]])); + } + rhs_by_row.push(rhs); + } + let mut damaged_lookup = vec![false; shard_ranges.len()]; + for &index in &damaged { + damaged_lookup[index] = true; + } + + for (data_index, range) in shard_ranges.iter().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + if damaged_lookup[data_index] || range.is_empty() { + continue; + } + let shard = read_range(range.clone())?; + if shard.len() != range.len() { + return Err(Error::ShardSizeMismatch); + } + for (row_index, rhs) in rhs_by_row.iter_mut().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + let coeff = recovery_coefficient( + gf, + shard_ranges.len(), + recovery_rows[row_index].0, + data_index, + )?; + // Omitted bytes are zero padding, so they contribute no RHS terms. + for (word_index, word) in shard.chunks(2).enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + let data_symbol = u16::from_le_bytes([word[0], word.get(1).copied().unwrap_or(0)]); + rhs[word_index] ^= gf.mul(coeff, data_symbol); + } + } + } + + let mut repaired = damaged + .iter() + .map(|&index| vec![0; shard_ranges[index].len()]) + .collect::>(); + for word_index in 0..word_count { + poller.check(0).map_err(|_| Error::Cancelled)?; + let rhs = rhs_by_row + .iter() + .map(|row| row[word_index]) + .collect::>(); + let solved = apply_inverse_matrix_with_control(gf, &inverse, &rhs, control)?; + for (output, &symbol) in repaired.iter_mut().zip(&solved) { + poller.check(0).map_err(|_| Error::Cancelled)?; + let byte_offset = word_index * 2; + if byte_offset < output.len() { + let bytes = symbol.to_le_bytes(); + let take = (output.len() - byte_offset).min(2); + output[byte_offset..byte_offset + take].copy_from_slice(&bytes[..take]); + } + } + } + + Ok(damaged + .into_iter() + .zip(repaired) + .map(|(index, data)| (shard_ranges[index].clone(), data)) + .collect()) +} + +/// What a raw inline-recovery repair knows beyond the archive bytes. +#[derive(Debug, Clone, Default)] +pub(crate) struct InlineRepairOptions<'a> { + pub control: crate::read_control::ReadControl, + /// Password for header-encrypted archives, needed to frame a replacement + /// end-of-archive header. + pub password: Option<&'a [u8]>, + /// Byte range holding this archive's recovery record, when a parsed + /// archive already said where it lives. + pub record_range: Option>, +} + +/// Repair an archive's protected prefix and, when possible, incomplete inline +/// recovery records. Solves use the admission ceiling documented on +/// [`repair_inline_recovery_prefix_shards`]. Record rebuilding checks a separate +/// use of that ceiling, scaled by `input`, for its full encoder matrix, +/// resident parity, CRC/header and I/O scratch, row descriptors and growing +/// intermediate framed-record buffer. Input/parsed records, shared field +/// tables, final archive output and allocator/control overhead are excluded. +/// If rebuilding is too large, the repaired prefix is returned while the +/// incomplete recovery record is retained. +pub fn repair_inline_recovery_archive(input: &[u8]) -> Result> { + Ok(repair_inline_recovery_archive_with_report(input, &InlineRepairOptions::default())?.0) +} + +pub(crate) fn repair_inline_recovery_archive_with_report( + input: &[u8], + options: &InlineRepairOptions<'_>, +) -> Result<(Vec, crate::RecoveryRepairReport)> { + let control = &options.control; + check_repair(control)?; + let chunks = select_record_chunks( + find_inline_recovery_chunks_with_control(input, control)?, + options.record_range.clone(), + )?; + let first = chunks.first().ok_or(Error::BadRecoveryChunk)?; + let plan = first.chunk.plan; + let protected_size = + usize::try_from(first.chunk.protected_size).map_err(|_| Error::PlanOverflow)?; + if protected_size > input.len() { + return Err(Error::BadRecoveryChunk); + } + let mut recovery_data = Vec::with_capacity( + chunks + .iter() + .map(|found| found.chunk.plan.shard_size as usize) + .sum(), + ); + for found in &chunks { + check_repair(control)?; + append_inline_recovery_chunk(input, found, &mut recovery_data); + } + let original_prefix = &input[..protected_size]; + let repaired_prefix = + repair_inline_recovery_prefix_with_control(original_prefix, &recovery_data, control)?; + let data_repaired = repaired_prefix != original_prefix; + let mut indices = chunks + .iter() + .map(|found| found.chunk.shard_index) + .collect::>(); + indices.sort_unstable(); + indices.dedup(); + let available = indices.len() as u64; + let expected = plan.recovery_shards; + let record_start = chunks + .iter() + .filter_map(|found| { + let distance = found + .chunk + .shard_index + .checked_mul(plan.shard_size as usize)?; + found.offset.checked_sub(distance) + }) + .min() + .ok_or(Error::BadRecoveryChunk)?; + if record_start < protected_size { + return Err(Error::BadRecoveryChunk); + } + let payload_len = usize::try_from(plan.payload_size()?).map_err(|_| Error::PlanOverflow)?; + let record_end = record_start + .checked_add(payload_len) + .ok_or(Error::PlanOverflow)?; + + // Splicing the repaired prefix back in is the floor. Whatever happens to + // the record itself, the caller still gets the data repair. + let prefix_only = || { + let mut out = input.to_vec(); + out[..protected_size].copy_from_slice(&repaired_prefix); + out + }; + let record_complete = available == expected && record_end <= input.len(); + let mut recovery_record_rebuilt = false; + let mut repaired = if record_complete { + prefix_only() + } else { + match rebuild_inline_recovery_record_with_control( + input, + &repaired_prefix, + record_start..record_end, + plan, + control, + ) { + Ok(rebuilt) => { + recovery_record_rebuilt = true; + rebuilt + } + Err(Error::Cancelled) => return Err(Error::Cancelled), + Err(_) => prefix_only(), + } + }; + + // An archive that stops where its recovery record does lost its + // end-of-archive header along with whatever followed. + let mut end_record_rebuilt = false; + if (record_complete || recovery_record_rebuilt) && repaired.len() <= record_end { + let mut read_options = crate::ArchiveReadOptions::with_optional_password(options.password); + read_options.cancellation = control.cancellation(); + let end = crate::rar50::recovery_end_header(&repaired, read_options) + .map_err(map_recovery_end_error)?; + repaired.extend_from_slice(&end); + end_record_rebuilt = true; + } + let report = crate::RecoveryRepairReport { + changed: repaired != input, + data_repaired, + recovery_record_rebuilt, + end_record_rebuilt, + available_recovery_shards: Some(available), + expected_recovery_shards: Some(expected), + }; + check_repair(control)?; + Ok((repaired, report)) +} + +fn map_recovery_end_error(error: crate::Error) -> Error { + if error.kind() == crate::ErrorKind::Cancelled { + Error::Cancelled + } else { + Error::BadRecoveryChunk + } +} + +/// Rebuilds the whole recovery record from the repaired prefix, replacing +/// `record` in the archive. +/// +/// Admission counts the full encoder matrix, resident parity and the framed +/// record, including a growing Vec's old and replacement buffers. Limiting +/// parity alone leaves repeated headers and coefficients unbounded when a +/// small available chunk declares thousands of missing recovery rows. +/// Refusal costs the caller the rebuild and keeps the data repair. +fn rebuild_inline_recovery_record_with_control( + input: &[u8], + repaired_prefix: &[u8], + record: std::ops::Range, + plan: InlineRecoveryPlan, + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + let parity_bytes = plan + .recovery_shards + .checked_mul(plan.group_count) + .ok_or(Error::PlanOverflow)?; + if parity_bytes > MAX_REBUILD_PARITY_BYTES { + return Err(Error::RebuildTooLarge); + } + let matrix_cells = repair_workspace_product(plan.data_shards, plan.recovery_shards)?; + let row_descriptors = 2 * std::mem::size_of::>() as u64; + admit_repair_workspace( + repair_workspace_sum(&[ + repair_workspace_product(matrix_cells, std::mem::size_of::() as u64)?, + parity_bytes, + repair_workspace_product(plan.recovery_shards, row_descriptors)?, + repair_workspace_product(plan.data_shards, std::mem::size_of::() as u64)?, + // At most twice the framed record capacity plus its previous buffer + // while Vec growth replaces it. This is deliberately conservative. + repair_workspace_product(plan.payload_size()?, 3)?, + plan.group_count.max(1).min(RECOVERY_IO_BLOCK as u64), + plan.header_size, + ])?, + input.len() as u64, + )?; + let rebuilt = build_inline_recovery_data_for_plan_with_control(repaired_prefix, plan, control)?; + if rebuilt.len() != record.len() { + return Err(Error::BadRecoveryChunk); + } + // record.start came from a parsed chunk within input, and the prefix + // boundary was checked above. + let gap = &input[repaired_prefix.len()..record.start]; + let mut out = Vec::with_capacity(input.len().max(record.end)); + out.extend_from_slice(repaired_prefix); + out.extend_from_slice(gap); + out.extend_from_slice(&rebuilt); + if let Some(tail) = input.get(record.end..) { + out.extend_from_slice(tail); + } + Ok(out) +} + +/// Narrows found chunks down to the ones belonging to this archive's own +/// recovery record. +/// +/// A stored archive nested inside this one carries `{RB}` chunks that parse +/// just as cleanly as ours, and taking the first one found picks the nested +/// record whenever it sits earlier in the file. This archive's record always +/// protects more bytes than anything stored inside it, so the largest +/// protected size wins. `record_range` settles it outright when a parsed +/// archive already said where the record is. +fn select_record_chunks( + chunks: Vec, + record_range: Option>, +) -> Result> { + let mut chunks = match record_range { + Some(range) => chunks + .into_iter() + .filter(|found| range.contains(&found.offset)) + .collect(), + None => chunks, + }; + let protected_size = chunks + .iter() + .map(|found| found.chunk.protected_size) + .max() + .ok_or(Error::BadRecoveryChunk)?; + chunks.retain(|found| found.chunk.protected_size == protected_size); + Ok(chunks) +} + +fn find_inline_recovery_chunks_with_control( + input: &[u8], + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + let mut chunks = Vec::new(); + let mut offset = 0usize; + while let Some(relative) = repair_marker(&input[offset..], control)? { + let start = offset + relative; + if let Ok(chunk) = parse_inline_recovery_chunk_with_control(&input[start..], control) { + // Parsing already checked that this entire declared shard fits. + let shard_size = chunk.plan.shard_size as usize; + chunks.push(FoundInlineRecoveryChunk { + offset: start, + chunk, + }); + offset = start + shard_size; + continue; + } + check_repair(control)?; + offset = start + 1; + } + if chunks.is_empty() { + return Err(Error::BadRecoveryChunk); + } + Ok(chunks) +} + +fn find_recovery_marker(input: &[u8]) -> Option { + let mut offset = 0usize; + while offset + 4 <= input.len() { + let relative = input[offset..].iter().position(|&byte| byte == b'{')?; + offset += relative; + if input.get(offset..offset + 4) == Some(b"{RB}") { + return Some(offset); + } + offset += 1; + } + None +} + +fn append_inline_recovery_chunk(input: &[u8], found: &FoundInlineRecoveryChunk, out: &mut Vec) { + // The scanner parsed this complete u32-sized shard from input[start..]. + let shard_size = found.chunk.plan.shard_size as usize; + let start = found.offset; + let end = start + shard_size; + out.extend_from_slice(&input[start..end]); +} + +/// Reconstruct equally padded data shards from available recovery rows. +/// +/// Known shard lengths, missing-row availability and field dimensions are +/// validated before output allocation. An admission ceiling of four times the +/// supplied shard bytes, and at least 256 MiB, covers padded output, solve +/// matrices/copies and row/vector scratch. The caller's input, shared field +/// tables, allocator and control overhead are excluded; this is not a +/// process-RAM limit. Oversized reconstruction returns +/// [`Error::RepairWorkspaceLimitExceeded`]. +pub fn reconstruct_data_shards( + data_shards: &[Option<&[u8]>], + recovery_shards: &[(usize, &[u8])], +) -> Result>> { + if data_shards.is_empty() { + return Err(Error::TooManyShards); + } + let shard_len = recovery_shards + .first() + .map(|(_, shard)| shard.len()) + .or_else(|| data_shards.iter().flatten().map(|shard| shard.len()).max()) + .ok_or(Error::TooManyDamagedShards)?; + if !shard_len.is_multiple_of(2) { + return Err(Error::OddShardSize); + } + if recovery_shards + .iter() + .any(|(_, shard)| shard.len() != shard_len) + { + return Err(Error::ShardSizeMismatch); + } + if data_shards + .iter() + .flatten() + .any(|shard| shard.len() > shard_len) + { + return Err(Error::ShardSizeMismatch); + } + let missing_count = data_shards.iter().filter(|shard| shard.is_none()).count(); + if missing_count > recovery_shards.len() { + return Err(Error::TooManyDamagedShards); + } + if data_shards.len() > FIELD_SIZE { + return Err(Error::TooManyShards); + } + // Unused recovery rows need no field coefficients. Validate each selected + // row without initializing the field or allocating any padded output. + if recovery_shards[..missing_count].iter().any(|&(row, _)| { + data_shards + .len() + .checked_add(row) + .is_none_or(|position| position >= FIELD_SIZE) + }) { + return Err(Error::TooManyShards); + } + let padded_bytes = repair_workspace_product(data_shards.len() as u64, shard_len as u64)?; + let input_bytes = data_shards + .iter() + .flatten() + .map(|shard| shard.len()) + .chain(recovery_shards.iter().map(|(_, shard)| shard.len())) + .fold(0u64, |total, len| total.saturating_add(len as u64)); + admit_repair_workspace( + repair_solve_workspace_required( + data_shards.len(), + missing_count, + shard_len, + padded_bytes, + 0, + )?, + input_bytes, + )?; + + let missing = data_shards + .iter() + .enumerate() + .filter_map(|(index, shard)| shard.is_none().then_some(index)) + .collect::>(); + let mut out = Vec::with_capacity(data_shards.len()); + for shard in data_shards { + let mut padded = vec![0; shard_len]; + if let Some(shard) = shard { + padded[..shard.len()].copy_from_slice(shard); + } + out.push(padded); + } + if missing.is_empty() { + return Ok(out); + } + recover_damaged_shards(&mut out, &missing, &recovery_shards[..missing.len()])?; + Ok(out) +} + +fn parse_available_inline_recovery_chunks_with_control( + recovery_data: &[u8], + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + Ok( + find_inline_recovery_chunks_with_control(recovery_data, control)? + .into_iter() + .map(|found| found.chunk) + .collect(), + ) +} + +pub(crate) fn inline_recovery_chunk_counts_with_control( + recovery_data: &[u8], + control: &crate::read_control::ReadControl, +) -> Result<(u64, u64)> { + check_repair(control)?; + let chunks = parse_available_inline_recovery_chunks_with_control(recovery_data, control)?; + let first = chunks.first().ok_or(Error::BadRecoveryChunk)?; + let expected = first.plan.recovery_shards; + let mut indices = chunks + .iter() + .map(|chunk| chunk.shard_index) + .collect::>(); + indices.sort_unstable(); + indices.dedup(); + Ok((indices.len() as u64, expected)) +} + +fn parse_inline_recovery_chunk_with_control( + input: &[u8], + control: &crate::read_control::ReadControl, +) -> Result { + check_repair(control)?; + if input.len() < 0x48 || &input[..4] != b"{RB}" { + return Err(Error::BadRecoveryChunk); + } + // The fixed 0x48-byte prefix is present, so all fixed fields fit. + let total_size = u32::from_le_bytes(input[0x0c..0x10].try_into().unwrap()) as u64; + let header_size = u32::from_le_bytes(input[0x10..0x14].try_into().unwrap()) as u64; + if header_size < RAR5_RECOVERY_CHUNK_FIXED_HEADER_SIZE || header_size > total_size { + return Err(Error::BadRecoveryChunk); + } + // Both values came from u32 fields, which fit usize on supported targets. + let total_size_usize = total_size as usize; + let header_size_usize = header_size as usize; + if input.len() < total_size_usize { + return Err(Error::BadRecoveryChunk); + } + let expected_crc = u64::from_le_bytes(input[0x04..0x0c].try_into().unwrap()); + let actual_crc = !repair_crc(&input[0x0c..total_size_usize], CRC64_XZ_INIT, control)?; + if actual_crc != expected_crc { + return Err(Error::BadRecoveryChunk); + } + if input[0x14] != 1 || input[0x15] != 1 { + return Err(Error::BadRecoveryChunk); + } + + let protected_size = u64::from_le_bytes(input[0x22..0x2a].try_into().unwrap()); + let group_count = u64::from_le_bytes(input[0x2a..0x32].try_into().unwrap()); + if !group_count.is_multiple_of(2) { + return Err(Error::BadRecoveryChunk); + } + let shard_size = u64::from_le_bytes(input[0x32..0x3a].try_into().unwrap()); + let data_shards = u16::from_le_bytes(input[0x3a..0x3c].try_into().unwrap()) as u64; + let recovery_shards = u16::from_le_bytes(input[0x3c..0x3e].try_into().unwrap()) as u64; + if data_shards == 0 || recovery_shards == 0 || data_shards + recovery_shards > FIELD_SIZE as u64 + { + return Err(Error::BadRecoveryChunk); + } + let shard_index = u16::from_le_bytes(input[0x3e..0x40].try_into().unwrap()) as usize; + let plan = InlineRecoveryPlan { + data_shards, + recovery_shards, + group_count, + header_size, + shard_size, + }; + if shard_size != total_size + || shard_index >= recovery_shards as usize + || header_size_usize != 0x48 + data_shards as usize * 8 + { + return Err(Error::BadRecoveryChunk); + } + + let mut data_shard_states = Vec::with_capacity(data_shards as usize); + let mut pos = 0x40; + for _ in 0..data_shards { + check_repair(control)?; + data_shard_states.push(u64::from_le_bytes(input[pos..pos + 8].try_into().unwrap())); + pos += 8; + } + let _final_state = u64::from_le_bytes(input[pos..pos + 8].try_into().unwrap()); + let parity = input[header_size_usize..total_size_usize].to_vec(); + if parity.len() as u64 != group_count { + return Err(Error::BadRecoveryChunk); + } + Ok(InlineRecoveryChunk { + plan, + protected_size, + shard_index, + data_shard_states, + parity, + }) +} + +fn recover_damaged_shards( + data_shards: &mut [Vec], + damaged: &[usize], + recovery_shards: &[(usize, &[u8])], +) -> Result<()> { + recover_damaged_shards_with_control( + data_shards, + damaged, + recovery_shards, + &crate::read_control::ReadControl::default(), + ) +} + +fn recover_damaged_shards_with_control( + data_shards: &mut [Vec], + damaged: &[usize], + recovery_shards: &[(usize, &[u8])], + control: &crate::read_control::ReadControl, +) -> Result<()> { + let mut poller = control.poller(); + check_repair(control)?; + let data_count = data_shards.len(); + let mut damaged_lookup = vec![false; data_count]; + for &data_index in damaged { + poller.check(0).map_err(|_| Error::Cancelled)?; + damaged_lookup[data_index] = true; + } + + if recovery_shards.is_empty() { + return Err(Error::TooManyDamagedShards); + } + let gf = shared_gf16(); + let equations = recovery_equations(gf, data_count, damaged, recovery_shards, control)?; + let inverse = invert_linear_system_matrix_with_control(gf, &equations, control)?; + + // Coefficients for each supplied row against every column, hoisted out of + // the per-word loop. Damaged columns are skipped there, so they stay zero. + let mut coefficients = Vec::with_capacity(recovery_shards.len()); + for &(row_index, _) in recovery_shards { + let mut row = vec![0; data_count]; + for (data_index, coefficient) in row.iter_mut().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + if !damaged_lookup[data_index] { + *coefficient = recovery_coefficient(gf, data_count, row_index, data_index)?; + } + } + coefficients.push(row); + } + + let shard_len = data_shards.first().ok_or(Error::TooManyShards)?.len(); + for word_offset in (0..shard_len).step_by(2) { + poller.check(0).map_err(|_| Error::Cancelled)?; + let mut rhs = Vec::with_capacity(recovery_shards.len()); + for (&(_, parity), coefficients) in recovery_shards.iter().zip(&coefficients) { + poller.check(0).map_err(|_| Error::Cancelled)?; + let mut value = u16::from_le_bytes([parity[word_offset], parity[word_offset + 1]]); + for (data_index, shard) in data_shards.iter().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + if damaged_lookup[data_index] { + continue; + } + let data_symbol = u16::from_le_bytes([shard[word_offset], shard[word_offset + 1]]); + value ^= gf.mul(coefficients[data_index], data_symbol); + } + rhs.push(value); + } + let solved = apply_inverse_matrix_with_control(gf, &inverse, &rhs, control)?; + for (&data_index, &symbol) in damaged.iter().zip(&solved) { + poller.check(0).map_err(|_| Error::Cancelled)?; + data_shards[data_index][word_offset..word_offset + 2] + .copy_from_slice(&symbol.to_le_bytes()); + } + } + Ok(()) +} + +fn recovery_coefficient(gf: &Gf16, data_count: usize, row: usize, column: usize) -> Result { + let position = data_count + .checked_add(row) + .filter(|&position| position < FIELD_SIZE) + .ok_or(Error::TooManyShards)?; + if data_count == 0 || column >= data_count { + return Err(Error::TooManyShards); + } + gf.inv((position ^ column) as u16) +} + +fn recovery_equations( + gf: &Gf16, + data_count: usize, + damaged: &[usize], + recovery_shards: &[(usize, &[u8])], + control: &crate::read_control::ReadControl, +) -> Result>> { + let mut equations = Vec::with_capacity(recovery_shards.len()); + let mut poller = control.poller(); + check_repair(control)?; + for &(row_index, _) in recovery_shards { + // Validate the row even when no damaged columns were supplied. + recovery_coefficient(gf, data_count, row_index, 0)?; + let mut row = Vec::with_capacity(damaged.len()); + for &column in damaged { + poller.check(0).map_err(|_| Error::Cancelled)?; + row.push(recovery_coefficient(gf, data_count, row_index, column)?); + } + equations.push(row); + } + Ok(equations) +} + +#[cfg(test)] +fn invert_linear_system_matrix(gf: &Gf16, matrix: &[Vec]) -> Result>> { + invert_linear_system_matrix_with_control( + gf, + matrix, + &crate::read_control::ReadControl::default(), + ) +} + +fn invert_linear_system_matrix_with_control( + gf: &Gf16, + matrix: &[Vec], + control: &crate::read_control::ReadControl, +) -> Result>> { + let mut poller = control.poller(); + check_repair(control)?; + let n = matrix.len(); + if matrix.iter().any(|row| row.len() != n) { + return Err(Error::BadRecoveryChunk); + } + let mut matrix = matrix.to_vec(); + let mut inverse = vec![vec![0u16; n]; n]; + for (row, inverse_row) in inverse.iter_mut().enumerate() { + poller.check(0).map_err(|_| Error::Cancelled)?; + inverse_row[row] = 1; + } + + for col in 0..n { + poller.check(0).map_err(|_| Error::Cancelled)?; + let pivot = (col..n) + .find(|&row| matrix[row][col] != 0) + .ok_or(Error::SingularElement)?; + matrix.swap(col, pivot); + inverse.swap(col, pivot); + let inv = gf.inv(matrix[col][col])?; + for value in &mut matrix[col] { + poller.check(0).map_err(|_| Error::Cancelled)?; + *value = gf.mul(*value, inv); + } + for value in &mut inverse[col] { + poller.check(0).map_err(|_| Error::Cancelled)?; + *value = gf.mul(*value, inv); + } + + let pivot_matrix_row = matrix[col].clone(); + let pivot_inverse_row = inverse[col].clone(); + for row in 0..n { + poller.check(0).map_err(|_| Error::Cancelled)?; + if row == col { + continue; + } + let factor = matrix[row][col]; + if factor == 0 { + continue; + } + for (value, pivot) in matrix[row] + .iter_mut() + .zip(pivot_matrix_row.iter().copied()) + .skip(col) + { + poller.check(0).map_err(|_| Error::Cancelled)?; + *value ^= gf.mul(factor, pivot); + } + for (value, pivot) in inverse[row] + .iter_mut() + .zip(pivot_inverse_row.iter().copied()) + { + poller.check(0).map_err(|_| Error::Cancelled)?; + *value ^= gf.mul(factor, pivot); + } + } + } + Ok(inverse) +} + +#[cfg(test)] +fn apply_inverse_matrix(gf: &Gf16, inverse: &[Vec], rhs: &[u16]) -> Result> { + apply_inverse_matrix_with_control( + gf, + inverse, + rhs, + &crate::read_control::ReadControl::default(), + ) +} + +fn apply_inverse_matrix_with_control( + gf: &Gf16, + inverse: &[Vec], + rhs: &[u16], + control: &crate::read_control::ReadControl, +) -> Result> { + check_repair(control)?; + if inverse.len() != rhs.len() || inverse.iter().any(|row| row.len() != rhs.len()) { + return Err(Error::BadRecoveryChunk); + } + let mut output = Vec::with_capacity(rhs.len()); + let mut poller = control.poller(); + for row in inverse { + let mut sum = 0; + for (&coefficient, &value) in row.iter().zip(rhs) { + poller.check(0).map_err(|_| Error::Cancelled)?; + sum ^= gf.mul(coefficient, value); + } + output.push(sum); + } + Ok(output) +} + +#[derive(Debug, Clone)] +#[non_exhaustive] +pub struct Gf16 { + exp: Box<[u16]>, + log: Box<[u32]>, +} + +impl Gf16 { + pub fn new() -> Self { + let mut exp = vec![0u16; FIELD_SIZE * 4 + 1]; + let mut log = vec![0u32; FIELD_SIZE + 1]; + initialize_field(&mut exp, &mut log); + Self { + exp: exp.into_boxed_slice(), + log: log.into_boxed_slice(), + } + } + + pub fn add(&self, left: u16, right: u16) -> u16 { + left ^ right + } + + fn view(&self) -> GfView<'_> { + GfView { + exp: &self.exp, + log: &self.log, + } + } + pub fn mul(&self, left: u16, right: u16) -> u16 { + self.view().mul(left, right) + } + pub fn inv(&self, value: u16) -> Result { + self.view().inv(value) + } + + pub fn div(&self, numerator: u16, denominator: u16) -> Result { + Ok(self.mul(numerator, self.inv(denominator)?)) + } +} + +fn initialize_field(exp: &mut [u16], log: &mut [u32]) { + let mut value = 1u32; + for power in 0..FIELD_SIZE { + log[value as usize] = power as u32; + exp[power] = value as u16; + exp[power + FIELD_SIZE] = value as u16; + value <<= 1; + if value > FIELD_MASK { + value ^= PRIMITIVE_POLYNOMIAL; + } + } + log[0] = ZERO_LOG_SENTINEL; +} +struct GfView<'a> { + exp: &'a [u16], + log: &'a [u32], +} +impl GfView<'_> { + #[inline] + fn mul(&self, left: u16, right: u16) -> u16 { + if left == 0 || right == 0 { + return 0; + } + let index = self.log[left as usize] + self.log[right as usize]; + self.exp[index as usize] + } + + #[inline] + fn inv(&self, value: u16) -> Result { + if value == 0 { + return Err(Error::SingularElement); + } + let index = FIELD_SIZE as u32 - self.log[value as usize]; + Ok(self.exp[index as usize]) + } +} + +impl Default for Gf16 { + fn default() -> Self { + Self::new() + } +} + +pub fn make_encoder_matrix(data_shards: usize, recovery_shards: usize) -> Result>> { + if data_shards == 0 + || recovery_shards == 0 + || data_shards + .checked_add(recovery_shards) + .is_none_or(|total| total > FIELD_SIZE) + { + return Err(Error::TooManyShards); + } + let gf = shared_gf16(); + let mut matrix = vec![vec![0u16; data_shards]; recovery_shards]; + for (i, row) in matrix.iter_mut().enumerate() { + for (j, cell) in row.iter_mut().enumerate() { + let denominator = ((i + data_shards) ^ j) as u16; + *cell = gf.inv(denominator)?; + } + } + Ok(matrix) +} + +pub fn encode_parity_shards(data: &[&[u8]], recovery_shards: usize) -> Result>> { + let Some(first) = data.first() else { + return Err(Error::TooManyShards); + }; + if !first.len().is_multiple_of(2) { + return Err(Error::OddShardSize); + } + if data.iter().any(|shard| shard.len() != first.len()) { + return Err(Error::ShardSizeMismatch); + } + + let matrix = make_encoder_matrix(data.len(), recovery_shards)?; + let gf = shared_gf16(); + let mut parity = vec![vec![0u8; first.len()]; recovery_shards]; + for (recovery_index, row) in matrix.iter().enumerate() { + for word_offset in (0..first.len()).step_by(2) { + let mut symbol = 0u16; + for (data_index, shard) in data.iter().enumerate() { + let data_symbol = u16::from_le_bytes([shard[word_offset], shard[word_offset + 1]]); + symbol ^= gf.mul(row[data_index], data_symbol); + } + parity[recovery_index][word_offset..word_offset + 2] + .copy_from_slice(&symbol.to_le_bytes()); + } + } + Ok(parity) +} + +/// The pre-streaming recovery writer, kept verbatim as the oracle for +/// byte-identity tests. If these two ever disagree, the streaming rewrite has +/// changed the format. +#[cfg(test)] +mod legacy_reference { + use super::*; + + pub(super) fn build_structural_inline_recovery_data( + archive_prefix: &[u8], + recovery_percent: u64, + ) -> Result> { + let (plan, parity) = encode_inline_recovery_parity(archive_prefix, recovery_percent)?; + let shard_ranges = split_prefix_shard_ranges(archive_prefix.len(), plan)?; + let total_len = usize::try_from(plan.payload_size()?).map_err(|_| Error::PlanOverflow)?; + let header_size = usize::try_from(plan.header_size).map_err(|_| Error::PlanOverflow)?; + let shard_size = usize::try_from(plan.shard_size).map_err(|_| Error::PlanOverflow)?; + let data_shards = usize::try_from(plan.data_shards).map_err(|_| Error::PlanOverflow)?; + let recovery_shards = + usize::try_from(plan.recovery_shards).map_err(|_| Error::PlanOverflow)?; + let total_size = u32::try_from(plan.shard_size).map_err(|_| Error::PlanOverflow)?; + let header_size_u32 = u32::try_from(plan.header_size).map_err(|_| Error::PlanOverflow)?; + let data_shards_u16 = u16::try_from(plan.data_shards).map_err(|_| Error::PlanOverflow)?; + let recovery_shards_u16 = + u16::try_from(plan.recovery_shards).map_err(|_| Error::PlanOverflow)?; + let chunk_data_extent = shard_ranges.last().map_or(0usize, std::ops::Range::len); + let chunk_data_extent_u32 = + u32::try_from(chunk_data_extent).map_err(|_| Error::PlanOverflow)?; + let data_shard_states: Vec = shard_ranges + .iter() + .map(|range| crc64_rar_state(&archive_prefix[range.clone()])) + .collect(); + let final_state = parity + .first() + .map(|payload| crc64_rar_state(payload)) + .unwrap_or(0); + + let mut out = Vec::with_capacity(total_len); + for (shard_index, payload) in parity.iter().enumerate() { + if payload.len() + header_size != shard_size { + return Err(Error::PlanOverflow); + } + + let chunk_start = out.len(); + out.extend_from_slice(b"{RB}"); + out.extend_from_slice(&0u64.to_le_bytes()); + out.extend_from_slice(&total_size.to_le_bytes()); + out.extend_from_slice(&header_size_u32.to_le_bytes()); + out.push(1); + out.push(1); + out.extend_from_slice(&0u64.to_le_bytes()); + out.extend_from_slice(&chunk_data_extent_u32.to_le_bytes()); + out.extend_from_slice(&(archive_prefix.len() as u64).to_le_bytes()); + out.extend_from_slice(&plan.group_count.to_le_bytes()); + out.extend_from_slice(&plan.shard_size.to_le_bytes()); + out.extend_from_slice(&data_shards_u16.to_le_bytes()); + out.extend_from_slice(&recovery_shards_u16.to_le_bytes()); + out.extend_from_slice( + &u16::try_from(shard_index) + .map_err(|_| Error::PlanOverflow)? + .to_le_bytes(), + ); + for &state in &data_shard_states { + out.extend_from_slice(&state.to_le_bytes()); + } + out.extend_from_slice(&final_state.to_le_bytes()); + if out.len() - chunk_start != header_size { + return Err(Error::PlanOverflow); + } + out.extend_from_slice(payload); + if out.len() - chunk_start != shard_size { + return Err(Error::PlanOverflow); + } + + let chunk_end = chunk_start + .checked_add(shard_size) + .ok_or(Error::PlanOverflow)?; + let crc_start = chunk_start.checked_add(0x0c).ok_or(Error::PlanOverflow)?; + let crc = crc64_xz(out.get(crc_start..chunk_end).ok_or(Error::PlanOverflow)?); + let crc_field_start = chunk_start.checked_add(0x04).ok_or(Error::PlanOverflow)?; + let crc_field_end = chunk_start.checked_add(0x0c).ok_or(Error::PlanOverflow)?; + out.get_mut(crc_field_start..crc_field_end) + .ok_or(Error::PlanOverflow)? + .copy_from_slice(&crc.to_le_bytes()); + } + if out.len() != total_len { + return Err(Error::PlanOverflow); + } + debug_assert_eq!(parity.len(), recovery_shards); + debug_assert_eq!(data_shard_states.len(), data_shards); + Ok(out) + } +} + +#[cfg(test)] +mod tests { + use super::{ + apply_inverse_matrix, build_inline_recovery_data_for_plan, + build_structural_inline_recovery_data, crc64_rar_state, crc64_xz, + encode_inline_recovery_parity, encode_parity_shards, invert_linear_system_matrix, + make_encoder_matrix, plan_inline_recovery, reconstruct_data_shards, recovery_equations, + repair_inline_recovery_archive, repair_inline_recovery_prefix, + repair_inline_recovery_prefix_shards, shared_gf16, split_prefix_shard_ranges, + split_prefix_shards, Error, Gf16, InlineRecoveryPlan, MAX_WINRAR602_DATA_SHARDS, + }; + + fn recovery_test_bytes(len: usize, seed: u32) -> Vec { + let mut state = seed.wrapping_mul(2_654_435_761).wrapping_add(1); + (0..len) + .map(|index| { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + if index % 5 == 0 { + (index % 251) as u8 + } else { + (state >> 24) as u8 + } + }) + .collect() + } + + /// Sizes and percentages that between them cover an empty body, odd tails, + /// the sub-200 KiB shard formula, the 200-shard switchover, and a body big + /// enough to need many stripes. + const RECOVERY_CASES: &[usize] = &[ + 0, + 1, + 2, + 3, + 1023, + 1024, + 1025, + 2050, + 200 * 1024 - 1, + 200 * 1024, + 200 * 1024 + 1, + 1024 * 1024 + 7, + ]; + + #[test] + fn aggregate_recovery_planning_selects_stripes_beside_retained_capacity() { + let data = vec![7; 131072]; + let plan = super::plan_inline_recovery(data.len() as u64, 100).unwrap(); + let ledger = super::Allowance::limited(900000); + let retained = super::Buffer::filled(4096, 0u8, &ledger).unwrap(); + let (mode, required) = + super::choose_recovery_capacity_mode(plan, 8 * 1024 * 1024, &ledger).unwrap(); + assert!(matches!(mode, super::RecoveryMemoryMode::Striped { .. })); + assert!(required <= 8 * 1024 * 1024); + let mut expected = Vec::new(); + super::build_streamed_inline_recovery( + &mut std::io::Cursor::new(&data), + data.len() as u64, + 100, + super::RecoveryMemoryMode::Resident, + None, + &mut expected, + None, + 1, + ) + .unwrap(); + let mut actual = Vec::new(); + super::streamed_recovery_with_allowance( + &mut std::io::Cursor::new(&data), + data.len() as u64, + plan, + mode, + Some(&mut std::io::Cursor::new(Vec::new())), + &mut actual, + None, + 1, + &ledger, + ) + .unwrap(); + assert_eq!(actual, expected); + assert_eq!(ledger.used(), 4096); + drop(retained); + assert_eq!(ledger.used(), 0); + let small = super::Allowance::limited(1); + let error = + super::choose_recovery_capacity_mode(plan, 8 * 1024 * 1024, &small).unwrap_err(); + assert_eq!( + crate::Error::from(error).kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(small.used(), 0); + } + + #[test] + fn recovery_allowance_covers_tables_parity_and_framing_in_both_modes() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::Cursor; + let data = recovery_test_bytes(200_003, 17); + let plan = plan_inline_recovery(data.len() as u64, 10).unwrap(); + let expected = + super::legacy_reference::build_structural_inline_recovery_data(&data, 10).unwrap(); + let field_bytes = ((super::FIELD_SIZE * 4 + 1) * 2 + (super::FIELD_SIZE + 1) * 4) as u64; + for mode in [ + RecoveryMemoryMode::Resident, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + ] { + let mut successes = 0; + let mut refusals = 0; + for limit in [ + 0, + field_bytes - 1, + field_bytes, + field_bytes + 2048, + field_bytes + 16384, + field_bytes + 131072, + ] { + let allowance = Allowance::limited(limit); + let mut body = Cursor::new(&data); + let mut scratch = Cursor::new(Vec::new()); + let mut output = Vec::new(); + let result = streamed_recovery_with_allowance( + &mut body, + data.len() as u64, + plan, + mode, + Some(&mut scratch), + &mut output, + None, + 0, + &allowance, + ); + match result { + Ok(built) => { + successes += 1; + assert_eq!(output, expected); + assert_eq!(built.payload_len, output.len() as u64); + assert_eq!(built.payload_crc32, crate::crc32::crc32(&output)); + } + Err(error) => { + refusals += 1; + assert_eq!( + crate::Error::from(error).kind(), + crate::ErrorKind::ResourceLimit + ); + if limit <= field_bytes { + assert_eq!(body.position(), 0); + assert!(output.is_empty()); + } + } + } + assert_eq!(allowance.used(), 0, "{mode:?} limit={limit}"); + } + assert!(successes > 0 && refusals >= 3); + } + } + + #[test] + fn recovery_allowance_releases_every_owner_on_cancellation_and_io_failure() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::{Cursor, Read, Seek, SeekFrom, Write}; + use std::sync::atomic::{AtomicBool, Ordering}; + struct Progress { + cancelled: AtomicBool, + finished: AtomicBool, + } + impl crate::WriteProgress for Progress { + fn report(&self, event: crate::WriteProgressEvent<'_>) { + match event { + crate::WriteProgressEvent::Advanced { .. } => { + self.cancelled.store(true, Ordering::Relaxed) + } + crate::WriteProgressEvent::OperationFinished { .. } => { + self.finished.store(true, Ordering::Relaxed) + } + _ => {} + } + } + fn is_cancelled(&self) -> bool { + self.cancelled.load(Ordering::Relaxed) + } + } + struct FailedScratch; + impl Read for FailedScratch { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + unreachable!() + } + } + impl Seek for FailedScratch { + fn seek(&mut self, _: SeekFrom) -> std::io::Result { + Ok(0) + } + } + impl Write for FailedScratch { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::ErrorKind::BrokenPipe.into()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let data = recovery_test_bytes(200_003, 17); + let plan = plan_inline_recovery(data.len() as u64, 10).unwrap(); + let allowance = Allowance::limited(2 * 1048576); + for mode in [ + RecoveryMemoryMode::Resident, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + ] { + for initially_cancelled in [false, true] { + let progress = Progress { + cancelled: AtomicBool::new(initially_cancelled), + finished: AtomicBool::new(false), + }; + let mut body = Cursor::new(&data); + let mut output = Vec::new(); + let result = streamed_recovery_with_allowance( + &mut body, + data.len() as u64, + plan, + mode, + Some(&mut Cursor::new(Vec::new())), + &mut output, + Some(crate::progress::ProgressReporter(&progress)), + 0, + &allowance, + ); + assert!(matches!(result, Err(Error::Cancelled))); + assert!(!progress.finished.load(Ordering::Relaxed)); + assert!(output.is_empty()); + if initially_cancelled { + assert_eq!(body.position(), 0); + } + assert_eq!(allowance.used(), 0); + } + let error = streamed_recovery_with_allowance( + &mut Cursor::new(&data[..7]), + data.len() as u64, + plan, + mode, + Some(&mut Cursor::new(Vec::new())), + &mut Vec::new(), + None, + 0, + &allowance, + ) + .unwrap_err(); + assert!(matches!( + error, + Error::Io(std::io::ErrorKind::UnexpectedEof) + )); + assert_eq!(allowance.used(), 0); + let error = streamed_recovery_with_allowance( + &mut Cursor::new(&data), + data.len() as u64, + plan, + mode, + Some(&mut FailedScratch), + &mut FailedScratch, + None, + 0, + &allowance, + ) + .unwrap_err(); + assert!(matches!(error, Error::Io(std::io::ErrorKind::BrokenPipe))); + assert_eq!(allowance.used(), 0); + let mut output = Vec::new(); + streamed_recovery_with_allowance( + &mut Cursor::new(&data), + data.len() as u64, + plan, + mode, + Some(&mut Cursor::new(Vec::new())), + &mut output, + None, + 0, + &allowance, + ) + .unwrap(); + assert!(!output.is_empty()); + assert_eq!(allowance.used(), 0); + } + } + + #[test] + fn streamed_recovery_reports_parity_sink_failure_after_header() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::{Cursor, Write}; + + struct HeaderOnlySink { + header_len: usize, + written: usize, + } + impl Write for HeaderOnlySink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + if self.written == self.header_len { + return Err(std::io::ErrorKind::BrokenPipe.into()); + } + let count = bytes.len().min(self.header_len - self.written); + self.written += count; + Ok(count) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let body = vec![0x5a; 4096]; + let plan = plan_inline_recovery(body.len() as u64, 10).unwrap(); + for mode in [ + RecoveryMemoryMode::Resident, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + ] { + let allowance = Allowance::limited(2 * 1048576); + let mut sink = HeaderOnlySink { + header_len: plan.header_size as usize, + written: 0, + }; + let error = streamed_recovery_with_allowance( + &mut Cursor::new(&body), + body.len() as u64, + plan, + mode, + Some(&mut Cursor::new(Vec::new())), + &mut sink, + None, + 0, + &allowance, + ) + .unwrap_err(); + assert_eq!(error, Error::Io(std::io::ErrorKind::BrokenPipe)); + assert_eq!(sink.written, plan.header_size as usize); + assert_eq!(allowance.used(), 0); + } + } + + #[test] + fn striped_recovery_stops_writing_after_mid_row_sink_failure() { + use std::io::{Cursor, Write}; + + struct HeaderSink(usize); + impl Write for HeaderSink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + if self.0 != 0 { + return Err(std::io::ErrorKind::BrokenPipe.into()); + } + self.0 += bytes.len(); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + let body = vec![7; super::RECOVERY_IO_BLOCK + 2]; + let plan = InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1, + group_count: body.len() as u64, + header_size: 80, + shard_size: 80 + body.len() as u64, + }; + let mut sink = HeaderSink(0); + let error = super::build_streamed_inline_recovery_for_plan( + &mut Cursor::new(&body), + body.len() as u64, + plan, + super::RecoveryMemoryMode::Striped { stripe_len: 4096 }, + Some(&mut Cursor::new(Vec::new())), + &mut sink, + None, + 1, + ) + .unwrap_err(); + assert_eq!(error, Error::Io(std::io::ErrorKind::BrokenPipe)); + assert_eq!(sink.0, plan.header_size as usize); + } + + #[test] + fn striped_recovery_reports_scratch_read_failure_before_output() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::{Cursor, Read, Seek, SeekFrom, Write}; + + struct UnreadableScratch(Cursor>); + impl Read for UnreadableScratch { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + Err(std::io::ErrorKind::BrokenPipe.into()) + } + } + impl Write for UnreadableScratch { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.write(bytes) + } + fn flush(&mut self) -> std::io::Result<()> { + self.0.flush() + } + } + impl Seek for UnreadableScratch { + fn seek(&mut self, pos: SeekFrom) -> std::io::Result { + self.0.seek(pos) + } + } + + let body = vec![0x5a; 4096]; + let plan = plan_inline_recovery(body.len() as u64, 10).unwrap(); + let allowance = Allowance::limited(2 * 1048576); + let mut output = Vec::new(); + let error = streamed_recovery_with_allowance( + &mut Cursor::new(&body), + body.len() as u64, + plan, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + Some(&mut UnreadableScratch(Cursor::new(Vec::new()))), + &mut output, + None, + 0, + &allowance, + ) + .unwrap_err(); + assert_eq!(error, Error::Io(std::io::ErrorKind::BrokenPipe)); + assert!(output.is_empty()); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn striped_recovery_preserves_scratch_seek_failures() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::{Cursor, Read, Seek, SeekFrom, Write}; + + struct FaultScratch { + data: Cursor>, + reads: usize, + fail_initial_seek: bool, + } + impl Read for FaultScratch { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + self.reads += 1; + self.data.read(bytes) + } + } + impl Write for FaultScratch { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.data.write(bytes) + } + fn flush(&mut self) -> std::io::Result<()> { + self.data.flush() + } + } + impl Seek for FaultScratch { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + if self.fail_initial_seek || self.reads != 0 { + return Err(std::io::ErrorKind::PermissionDenied.into()); + } + self.data.seek(from) + } + } + + let body = vec![0x5a; 4096]; + let plan = plan_inline_recovery(body.len() as u64, 10).unwrap(); + for fail_initial_seek in [true, false] { + let allowance = Allowance::limited(2 * 1048576); + let mut scratch = FaultScratch { + data: Cursor::new(Vec::new()), + reads: 0, + fail_initial_seek, + }; + let mut output = Vec::new(); + let error = streamed_recovery_with_allowance( + &mut Cursor::new(&body), + body.len() as u64, + plan, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + Some(&mut scratch), + &mut output, + None, + 0, + &allowance, + ) + .unwrap_err(); + assert_eq!(error, Error::Io(std::io::ErrorKind::PermissionDenied)); + assert_eq!(scratch.reads == 0, fail_initial_seek); + assert!(output.is_empty()); + assert_eq!(allowance.used(), 0); + } + } + + #[test] + fn recovery_encoder_preserves_body_seek_failures() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::{Cursor, Read, Seek, SeekFrom}; + + struct UnseekableBody(Cursor>); + impl Read for UnseekableBody { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + self.0.read(bytes) + } + } + impl Seek for UnseekableBody { + fn seek(&mut self, _: SeekFrom) -> std::io::Result { + Err(std::io::ErrorKind::PermissionDenied.into()) + } + } + + let body = vec![0x5a; 4096]; + let plan = plan_inline_recovery(body.len() as u64, 10).unwrap(); + for mode in [ + RecoveryMemoryMode::Resident, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + ] { + let allowance = Allowance::limited(2 * 1048576); + let mut output = Vec::new(); + let error = streamed_recovery_with_allowance( + &mut UnseekableBody(Cursor::new(body.clone())), + body.len() as u64, + plan, + mode, + Some(&mut Cursor::new(Vec::new())), + &mut output, + None, + 0, + &allowance, + ) + .unwrap_err(); + assert_eq!(error, Error::Io(std::io::ErrorKind::PermissionDenied)); + assert!(output.is_empty()); + assert_eq!(allowance.used(), 0); + } + } + + #[test] + fn streamed_recovery_rejects_invalid_plan_before_output() { + use super::{streamed_recovery_with_allowance, Allowance, RecoveryMemoryMode}; + use std::io::Cursor; + + let body = vec![0x5a; 4096]; + let valid = plan_inline_recovery(body.len() as u64, 10).unwrap(); + let allowance = Allowance::limited(2 * 1048576); + for (name, plan, expected) in [ + ( + "payload length overflow", + InlineRecoveryPlan { + recovery_shards: u64::MAX, + ..valid + }, + Error::PlanOverflow, + ), + ( + "header state multiplication overflow", + InlineRecoveryPlan { + data_shards: u64::MAX, + ..valid + }, + Error::PlanOverflow, + ), + ( + "header state addition overflow", + InlineRecoveryPlan { + data_shards: (u64::MAX - 0x48) / 8 + 1, + ..valid + }, + Error::PlanOverflow, + ), + ( + "shard length addition overflow", + InlineRecoveryPlan { + group_count: u64::MAX, + ..valid + }, + Error::PlanOverflow, + ), + ( + "u32 shard length", + InlineRecoveryPlan { + group_count: u32::MAX as u64, + shard_size: u32::MAX as u64 + valid.header_size, + ..valid + }, + Error::PlanOverflow, + ), + ( + "u16 data count", + InlineRecoveryPlan { + data_shards: u16::MAX as u64 + 1, + group_count: 0, + header_size: 0x48 + 8 * (u16::MAX as u64 + 1), + shard_size: 0x48 + 8 * (u16::MAX as u64 + 1), + ..valid + }, + Error::PlanOverflow, + ), + ( + "u16 recovery count", + InlineRecoveryPlan { + recovery_shards: u16::MAX as u64 + 1, + ..valid + }, + Error::PlanOverflow, + ), + ( + "header length", + InlineRecoveryPlan { + header_size: valid.header_size + 1, + ..valid + }, + Error::PlanOverflow, + ), + ( + "shard length", + InlineRecoveryPlan { + shard_size: valid.shard_size + 1, + ..valid + }, + Error::PlanOverflow, + ), + ( + "prefix capacity", + InlineRecoveryPlan { + group_count: 2, + shard_size: valid.header_size + 2, + ..valid + }, + Error::PrefixExceedsPlan, + ), + ( + "zero recovery shards", + InlineRecoveryPlan { + recovery_shards: 0, + ..valid + }, + Error::TooManyShards, + ), + ] { + let mut output = Vec::new(); + let result = streamed_recovery_with_allowance( + &mut Cursor::new(&body), + body.len() as u64, + plan, + RecoveryMemoryMode::Resident, + None, + &mut output, + None, + 0, + &allowance, + ); + assert_eq!(result.unwrap_err(), expected, "{name}"); + assert!(output.is_empty(), "{name}"); + assert_eq!(allowance.used(), 0, "{name}"); + } + let mut output = Vec::new(); + assert_eq!( + streamed_recovery_with_allowance( + &mut Cursor::new(&body), + body.len() as u64, + valid, + RecoveryMemoryMode::Striped { stripe_len: 64 }, + None, + &mut output, + None, + 0, + &allowance, + ) + .unwrap_err(), + Error::PlanOverflow + ); + assert!(output.is_empty()); + assert_eq!(allowance.used(), 0); + } + + #[test] + fn rar5_record_builder_preserves_plan_errors() { + let plan = InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1, + group_count: 0, + header_size: 80, + shard_size: 80, + }; + assert_eq!( + super::build_inline_recovery_data_for_plan_with_control( + b"abc", + plan, + &crate::read_control::ReadControl::default() + ), + Err(Error::PrefixExceedsPlan) + ); + } + + #[test] + fn streamed_recovery_reports_progress_through_completion() { + use std::io::Cursor; + use std::sync::Mutex; + + #[derive(Default)] + struct Progress(Mutex>); + impl crate::WriteProgress for Progress { + fn report(&self, event: crate::WriteProgressEvent<'_>) { + let item = match event { + crate::WriteProgressEvent::OperationStarted { + total_bytes: Some(total), + .. + } => (0, total), + crate::WriteProgressEvent::Advanced { + completed_bytes, .. + } => (1, completed_bytes), + crate::WriteProgressEvent::OperationFinished { + total_bytes: Some(total), + .. + } => (2, total), + _ => panic!("unexpected recovery progress event"), + }; + self.0.lock().unwrap().push(item); + } + } + + let body = vec![0x5a; 4096]; + let progress = Progress::default(); + let mut output = Vec::new(); + let result = super::build_streamed_inline_recovery( + &mut Cursor::new(&body), + body.len() as u64, + 10, + super::RecoveryMemoryMode::Resident, + None, + &mut output, + Some(crate::progress::ProgressReporter(&progress)), + 3, + ) + .unwrap(); + let events = progress.0.into_inner().unwrap(); + assert_eq!(events.first(), Some(&(0, result.payload_len))); + assert_eq!(events.last(), Some(&(2, result.payload_len))); + assert!(events[1..events.len() - 1] + .iter() + .all(|&(kind, bytes)| kind == 1 && bytes <= result.payload_len)); + assert!(events.len() > 2); + assert_eq!(output.len() as u64, result.payload_len); + } + + #[test] + fn streamed_recovery_handles_empty_and_unused_data_shards() { + use std::io::Cursor; + + for (body, plan) in [ + ( + &b""[..], + InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1, + group_count: 2, + header_size: 80, + shard_size: 82, + }, + ), + ( + &b"abc"[..], + InlineRecoveryPlan { + data_shards: 3, + recovery_shards: 1, + group_count: 4, + header_size: 96, + shard_size: 100, + }, + ), + ] { + let mut output = Vec::new(); + super::build_streamed_inline_recovery_for_plan( + &mut Cursor::new(body), + body.len() as u64, + plan, + super::RecoveryMemoryMode::Resident, + None, + &mut output, + None, + 1, + ) + .unwrap(); + assert_eq!( + repair_inline_recovery_prefix(body, &output), + Ok(body.to_vec()) + ); + } + } + + #[test] + fn streamed_recovery_matches_the_legacy_writer_byte_for_byte() { + for &len in RECOVERY_CASES { + let body = recovery_test_bytes(len, len as u32); + // High percentages on the large cases cost O(shards^2) work for no + // extra coverage: the geometry is already pinned by the small ones. + let percents: &[u64] = if len < 200 * 1024 { + &[1, 5, 10, 50, 100] + } else { + &[1, 10] + }; + for &percent in percents { + let expected = + super::legacy_reference::build_structural_inline_recovery_data(&body, percent) + .unwrap(); + let produced = build_structural_inline_recovery_data(&body, percent).unwrap(); + assert_eq!( + produced, expected, + "streamed output differs for {len} bytes at {percent}%" + ); + } + } + } + + #[test] + fn striped_recovery_matches_resident_recovery_byte_for_byte() { + // Small bodies get a deliberately tiny stripe so stripe boundaries land + // everywhere; large ones use a realistic stripe, since their job is to + // cover the 200-shard geometry rather than boundary arithmetic. + for &len in RECOVERY_CASES { + let body = recovery_test_bytes(len, len as u32 ^ 0x5555); + let (stripe_len, percents): (usize, &[u64]) = if len <= 4096 { + (64, &[1, 10, 100]) + } else { + (4096, &[1, 10]) + }; + for &percent in percents { + let expected = build_structural_inline_recovery_data(&body, percent).unwrap(); + + let plan = plan_inline_recovery(body.len() as u64, percent).unwrap(); + let mut scratch = std::io::Cursor::new(vec![ + 0u8; + (plan.recovery_shards * plan.group_count) + as usize + ]); + let mut produced = Vec::new(); + let output = super::build_streamed_inline_recovery( + &mut std::io::Cursor::new(&body), + body.len() as u64, + percent, + super::RecoveryMemoryMode::Striped { stripe_len }, + Some(&mut scratch), + &mut produced, + None, + 1, + ) + .unwrap(); + + assert_eq!( + produced, expected, + "striped output differs for {len} bytes at {percent}%" + ); + assert_eq!(output.plan, plan); + assert_eq!(output.payload_len, produced.len() as u64); + assert_eq!(output.payload_crc32, crate::crc32::crc32(&produced)); + } + } + } + + #[test] + fn recovery_memory_mode_switches_to_striping_under_pressure() { + let plan = plan_inline_recovery(4 * 1024 * 1024, 10).unwrap(); + let parity_bytes = plan.recovery_shards * plan.group_count; + + let (mode, required) = + super::choose_recovery_memory_mode(plan, parity_bytes + 1024 * 1024).unwrap(); + assert_eq!(mode, super::RecoveryMemoryMode::Resident); + assert!(required >= parity_bytes); + + let limit = parity_bytes / 2; + let (mode, required) = super::choose_recovery_memory_mode(plan, limit).unwrap(); + let super::RecoveryMemoryMode::Striped { stripe_len } = mode else { + panic!("expected striped mode when parity does not fit"); + }; + assert!(stripe_len.is_multiple_of(2), "stripes must be word aligned"); + assert!( + required <= limit, + "striping must fit the budget it was given: {required} > {limit}" + ); + assert!(required < parity_bytes); + assert_eq!( + super::choose_recovery_memory_mode( + InlineRecoveryPlan { + recovery_shards: u64::MAX, + group_count: 2, + ..plan + }, + u64::MAX, + ), + Err(Error::PlanOverflow) + ); + let allowance = super::Allowance::limited(2 * 1048576); + assert_eq!( + super::choose_recovery_capacity_mode( + InlineRecoveryPlan { + recovery_shards: u64::MAX, + group_count: 2, + ..plan + }, + u64::MAX, + &allowance, + ), + Err(Error::PlanOverflow) + ); + } + + #[test] + fn rar5_inline_recovery_plan_matches_fixture_formula_examples() { + assert_eq!( + plan_inline_recovery(65_681, 5).unwrap(), + InlineRecoveryPlan { + data_shards: 65, + recovery_shards: 3, + group_count: 1012, + header_size: 592, + shard_size: 1604, + } + ); + assert_eq!( + plan_inline_recovery(65_681, 20).unwrap(), + InlineRecoveryPlan { + data_shards: 65, + recovery_shards: 13, + group_count: 1012, + header_size: 592, + shard_size: 1604, + } + ); + } + + #[test] + fn rar5_inline_recovery_plan_handles_clamps_and_large_prefixes() { + assert_eq!( + plan_inline_recovery(0, 0).unwrap(), + InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1, + group_count: 0, + header_size: 80, + shard_size: 80, + } + ); + assert_eq!( + plan_inline_recovery(200 * 1024, 1000).unwrap(), + InlineRecoveryPlan { + data_shards: 200, + recovery_shards: 200, + group_count: 1024, + header_size: 1672, + shard_size: 2696, + } + ); + let largest = plan_inline_recovery(u64::MAX, 1000).unwrap(); + assert_eq!(largest.data_shards, MAX_WINRAR602_DATA_SHARDS); + assert_eq!(largest.header_size, 1672); + assert_eq!(largest.group_count, u64::MAX.div_ceil(200) + 1); + assert_eq!( + largest.shard_size, + largest.header_size + largest.group_count + ); + } + + #[test] + fn rar5_inline_recovery_plan_keeps_fixed_header_above_64k_groups() { + let boundary = MAX_WINRAR602_DATA_SHARDS * 0x10000; + assert_eq!( + plan_inline_recovery(boundary, 1).unwrap(), + InlineRecoveryPlan { + data_shards: 200, + recovery_shards: 2, + group_count: 65_536, + header_size: 1672, + shard_size: 67_208, + } + ); + assert_eq!( + plan_inline_recovery(boundary + 1, 1).unwrap(), + InlineRecoveryPlan { + data_shards: 200, + recovery_shards: 2, + group_count: 65_538, + header_size: 1672, + shard_size: 67_210, + } + ); + } + + #[test] + fn rar5_recovery_planning_handles_zero_percent_and_tight_budgets() { + let large = plan_inline_recovery(200 * 1024, 0).unwrap(); + assert_eq!(large.recovery_shards, 0); + let body = vec![0; 200 * 1024]; + assert_eq!( + encode_inline_recovery_parity(&body, 0), + Err(Error::TooManyShards) + ); + assert_eq!( + build_structural_inline_recovery_data(&body, 0), + Err(Error::TooManyShards) + ); + + let plan = plan_inline_recovery(4096, 10).unwrap(); + let (mode, _) = super::choose_recovery_memory_mode(plan, 0).unwrap(); + assert!(matches!(mode, super::RecoveryMemoryMode::Striped { .. })); + + let allowance = super::Allowance::limited(2 * 1048576); + let (mode, required) = + super::choose_recovery_capacity_mode(plan, 2 * 1048576, &allowance).unwrap(); + assert_eq!(mode, super::RecoveryMemoryMode::Resident); + assert!(required <= allowance.available()); + } + + #[test] + fn gf16_matches_rar5_polynomial_wrap() { + let gf = Gf16::new(); + + assert_eq!(gf.mul(0x8000, 2), 0x100b); + assert_eq!(gf.mul(0, 0x1234), 0); + assert_eq!(gf.mul(0x1234, 0), 0); + assert_eq!(gf.mul(0, 0), 0); + assert_eq!(gf.mul(1, 0x1234), 0x1234); + } + + #[test] + fn shared_gf16_reuses_field_tables() { + let first = shared_gf16() as *const Gf16; + let second = shared_gf16() as *const Gf16; + + assert_eq!(first, second); + assert_eq!(shared_gf16().mul(0x8000, 2), 0x100b); + } + + #[test] + fn crc64_xz_matches_reference_vectors() { + assert_eq!(crc64_xz(b""), 0); + assert_eq!(crc64_xz(b"123456789"), 0x995d_c9bb_df19_39fa); + assert_eq!(crc64_xz(b"testtesttest"), 0x7b1c_2d23_0ede_b436); + } + + #[test] + fn raw_crc64_state_matches_reference_vector() { + assert_eq!(crc64_rar_state(b""), 0); + assert_eq!(crc64_rar_state(b"te\x80st"), 0xb5db_f958_3a6e_ed4a); + } + + #[test] + fn rar5_prefix_split_produces_even_padded_data_shards() { + let plan = InlineRecoveryPlan { + data_shards: 3, + recovery_shards: 1, + group_count: 4, + header_size: 96, + shard_size: 100, + }; + let shards = split_prefix_shards(b"abcdefghij", plan).unwrap(); + + assert_eq!( + shards, + vec![b"abcd".to_vec(), b"efgh".to_vec(), b"ij\0\0".to_vec()] + ); + } + + #[test] + fn rar5_prefix_split_rejects_prefix_larger_than_plan_capacity() { + let plan = InlineRecoveryPlan { + data_shards: 2, + recovery_shards: 1, + group_count: 2, + header_size: 88, + shard_size: 90, + }; + + assert_eq!( + split_prefix_shards(b"abcde", plan), + Err(Error::PrefixExceedsPlan) + ); + assert_eq!( + split_prefix_shard_ranges( + 0, + InlineRecoveryPlan { + group_count: usize::MAX as u64, + ..plan + } + ), + Err(Error::PlanOverflow) + ); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn rar5_prefix_split_rejects_unrepresentable_native_geometry() { + let plan = InlineRecoveryPlan { + data_shards: u32::MAX as u64 + 1, + recovery_shards: 1, + group_count: 1, + header_size: 80, + shard_size: 81, + }; + assert_eq!(split_prefix_shard_ranges(0, plan), Err(Error::PlanOverflow)); + assert_eq!( + split_prefix_shard_ranges( + 0, + InlineRecoveryPlan { + data_shards: 1, + group_count: u32::MAX as u64 + 1, + ..plan + } + ), + Err(Error::PlanOverflow) + ); + assert_eq!( + split_prefix_shards( + b"", + InlineRecoveryPlan { + data_shards: 1, + group_count: u32::MAX as u64 + 1, + ..plan + } + ), + Err(Error::PlanOverflow) + ); + } + + #[test] + fn rar5_prefix_split_handles_extra_empty_data_shards() { + let plan = InlineRecoveryPlan { + data_shards: 3, + recovery_shards: 1, + group_count: 4, + header_size: 96, + shard_size: 100, + }; + + assert_eq!( + split_prefix_shard_ranges(3, plan).unwrap(), + vec![0..3, 3..3, 3..3] + ); + assert_eq!( + split_prefix_shards(b"abc", plan).unwrap(), + vec![b"abc\0".to_vec(), vec![0; 4], vec![0; 4]] + ); + } + + #[test] + fn gf16_inverse_round_trips_nonzero_elements() { + let gf = Gf16::new(); + + for value in [1, 2, 3, 0x100b, 0x8000, 0xffff] { + let inverse = gf.inv(value).unwrap(); + assert_eq!(gf.mul(value, inverse), 1); + } + assert_eq!(gf.inv(0), Err(Error::SingularElement)); + } + + #[test] + fn gf16_public_arithmetic_matches_field_identities() { + let gf = Gf16::default(); + assert_eq!(gf.add(0x1234, 0x1234), 0); + assert_eq!(gf.add(0x1234, 0), 0x1234); + assert_eq!(gf.div(0x1234, 1), Ok(0x1234)); + assert_eq!(gf.div(0, 0x1234), Ok(0)); + assert_eq!(gf.div(1, 0), Err(Error::SingularElement)); + } + + #[test] + fn rar5_recovery_errors_display_and_preserve_typed_sources() { + for error in [ + Error::Cancelled, + Error::BadRecoveryChunk, + Error::OddShardSize, + Error::PlanOverflow, + Error::PrefixExceedsPlan, + Error::TooManyDamagedShards, + Error::ShardSizeMismatch, + Error::TooManyShards, + Error::SingularElement, + Error::RebuildTooLarge, + Error::RepairWorkspaceLimitExceeded { + limit: 1, + required: 2, + }, + Error::Io(std::io::ErrorKind::BrokenPipe), + ] { + assert!(!error.to_string().is_empty()); + assert!(std::error::Error::source(&error).is_none()); + } + let typed = Error::TypedIo(Box::new(crate::Error::Cancelled)); + assert_eq!(typed.to_string(), crate::Error::Cancelled.to_string()); + assert!(std::error::Error::source(&typed).is_some()); + } + + #[test] + fn rar5_cauchy_encoder_matrix_uses_inverse_xor_denominators() { + let gf = Gf16::new(); + let matrix = make_encoder_matrix(3, 2).unwrap(); + + assert_eq!(matrix.len(), 2); + assert_eq!(matrix[0].len(), 3); + for (i, row) in matrix.iter().enumerate() { + for (j, &cell) in row.iter().enumerate() { + let denominator = ((i + 3) ^ j) as u16; + assert_eq!(gf.mul(cell, denominator), 1); + } + } + } + + #[test] + fn rar5_recovery_equations_do_not_materialize_unused_rows_or_columns() { + let gf = shared_gf16(); + let equations = recovery_equations( + gf, + 32_000, + &[0, 31_999], + &[(32_000, &[])], + &crate::read_control::ReadControl::default(), + ) + .unwrap(); + assert_eq!( + equations, + vec![vec![ + gf.inv(64_000).unwrap(), + gf.inv(64_000 ^ 31_999).unwrap() + ]] + ); + assert_eq!(equations[0].capacity(), 2); + assert_eq!( + make_encoder_matrix(usize::MAX, 1), + Err(Error::TooManyShards) + ); + } + + #[test] + fn rar5_repair_keeps_empty_shards_and_padding_virtual() { + // A valid sparse record describes 8 MiB of padded data capacity, but + // only one byte of real data and one available high-index parity row. + let data_count = 2048usize; + let row = data_count - 1; + let group_count = 4096usize; + let header_size = 0x48 + data_count * 8; + let shard_size = header_size + group_count; + let mut chunk = vec![0; shard_size]; + chunk[..4].copy_from_slice(b"{RB}"); + chunk[0x0c..0x10].copy_from_slice(&(shard_size as u32).to_le_bytes()); + chunk[0x10..0x14].copy_from_slice(&(header_size as u32).to_le_bytes()); + chunk[0x14] = 1; + chunk[0x15] = 1; + chunk[0x22..0x2a].copy_from_slice(&1u64.to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&(group_count as u64).to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&(shard_size as u64).to_le_bytes()); + chunk[0x3a..0x3c].copy_from_slice(&(data_count as u16).to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&(data_count as u16).to_le_bytes()); + chunk[0x3e..0x40].copy_from_slice(&(row as u16).to_le_bytes()); + chunk[0x40..0x48].copy_from_slice(&crc64_rar_state(b"a").to_le_bytes()); + let gf = shared_gf16(); + let parity = gf.mul(gf.inv((data_count + row) as u16).unwrap(), b'a' as u16); + chunk[header_size..header_size + 2].copy_from_slice(&parity.to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[4..0x0c].copy_from_slice(&crc.to_le_bytes()); + assert_eq!(repair_inline_recovery_prefix(b"a", &chunk).unwrap(), b"a"); + assert_eq!(repair_inline_recovery_prefix(b"b", &chunk).unwrap(), b"a"); + let mut empty_reads = 0; + let repaired = repair_inline_recovery_prefix_shards(1, &chunk, |range| { + assert!(range.len() <= 1); + if range.is_empty() { + empty_reads += 1; + } + Ok(b"b"[range].to_vec()) + }) + .unwrap(); + assert_eq!(repaired, vec![(0..1, b"a".to_vec())]); + // Empty columns are checked once and never reread during RHS solving. + assert_eq!(empty_reads, data_count - 1); + } + + #[test] + fn rar5_cauchy_encoder_matrix_rejects_impossible_shard_counts() { + assert_eq!(make_encoder_matrix(0, 1), Err(Error::TooManyShards)); + assert_eq!(make_encoder_matrix(1, 0), Err(Error::TooManyShards)); + assert_eq!(make_encoder_matrix(65535, 1), Err(Error::TooManyShards)); + } + + #[test] + fn rar5_recovery_inverse_matrix_solves_reused_equations() { + let gf = shared_gf16(); + let equations = vec![vec![3, 5], vec![7, 11]]; + let expected = [0x1234, 0xabcd]; + let rhs = equations + .iter() + .map(|row| gf.mul(row[0], expected[0]) ^ gf.mul(row[1], expected[1])) + .collect::>(); + + let inverse = invert_linear_system_matrix(gf, &equations).unwrap(); + let solved = apply_inverse_matrix(gf, &inverse, &rhs).unwrap(); + + assert_eq!(solved, expected); + } + + #[test] + fn rar5_recovery_matrix_rejects_non_square_inputs() { + let gf = shared_gf16(); + assert_eq!( + invert_linear_system_matrix(gf, &[vec![1], vec![1]]), + Err(Error::BadRecoveryChunk) + ); + assert_eq!( + apply_inverse_matrix(gf, &[vec![1]], &[1, 2]), + Err(Error::BadRecoveryChunk) + ); + assert_eq!( + apply_inverse_matrix(gf, &[vec![1], vec![1]], &[1, 2]), + Err(Error::BadRecoveryChunk) + ); + } + + #[test] + fn rar5_recovery_matrix_handles_zero_elimination_factors() { + let gf = shared_gf16(); + assert_eq!( + invert_linear_system_matrix(gf, &[vec![1, 0], vec![0, 1]]), + Ok(vec![vec![1, 0], vec![0, 1]]) + ); + } + + #[test] + fn rar5_budgeted_encoder_rejects_invalid_shard_counts() { + let allowance = super::Allowance::default(); + let gf = shared_gf16().view(); + for (data, recovery) in [(0, 1), (1, 0), (usize::MAX, 1)] { + assert_eq!( + super::encoder_matrix_with_allowance(data, recovery, &gf, &allowance).unwrap_err(), + Error::TooManyShards + ); + } + } + + #[test] + fn rar5_parity_encoder_generates_systematic_recovery_shards() { + let first = [1, 0, 2, 0, 3, 0, 4, 0]; + let parity = encode_parity_shards(&[&first], 1).unwrap(); + + assert_eq!(parity, [first.to_vec()]); + } + + #[test] + fn rar5_parity_encoder_applies_cauchy_matrix_coefficients() { + let gf = Gf16::new(); + let first = [1, 0, 2, 0]; + let second = [3, 0, 4, 0]; + let matrix = make_encoder_matrix(2, 2).unwrap(); + let parity = encode_parity_shards(&[&first, &second], 2).unwrap(); + + for recovery_index in 0..2 { + for word_index in 0..2 { + let offset = word_index * 2; + let left = u16::from_le_bytes([first[offset], first[offset + 1]]); + let right = u16::from_le_bytes([second[offset], second[offset + 1]]); + let expected = gf.mul(matrix[recovery_index][0], left) + ^ gf.mul(matrix[recovery_index][1], right); + assert_eq!( + u16::from_le_bytes([ + parity[recovery_index][offset], + parity[recovery_index][offset + 1], + ]), + expected + ); + } + } + } + + #[test] + fn rar5_inline_recovery_parity_splits_and_encodes_prefix() { + let prefix = b"RAR5 inline recovery parity payload input"; + let (plan, parity) = encode_inline_recovery_parity(prefix, 10).unwrap(); + + assert_eq!(plan, plan_inline_recovery(prefix.len() as u64, 10).unwrap()); + assert_eq!(parity.len(), plan.recovery_shards as usize); + assert!(parity + .iter() + .all(|shard| shard.len() == plan.group_count as usize)); + + let data_shards = split_prefix_shards(prefix, plan).unwrap(); + let shard_refs: Vec<&[u8]> = data_shards.iter().map(Vec::as_slice).collect(); + assert_eq!( + parity, + encode_parity_shards(&shard_refs, plan.recovery_shards as usize).unwrap() + ); + } + + #[test] + fn rar5_structural_inline_recovery_data_writes_chunks_and_crc64() { + let prefix = b"RAR5 structural inline recovery data"; + let (plan, parity) = encode_inline_recovery_parity(prefix, 10).unwrap(); + let data = build_structural_inline_recovery_data(prefix, 10).unwrap(); + + assert_eq!(data.len(), plan.payload_size().unwrap() as usize); + for (shard_index, payload) in parity.iter().enumerate() { + let chunk_start = shard_index * plan.shard_size as usize; + let chunk = &data[chunk_start..chunk_start + plan.shard_size as usize]; + assert_eq!(&chunk[..4], b"{RB}"); + assert_eq!( + u64::from_le_bytes(chunk[4..12].try_into().unwrap()), + crc64_xz(&chunk[0x0c..]) + ); + assert_eq!( + u32::from_le_bytes(chunk[0x0c..0x10].try_into().unwrap()) as u64, + plan.shard_size + ); + assert_eq!( + u32::from_le_bytes(chunk[0x10..0x14].try_into().unwrap()) as u64, + plan.header_size + ); + assert_eq!(chunk[0x14], 1); + assert_eq!(chunk[0x15], 1); + assert_eq!( + u64::from_le_bytes(chunk[0x22..0x2a].try_into().unwrap()), + prefix.len() as u64 + ); + assert_eq!( + u16::from_le_bytes(chunk[0x3e..0x40].try_into().unwrap()) as usize, + shard_index + ); + let shard_ranges = split_prefix_shard_ranges(prefix.len(), plan).unwrap(); + assert_eq!( + u32::from_le_bytes(chunk[0x1e..0x22].try_into().unwrap()) as usize, + shard_ranges.last().unwrap().len() + ); + for (data_index, range) in shard_ranges.iter().enumerate() { + let state_offset = 0x40 + data_index * 8; + assert_eq!( + u64::from_le_bytes(chunk[state_offset..state_offset + 8].try_into().unwrap()), + crc64_rar_state(&prefix[range.clone()]) + ); + } + assert_eq!(&chunk[plan.header_size as usize..], payload); + } + } + + #[test] + fn rar5_structural_inline_recovery_round_trips_above_64k_groups() { + let prefix_len = (MAX_WINRAR602_DATA_SHARDS * 0x10000 + 1) as usize; + let prefix: Vec = (0..prefix_len).map(|index| index as u8).collect(); + let plan = plan_inline_recovery(prefix.len() as u64, 1).unwrap(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 1).unwrap(); + + assert_eq!(plan.header_size, 1672); + assert_eq!(plan.group_count, 65_538); + assert_eq!(recovery_data.len(), plan.payload_size().unwrap() as usize); + for shard_index in 0..plan.recovery_shards as usize { + let chunk_start = shard_index * plan.shard_size as usize; + let chunk_end = chunk_start + plan.shard_size as usize; + let chunk = &recovery_data[chunk_start..chunk_end]; + assert_eq!( + u32::from_le_bytes(chunk[0x0c..0x10].try_into().unwrap()) as u64, + plan.shard_size + ); + assert_eq!( + u32::from_le_bytes(chunk[0x10..0x14].try_into().unwrap()) as u64, + plan.header_size + ); + assert_eq!( + u64::from_le_bytes(chunk[0x04..0x0c].try_into().unwrap()), + crc64_xz(&chunk[0x0c..]) + ); + } + + assert_eq!( + repair_inline_recovery_prefix(&prefix, &recovery_data).unwrap(), + prefix + ); + let mut damaged = prefix.clone(); + damaged[0] ^= 0xff; + assert_eq!( + repair_inline_recovery_prefix(&damaged, &recovery_data).unwrap(), + prefix + ); + } + + #[test] + fn rar5_structural_inline_recovery_uses_shared_final_state() { + let prefix: Vec = (0..(256 * 1024)).map(|index| index as u8).collect(); + let (plan, parity) = encode_inline_recovery_parity(&prefix, 20).unwrap(); + assert!(plan.recovery_shards > 1); + let data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let expected = crc64_rar_state(&parity[0]); + + for shard_index in 0..plan.recovery_shards as usize { + let chunk_start = shard_index * plan.shard_size as usize; + let final_state_offset = chunk_start + 0x40 + plan.data_shards as usize * 8; + assert_eq!( + u64::from_le_bytes( + data[final_state_offset..final_state_offset + 8] + .try_into() + .unwrap() + ), + expected + ); + } + } + + #[test] + fn rar5_inline_recovery_rejects_malformed_chunk_fields() { + let valid = build_structural_inline_recovery_data(b"prefix", 10).unwrap(); + let parse = |chunk: &[u8]| { + super::parse_inline_recovery_chunk_with_control( + chunk, + &crate::read_control::ReadControl::default(), + ) + .unwrap_err() + }; + let mut cases = Vec::new(); + cases.push(("short header", valid[..0x47].to_vec())); + let mut wrong_magic = valid.clone(); + wrong_magic[0] = b'X'; + cases.push(("wrong magic", wrong_magic)); + let mut truncated = valid.clone(); + truncated.pop(); + cases.push(("truncated chunk", truncated)); + let mut bad_crc = valid.clone(); + bad_crc[0x40] ^= 1; + cases.push(("bad CRC", bad_crc)); + + let mut altered = |name, edit: fn(&mut Vec)| { + let mut chunk = valid.clone(); + edit(&mut chunk); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + cases.push((name, chunk)); + }; + altered("short declared header", |chunk| { + chunk[0x10..0x14].copy_from_slice(&0x47u32.to_le_bytes()) + }); + altered("header larger than chunk", |chunk| { + let size = u32::try_from(chunk.len()).unwrap() + 1; + chunk[0x10..0x14].copy_from_slice(&size.to_le_bytes()); + }); + altered("wrong format version", |chunk| chunk[0x14] = 2); + altered("wrong record version", |chunk| chunk[0x15] = 2); + altered("wrong shard size", |chunk| chunk[0x32] ^= 1); + altered("out-of-range shard index", |chunk| chunk[0x3e] = 1); + altered("wrong data-state count", |chunk| chunk[0x3a] = 2); + altered("no data shards", |chunk| { + let parity_len = (chunk.len() - 0x48) as u64; + chunk[0x10..0x14].copy_from_slice(&0x48u32.to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&parity_len.to_le_bytes()); + chunk[0x3a..0x3c].copy_from_slice(&0u16.to_le_bytes()); + }); + altered("wrong parity length", |chunk| chunk[0x2a] ^= 2); + altered("no recovery shards", |chunk| chunk[0x3c..0x3e].fill(0)); + + for (name, chunk) in cases { + assert_eq!(parse(&chunk), Error::BadRecoveryChunk, "{name}"); + } + } + + #[test] + fn rar5_recovery_scan_ignores_truncated_markers() { + for data in [&b""[..], &b"{RB"[..], &b"noise{RB}"[..]] { + assert_eq!( + repair_inline_recovery_prefix(b"prefix", data), + Err(Error::BadRecoveryChunk) + ); + } + let valid = build_structural_inline_recovery_data(b"prefix", 10).unwrap(); + let mut data = b"{RB}".to_vec(); + data.extend_from_slice(&valid); + assert_eq!( + repair_inline_recovery_prefix(b"prefix", &data), + Ok(b"prefix".to_vec()) + ); + } + + #[test] + fn rar5_repair_rejects_odd_gf16_shards() { + let mut chunk = build_structural_inline_recovery_data(b"x", 10).unwrap(); + chunk.pop(); + let size = chunk.len() as u32; + chunk[0x0c..0x10].copy_from_slice(&size.to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&1u64.to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&(size as u64).to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + + assert_eq!( + super::parse_inline_recovery_chunk_with_control( + &chunk, + &crate::read_control::ReadControl::default() + ) + .unwrap_err(), + Error::BadRecoveryChunk + ); + assert_eq!( + repair_inline_recovery_prefix(b"y", &chunk), + Err(Error::BadRecoveryChunk) + ); + } + + #[test] + fn rar5_recovery_rejects_shard_counts_above_field_capacity() { + let data_shards = 32_768u16; + let recovery_shards = 32_768u16; + let header_size = 0x48 + data_shards as usize * 8; + let mut chunk = vec![0u8; header_size]; + chunk[..4].copy_from_slice(b"{RB}"); + chunk[0x0c..0x10].copy_from_slice(&(header_size as u32).to_le_bytes()); + chunk[0x10..0x14].copy_from_slice(&(header_size as u32).to_le_bytes()); + chunk[0x14] = 1; + chunk[0x15] = 1; + chunk[0x32..0x3a].copy_from_slice(&(header_size as u64).to_le_bytes()); + chunk[0x3a..0x3c].copy_from_slice(&data_shards.to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&recovery_shards.to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + + assert_eq!( + super::parse_inline_recovery_chunk_with_control( + &chunk, + &crate::read_control::ReadControl::default() + ) + .unwrap_err(), + Error::BadRecoveryChunk + ); + } + + #[test] + fn rar5_repair_rejects_inconsistent_recovery_chunks() { + let prefix = recovery_test_bytes(32_000, 33); + let plan = plan_inline_recovery(prefix.len() as u64, 20).unwrap(); + assert!(plan.recovery_shards > 2); + let valid = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let start = plan.shard_size as usize; + let end = start + plan.shard_size as usize; + for (name, edit) in [ + ("states", 0x40), + ("protected size", 0x22), + ("recovery shard count", 0x3c), + ] { + let mut recovery_data = valid.clone(); + recovery_data[start + edit] ^= 1; + let crc = crc64_xz(&recovery_data[start + 0x0c..end]); + recovery_data[start + 0x04..start + 0x0c].copy_from_slice(&crc.to_le_bytes()); + + assert_eq!( + repair_inline_recovery_prefix(&prefix, &recovery_data), + Err(Error::BadRecoveryChunk), + "{name}" + ); + assert_eq!( + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(prefix[range].to_vec()) + }), + Err(Error::BadRecoveryChunk), + "{name}" + ); + } + } + + #[test] + fn rar5_prefix_repair_checks_protected_size_and_healthy_ranges() { + let prefix = b"prefix"; + let recovery_data = build_structural_inline_recovery_data(prefix, 10).unwrap(); + assert_eq!( + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(prefix[range].to_vec()) + }), + Ok(Vec::new()) + ); + assert_eq!( + repair_inline_recovery_prefix(b"prefix!", &recovery_data), + Err(Error::BadRecoveryChunk) + ); + assert_eq!( + repair_inline_recovery_prefix_shards(prefix.len() + 1, &recovery_data, |_| { + panic!("unexpected read after mismatched protected size") + }), + Err(Error::BadRecoveryChunk) + ); + } + + #[test] + fn rar5_range_repair_preserves_short_and_failed_callback_reads() { + let prefix = recovery_test_bytes(32_000, 41); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut damaged = prefix.clone(); + damaged[0] ^= 1; + + let short_first = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(damaged[range.start..range.end - 1].to_vec()) + }); + assert_eq!(short_first, Err(Error::ShardSizeMismatch)); + let failed_first = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |_| { + Err(Error::Io(std::io::ErrorKind::PermissionDenied)) + }); + assert_eq!( + failed_first, + Err(Error::Io(std::io::ErrorKind::PermissionDenied)) + ); + + let mut reads = 0; + let data_shards = plan_inline_recovery(prefix.len() as u64, 20) + .unwrap() + .data_shards as usize; + let short_second = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + reads += 1; + let end = if reads > data_shards { + range.end - 1 + } else { + range.end + }; + Ok(damaged[range.start..end].to_vec()) + }); + assert_eq!(short_second, Err(Error::ShardSizeMismatch)); + assert!(reads > data_shards); + + reads = 0; + let failed_second = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + reads += 1; + if reads > data_shards { + Err(Error::Io(std::io::ErrorKind::PermissionDenied)) + } else { + Ok(damaged[range].to_vec()) + } + }); + assert_eq!( + failed_second, + Err(Error::Io(std::io::ErrorKind::PermissionDenied)) + ); + assert!(reads > data_shards); + } + + #[test] + fn rar5_range_repair_rejects_damage_beyond_available_parity() { + let prefix = recovery_test_bytes(10_000, 73); + let plan = plan_inline_recovery(prefix.len() as u64, 10).unwrap(); + assert_eq!(plan.recovery_shards, 1); + let recovery_data = build_structural_inline_recovery_data(&prefix, 10).unwrap(); + let mut damaged = prefix.clone(); + damaged[0] ^= 1; + damaged[plan.group_count as usize] ^= 1; + assert_eq!( + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(damaged[range].to_vec()) + }), + Err(Error::TooManyDamagedShards) + ); + } + + #[test] + fn rar5_prefix_repair_rejects_duplicate_parity_rows() { + let prefix = recovery_test_bytes(10_000, 83); + let plan = plan_inline_recovery(prefix.len() as u64, 20).unwrap(); + assert!(plan.recovery_shards >= 2); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let first = &recovery_data[..plan.shard_size as usize]; + let duplicated = [first, first].concat(); + let mut damaged = prefix.clone(); + damaged[0] ^= 1; + damaged[plan.group_count as usize] ^= 1; + assert_eq!( + repair_inline_recovery_prefix(&damaged, &duplicated), + Err(Error::SingularElement) + ); + assert_eq!( + repair_inline_recovery_prefix_shards(prefix.len(), &duplicated, |range| { + Ok(damaged[range].to_vec()) + }), + Err(Error::SingularElement) + ); + } + + #[test] + fn rar5_range_repair_restores_short_final_shard() { + let prefix = recovery_test_bytes(10_001, 79); + let plan = plan_inline_recovery(prefix.len() as u64, 20).unwrap(); + let final_start = (plan.data_shards as usize - 1) * plan.group_count as usize; + assert!(final_start < prefix.len()); + assert!((prefix.len() - final_start) % 2 == 1); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut damaged = prefix.clone(); + damaged[final_start] ^= 1; + let repaired = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(damaged[range].to_vec()) + }) + .unwrap(); + assert_eq!( + repaired, + vec![(final_start..prefix.len(), prefix[final_start..].to_vec())] + ); + } + + #[test] + fn rar5_parity_encoder_rejects_invalid_shard_shapes() { + assert_eq!(encode_parity_shards(&[], 1), Err(Error::TooManyShards)); + assert_eq!( + encode_parity_shards(&[&[1, 2, 3]], 1), + Err(Error::OddShardSize) + ); + assert_eq!( + encode_parity_shards(&[&[1, 2], &[3, 4, 5, 6]], 1), + Err(Error::ShardSizeMismatch) + ); + } + + #[test] + fn rar5_inline_recovery_repairs_single_damaged_data_shard() { + let prefix: Vec = (0..32_000).map(|index| (index * 17) as u8).collect(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut damaged = prefix.clone(); + damaged[1500..1537].fill(0xa5); + + let repaired = repair_inline_recovery_prefix(&damaged, &recovery_data).unwrap(); + + assert_eq!(repaired, prefix); + } + + #[test] + fn rar5_inline_recovery_skips_damaged_recovery_chunks_if_enough_survive() { + let prefix: Vec = (0..32_000).map(|index| (index * 13) as u8).collect(); + let mut recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + recovery_data[0x48] ^= 0xff; + let mut damaged = prefix.clone(); + damaged[1024..1300].fill(0xa5); + + let repaired = repair_inline_recovery_prefix(&damaged, &recovery_data).unwrap(); + + assert_eq!(repaired, prefix); + } + + #[test] + fn rar5_inline_recovery_repairs_multiple_damaged_data_shards() { + let prefix: Vec = (0..128_000).map(|index| (index * 31) as u8).collect(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut damaged = prefix.clone(); + damaged[100..500].fill(0x11); + damaged[4_000..4_400].fill(0x22); + damaged[9_000..9_400].fill(0x33); + + let repaired = repair_inline_recovery_prefix(&damaged, &recovery_data).unwrap(); + + assert_eq!(repaired, prefix); + } + + #[test] + fn rar5_inline_recovery_returns_only_repaired_shard_ranges() { + let prefix: Vec = (0..128_000).map(|index| (index * 29) as u8).collect(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut damaged = prefix.clone(); + damaged[100..500].fill(0x11); + damaged[9_000..9_400].fill(0x33); + + let repaired_shards = + repair_inline_recovery_prefix_shards(prefix.len(), &recovery_data, |range| { + Ok(damaged[range].to_vec()) + }) + .unwrap(); + assert!(!repaired_shards.is_empty()); + + let mut repaired = damaged; + for (range, data) in repaired_shards { + assert_eq!(range.len(), data.len()); + repaired[range].copy_from_slice(&data); + } + + assert_eq!(repaired, prefix); + } + + #[test] + fn rar5_inline_recovery_archive_scans_chunks_and_repairs_prefix() { + let prefix: Vec = (0..32_000).map(|index| (index * 13) as u8).collect(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut archive = prefix.clone(); + archive.extend_from_slice(b"service header bytes before chunks"); + archive.extend_from_slice(&recovery_data); + archive.extend_from_slice(b"end bytes"); + let mut damaged = archive.clone(); + damaged[256..320].fill(0x5a); + + let repaired = repair_inline_recovery_archive(&damaged).unwrap(); + + assert_eq!(repaired, archive); + } + + #[test] + fn rar5_inline_recovery_rebuilds_a_record_above_one_hundred_percent() { + // WinRAR takes -rr up to 1000%, so a record can hold more recovery + // shards than data shards. plan_inline_recovery never produces one, + // and a rebuild that works back from a percentage cannot match it. + let prefix: Vec = (0..32_000).map(|index| (index * 13) as u8).collect(); + let mut plan = plan_inline_recovery(prefix.len() as u64, 100).unwrap(); + plan.recovery_shards = plan.data_shards * 3; + let recovery_data = build_inline_recovery_data_for_plan(&prefix, plan).unwrap(); + let mut archive = prefix.clone(); + archive.extend_from_slice(b"service header bytes before chunks"); + let record_start = archive.len(); + archive.extend_from_slice(&recovery_data); + archive.extend_from_slice(b"end bytes"); + + let mut damaged = archive.clone(); + damaged[256..320].fill(0x5a); + damaged[record_start + 0x48] ^= 0xff; + + let repaired = repair_inline_recovery_archive(&damaged).unwrap(); + + assert_eq!(repaired, archive); + } + + #[test] + fn rar5_inline_recovery_picks_the_outermost_record() { + // A stored archive nested inside this one has its own {RB} chunks, and + // they sit earlier in the file than ours. + let inner_prefix: Vec = (0..16_000).map(|index| (index * 7) as u8).collect(); + let mut inner = inner_prefix.clone(); + inner.extend_from_slice(&build_structural_inline_recovery_data(&inner_prefix, 20).unwrap()); + + let mut prefix = b"outer archive header bytes".to_vec(); + prefix.extend_from_slice(&inner); + prefix.extend_from_slice(&recovery_test_bytes(9_000, 5)); + let mut archive = prefix.clone(); + archive.extend_from_slice(b"service header bytes before chunks"); + let record_start = archive.len(); + archive.extend_from_slice(&build_structural_inline_recovery_data(&prefix, 20).unwrap()); + archive.extend_from_slice(b"end bytes"); + + let mut damaged = archive.clone(); + damaged[record_start + 0x48] ^= 0xff; + + let repaired = repair_inline_recovery_archive(&damaged).unwrap(); + + assert_eq!(repaired, archive); + } + + #[test] + fn rar5_inline_recovery_archive_accepts_healthy_archive() { + let prefix: Vec = (0..32_000).map(|index| (index * 17) as u8).collect(); + let recovery_data = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut archive = prefix.clone(); + archive.extend_from_slice(b"service header bytes before chunks"); + archive.extend_from_slice(&recovery_data); + archive.extend_from_slice(b"end bytes"); + + let repaired = repair_inline_recovery_archive(&archive).unwrap(); + + assert_eq!(repaired, archive); + } + + #[test] + fn rar5_archive_repair_rejects_impossible_protected_ranges() { + let chunk = build_structural_inline_recovery_data(b"x", 10).unwrap(); + assert_eq!( + repair_inline_recovery_archive(&chunk), + Err(Error::BadRecoveryChunk) + ); + + let mut beyond_end = chunk.clone(); + let protected_size = beyond_end.len() as u64 + 1; + beyond_end[0x22..0x2a].copy_from_slice(&protected_size.to_le_bytes()); + let crc = crc64_xz(&beyond_end[0x0c..]); + beyond_end[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + assert_eq!( + repair_inline_recovery_archive(&beyond_end), + Err(Error::BadRecoveryChunk) + ); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn rar5_archive_repair_rejects_protected_size_above_native_range() { + let mut chunk = build_structural_inline_recovery_data(b"x", 10).unwrap(); + chunk[0x22..0x2a].copy_from_slice(&(u32::MAX as u64 + 1).to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + assert_eq!( + repair_inline_recovery_archive(&chunk), + Err(Error::PlanOverflow) + ); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn rar5_archive_repair_rejects_native_payload_and_offset_overflows() { + let mut chunk = build_structural_inline_recovery_data(b"x", 10).unwrap(); + let group_count = 65_536u64; + let shard_size = 80 + group_count; + chunk.resize(shard_size as usize, 0); + chunk[0x0c..0x10].copy_from_slice(&(shard_size as u32).to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&group_count.to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&shard_size.to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&(u16::MAX - 1).to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + let mut archive = b"x".to_vec(); + archive.extend_from_slice(&chunk); + assert_eq!( + repair_inline_recovery_archive(&archive), + Err(Error::PlanOverflow) + ); + chunk[0x3e..0x40].copy_from_slice(&(u16::MAX - 2).to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + archive.truncate(1); + archive.extend_from_slice(&chunk); + assert_eq!( + repair_inline_recovery_archive(&archive), + Err(Error::BadRecoveryChunk) + ); + + let mut chunk = build_structural_inline_recovery_data(b"abcd", 10).unwrap(); + let group_count = 65_458u64; + let shard_size = 80 + group_count; + assert_eq!((u16::MAX as u64 - 1) * shard_size, u32::MAX as u64 - 3); + chunk.resize(shard_size as usize, 0); + chunk[0x0c..0x10].copy_from_slice(&(shard_size as u32).to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&group_count.to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&shard_size.to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&(u16::MAX - 1).to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + let mut archive = b"abcd".to_vec(); + archive.extend_from_slice(&chunk); + assert_eq!( + repair_inline_recovery_archive(&archive), + Err(Error::PlanOverflow) + ); + } + + #[test] + fn rar5_archive_repair_rejects_missing_chunks_and_invalid_end_header_source() { + assert_eq!( + repair_inline_recovery_archive(b"no recovery chunks"), + Err(Error::BadRecoveryChunk) + ); + + let prefix = b"not a RAR archive"; + let mut archive = prefix.to_vec(); + archive.extend_from_slice(&build_structural_inline_recovery_data(prefix, 10).unwrap()); + assert_eq!( + repair_inline_recovery_archive(&archive), + Err(Error::BadRecoveryChunk) + ); + + let options = super::InlineRepairOptions { + record_range: Some(0..0), + ..Default::default() + }; + assert_eq!( + super::repair_inline_recovery_archive_with_report(&archive, &options).unwrap_err(), + Error::BadRecoveryChunk + ); + } + + #[test] + fn rar5_end_header_errors_preserve_cancellation() { + assert_eq!( + super::map_recovery_end_error(crate::Error::Cancelled), + Error::Cancelled + ); + assert_eq!( + super::map_recovery_end_error(crate::Error::WrongPasswordOrCorruptData), + Error::BadRecoveryChunk + ); + } + + #[test] + fn rar5_record_rebuild_checks_resource_and_record_length() { + let control = crate::read_control::ReadControl::default(); + let impossible = InlineRecoveryPlan { + data_shards: 1, + recovery_shards: u64::MAX, + group_count: 2, + header_size: 80, + shard_size: 82, + }; + assert_eq!( + super::rebuild_inline_recovery_record_with_control( + &[], + b"x", + 0..0, + impossible, + &control + ), + Err(Error::PlanOverflow) + ); + let huge = InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1000, + group_count: 2_000_000, + header_size: 80, + shard_size: 2_000_080, + }; + assert_eq!( + super::rebuild_inline_recovery_record_with_control(&[], b"x", 0..0, huge, &control), + Err(Error::RebuildTooLarge) + ); + + let plan = plan_inline_recovery(1, 10).unwrap(); + assert_eq!( + super::rebuild_inline_recovery_record_with_control(&[], b"x", 0..0, plan, &control), + Err(Error::BadRecoveryChunk) + ); + } + + #[test] + fn rar5_archive_repair_keeps_prefix_when_record_rebuild_exceeds_limit() { + let mut chunk = build_structural_inline_recovery_data(b"x", 10).unwrap(); + let group_count = 8192u64; + let shard_size = 80 + group_count; + let recovery_shards = u16::MAX - 1; + chunk.resize(shard_size as usize, 0); + chunk[0x0c..0x10].copy_from_slice(&(shard_size as u32).to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&group_count.to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&shard_size.to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&recovery_shards.to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[0x04..0x0c].copy_from_slice(&crc.to_le_bytes()); + + let mut archive = b"x".to_vec(); + archive.extend_from_slice(&chunk); + let (repaired, report) = super::repair_inline_recovery_archive_with_report( + &archive, + &super::InlineRepairOptions::default(), + ) + .unwrap(); + assert_eq!(repaired, archive); + assert!(!report.changed); + assert!(!report.recovery_record_rebuilt); + assert_eq!(report.available_recovery_shards, Some(1)); + assert_eq!( + report.expected_recovery_shards, + Some(recovery_shards as u64) + ); + } + + #[test] + fn rar5_inline_recovery_rejects_unrepairable_damage_count() { + let prefix = b"small prefix with only one parity shard".repeat(100); + let recovery_data = build_structural_inline_recovery_data(&prefix, 1).unwrap(); + let mut damaged = prefix.clone(); + damaged[0] ^= 0xff; + damaged[1024] ^= 0xff; + + assert_eq!( + repair_inline_recovery_prefix(&damaged, &recovery_data), + Err(Error::TooManyDamagedShards) + ); + } + + #[test] + fn rar5_reconstruct_data_shards_repairs_missing_shards_from_parity() { + let first = b"abcdefgh".to_vec(); + let second = b"ijklmnop".to_vec(); + let third = b"qrstuvwx".to_vec(); + let refs = [first.as_slice(), second.as_slice(), third.as_slice()]; + let parity = encode_parity_shards(&refs, 2).unwrap(); + + let reconstructed = reconstruct_data_shards( + &[Some(&first), None, Some(&third)], + &[(0, parity[0].as_slice())], + ) + .unwrap(); + + assert_eq!(reconstructed[0], first); + assert_eq!(reconstructed[1], second); + assert_eq!(reconstructed[2], third); + } + + #[test] + fn rar5_reconstruct_data_shards_validates_shapes_and_missing_count() { + assert_eq!(reconstruct_data_shards(&[], &[]), Err(Error::TooManyShards)); + assert_eq!( + reconstruct_data_shards(&[None], &[]), + Err(Error::TooManyDamagedShards) + ); + assert_eq!( + reconstruct_data_shards(&[Some(&[1, 2, 3])], &[]), + Err(Error::OddShardSize) + ); + assert_eq!( + reconstruct_data_shards(&[None], &[(0, &[1, 2]), (1, &[3, 4, 5, 6])]), + Err(Error::ShardSizeMismatch) + ); + assert_eq!( + reconstruct_data_shards(&[Some(&[1, 2, 3, 4]), None], &[(0, &[5, 6])]), + Err(Error::ShardSizeMismatch) + ); + assert_eq!( + reconstruct_data_shards(&[None, None], &[(0, &[1, 2])]), + Err(Error::TooManyDamagedShards) + ); + assert_eq!( + reconstruct_data_shards(&[None], &[(usize::MAX, &[1, 2])]), + Err(Error::TooManyShards) + ); + let mut data_shards = vec![vec![0, 0]]; + assert_eq!( + super::recover_damaged_shards(&mut data_shards, &[0], &[(usize::MAX, &[1, 2])]), + Err(Error::TooManyShards) + ); + assert_eq!( + super::recover_damaged_shards(&mut data_shards, &[0], &[]), + Err(Error::TooManyDamagedShards) + ); + assert_eq!( + reconstruct_data_shards(&[None], &[(super::FIELD_SIZE - 1, &[1, 2])]), + Err(Error::TooManyShards) + ); + assert_eq!( + reconstruct_data_shards(&[Some(&[1, 2]), Some(&[3])], &[]), + Ok(vec![vec![1, 2], vec![3, 0]]) + ); + } + + #[test] + fn rar5_reconstruct_data_shards_repairs_multiple_missing_shards() { + let first = b"abcdefgh".to_vec(); + let second = b"ijklmnop".to_vec(); + let third = b"qrstuvwx".to_vec(); + let refs = [first.as_slice(), second.as_slice(), third.as_slice()]; + let parity = encode_parity_shards(&refs, 2).unwrap(); + + assert_eq!( + reconstruct_data_shards( + &[None, Some(&second), None], + &[(0, parity[0].as_slice()), (0, parity[0].as_slice())] + ), + Err(Error::SingularElement) + ); + + let reconstructed = reconstruct_data_shards( + &[None, Some(&second), None], + &[(0, parity[0].as_slice()), (1, parity[1].as_slice())], + ) + .unwrap(); + + assert_eq!(reconstructed[0], first); + assert_eq!(reconstructed[1], second); + assert_eq!(reconstructed[2], third); + } +} + +fn check_repair(control: &crate::read_control::ReadControl) -> Result<()> { + control.check().map_err(|_| Error::Cancelled) +} +fn repair_crc( + data: &[u8], + initial: u64, + control: &crate::read_control::ReadControl, +) -> Result { + let mut state = initial; + for chunk in data.chunks(64 * 1024) { + check_repair(control)?; + state = crc64_update(chunk, state); + } + Ok(state) +} +fn repair_marker( + input: &[u8], + control: &crate::read_control::ReadControl, +) -> Result> { + for start in (0..input.len()).step_by(64 * 1024) { + check_repair(control)?; + let end = (start + 64 * 1024 + 3).min(input.len()); + if let Some(offset) = find_recovery_marker(&input[start..end]) { + return Ok(Some(start + offset)); + } + } + Ok(None) +} + +#[cfg(test)] +mod repair_workspace_tests { + use super::*; + + #[test] + fn rar5_repair_admits_discovery_reads_before_calling_range_reader() { + let prefix = b"data"; + let plan = InlineRecoveryPlan { + data_shards: 1, + recovery_shards: 1, + group_count: 4, + header_size: 80, + shard_size: 84, + }; + let chunk = build_inline_recovery_data_for_plan(prefix, plan).unwrap(); + let control = crate::read_control::ReadControl::default(); + let required = repair_solve_workspace_required(1, 0, 4, 0, 4).unwrap(); + let unexpected_read = |_| -> Result> { + panic!("discovery must be refused before requesting range bytes") + }; + assert_eq!( + repair_inline_recovery_prefix_shards_with_workspace_limit( + prefix.len(), + &chunk, + unexpected_read, + &control, + required - 1, + ), + Err(Error::RepairWorkspaceLimitExceeded { + limit: required - 1, + required, + }) + ); + assert_eq!( + repair_inline_recovery_prefix_shards_with_workspace_limit( + prefix.len(), + &chunk, + |range| Ok(prefix[range].to_vec()), + &control, + required, + ), + Ok(Vec::new()) + ); + // Discovery fits, but the solve and repaired output do not. It must + // stop after discovery rather than reread undamaged RHS shards. + let mut reads = 0; + let result = repair_inline_recovery_prefix_shards_with_workspace_limit( + prefix.len(), + &chunk, + |range| { + reads += 1; + Ok(b"fail"[range].to_vec()) + }, + &control, + required, + ); + assert_eq!(reads, 1); + assert!(matches!(result, + Err(Error::RepairWorkspaceLimitExceeded { limit, required: solve }) + if limit == required && solve > required + )); + let token = crate::ReadCancellation::new(); + token.cancel(); + assert_eq!( + repair_inline_recovery_prefix_shards_with_workspace_limit( + prefix.len(), + &chunk, + unexpected_read, + &crate::read_control::ReadControl::new(Some(&token)), + 0, + ), + Err(Error::Cancelled) + ); + } + + #[test] + fn rar5_repair_workspace_admission_is_checked_and_inclusive() { + let limit = super::REPAIR_WORKSPACE_FLOOR_BYTES; + assert_eq!(super::admit_repair_workspace(limit, 0), Ok(())); + let refusal = Error::RepairWorkspaceLimitExceeded { + limit, + required: limit + 1, + }; + assert_eq!( + super::admit_repair_workspace(limit + 1, 0), + Err(refusal.clone()) + ); + let typed = crate::Error::from(refusal.clone()).at_archive_offset(42); + assert_eq!(typed.kind(), crate::ErrorKind::ResourceLimit); + assert!( + matches!(typed.root_cause(), crate::Error::Rar5Recovery(actual) if actual == &refusal) + ); + assert!(typed.to_string().contains("repair workspace limit")); + assert_eq!( + super::repair_solve_workspace_required(1, 1, 0, u64::MAX, 0), + Err(Error::PlanOverflow) + ); + assert_eq!( + super::repair_workspace_product(u64::MAX, 2), + Err(Error::PlanOverflow) + ); + // Ordinary generated geometry still fits even with all 200 shards + // damaged, full output buffers and read scratch. + let required = + super::repair_solve_workspace_required(200, 200, 1024, 200 * 1024, 1024).unwrap(); + assert_eq!(super::admit_repair_workspace(required, 0), Ok(())); + } + + #[test] + fn rar5_repair_workspace_scales_with_genuine_input() { + const MIB: u64 = 1024 * 1024; + // A REV set of five 100 MiB volumes, one missing, with two REV files: + // padded output alone exceeds the floor, yet master rebuilt it. + let volume = 100 * MIB as usize; + let required = + super::repair_solve_workspace_required(5, 1, volume, 5 * volume as u64, 0).unwrap(); + assert!(required > super::REPAIR_WORKSPACE_FLOOR_BYTES); + assert_eq!( + super::admit_repair_workspace(required, 4 * 100 * MIB + 2 * 100 * MIB), + Ok(()) + ); + + // A 10 GiB archive with a 10% record has 51 MiB shards; repairing all + // 20 recoverable shards must fit beside the archive and its record. + let archive = 10 * 1024 * MIB; + let shard = archive.div_ceil(200) as usize; + let required = + super::repair_solve_workspace_required(200, 20, shard, 20 * shard as u64, shard) + .unwrap(); + assert!(required > super::REPAIR_WORKSPACE_FLOOR_BYTES); + assert_eq!( + super::admit_repair_workspace(required, archive + archive / 10), + Ok(()) + ); + + // The multiple still refuses records declaring far more than they hold. + let input = super::REPAIR_WORKSPACE_FLOOR_BYTES; + assert!(matches!( + super::admit_repair_workspace(4 * input + 1, input), + Err(Error::RepairWorkspaceLimitExceeded { .. }) + )); + } + + #[test] + fn rar5_tiny_incomplete_record_keeps_repaired_prefix_without_giant_rebuild() { + // One 128 KiB chunk declares 16,000 recovery rows. Only 32 KiB of + // parity would be rebuilt, but its full coefficient matrix is almost + // 0.5 GiB and repeated headers would produce a 1.9 GiB recovery record. + // Frame this one chunk directly, without generating the claimed rows. + let data_count = 16_000usize; + let recovery_count = 16_000usize; + let header_size = 0x48 + data_count * 8; + let shard_size = header_size + 2; + let mut chunk = vec![0; shard_size]; + chunk[..4].copy_from_slice(b"{RB}"); + chunk[0x0c..0x10].copy_from_slice(&(shard_size as u32).to_le_bytes()); + chunk[0x10..0x14].copy_from_slice(&(header_size as u32).to_le_bytes()); + chunk[0x14] = 1; + chunk[0x15] = 1; + chunk[0x22..0x2a].copy_from_slice(&1u64.to_le_bytes()); + chunk[0x2a..0x32].copy_from_slice(&2u64.to_le_bytes()); + chunk[0x32..0x3a].copy_from_slice(&(shard_size as u64).to_le_bytes()); + chunk[0x3a..0x3c].copy_from_slice(&(data_count as u16).to_le_bytes()); + chunk[0x3c..0x3e].copy_from_slice(&(recovery_count as u16).to_le_bytes()); + chunk[0x40..0x48].copy_from_slice(&crc64_rar_state(b"a").to_le_bytes()); + let gf = shared_gf16(); + let parity = gf.mul(gf.inv(data_count as u16).unwrap(), b'a' as u16); + chunk[header_size..].copy_from_slice(&parity.to_le_bytes()); + let crc = crc64_xz(&chunk[0x0c..]); + chunk[4..0x0c].copy_from_slice(&crc.to_le_bytes()); + + let mut archive = b"b".to_vec(); + archive.extend_from_slice(&chunk); + let repaired = super::repair_inline_recovery_archive(&archive).unwrap(); + assert_eq!(repaired.len(), archive.len()); + assert_eq!(repaired[0], b'a'); + assert_eq!(&repaired[1..], &archive[1..]); + let (reported, report) = super::repair_inline_recovery_archive_with_report( + &archive, + &super::InlineRepairOptions::default(), + ) + .unwrap(); + assert_eq!(reported, repaired); + assert!(report.changed); + assert!(report.data_repaired); + assert!(!report.recovery_record_rebuilt); + assert!(!report.end_record_rebuilt); + assert_eq!(report.available_recovery_shards, Some(1)); + assert_eq!(report.expected_recovery_shards, Some(recovery_count as u64)); + + let plan = InlineRecoveryPlan { + data_shards: data_count as u64, + recovery_shards: recovery_count as u64, + group_count: 2, + header_size: header_size as u64, + shard_size: shard_size as u64, + }; + let end = 1 + plan.payload_size().unwrap() as usize; + assert!(matches!( + super::rebuild_inline_recovery_record_with_control( + &archive, + b"a", + 1..end, + plan, + &crate::read_control::ReadControl::default(), + ), + Err(Error::RepairWorkspaceLimitExceeded { limit, required }) + if limit == super::REPAIR_WORKSPACE_FLOOR_BYTES && required > limit + )); + let token = crate::ReadCancellation::new(); + token.cancel(); + let control = crate::read_control::ReadControl::new(Some(&token)); + assert_eq!( + super::rebuild_inline_recovery_record_with_control( + &archive, + b"a", + 1..end, + plan, + &control + ), + Err(Error::Cancelled) + ); + } + + #[test] + fn rar5_reconstruction_admits_padded_output_and_all_solve_matrices() { + // Less than 1 MiB of caller metadata and 8 KiB of parity used to + // allocate 512 MiB of zero padding before the solve was considered. + let empty = &[][..]; + let mut data = vec![Some(empty); super::FIELD_SIZE - 1]; + data[0] = None; + let parity = vec![0; 8192]; + assert!(matches!( + reconstruct_data_shards(&data, &[(0, &parity)]), + Err(Error::RepairWorkspaceLimitExceeded { limit, required }) + if limit == super::REPAIR_WORKSPACE_FLOOR_BYTES && required > limit + )); + + // Tiny two-byte shards can still ask for hundreds of MiB across + // original equations, their working copy and the inverse together. + let count = 7000; + let data = vec![None; count]; + let recovery = (0..count).map(|row| (row, &[0, 0][..])).collect::>(); + assert!(matches!( + reconstruct_data_shards(&data, &recovery), + Err(Error::RepairWorkspaceLimitExceeded { limit, required }) + if limit == super::REPAIR_WORKSPACE_FLOOR_BYTES && required > limit + )); + } + + #[test] + fn rar5_reconstruction_validates_before_oversized_padding() { + let parity = vec![0; 8192]; + let missing = vec![None; super::FIELD_SIZE - 1]; + assert_eq!( + reconstruct_data_shards(&missing, &[(0, &parity)]), + Err(Error::TooManyDamagedShards) + ); + let mut data = vec![Some(&[][..]); super::FIELD_SIZE - 1]; + data[0] = None; + assert_eq!( + reconstruct_data_shards(&data, &[(usize::MAX, &parity)]), + Err(Error::TooManyShards) + ); + let long = vec![0; parity.len() + 1]; + *data.last_mut().unwrap() = Some(&long); + assert_eq!( + reconstruct_data_shards(&data, &[(0, &parity)]), + Err(Error::ShardSizeMismatch) + ); + assert_eq!( + reconstruct_data_shards(&vec![Some(&[][..]); super::FIELD_SIZE + 1], &[]), + Err(Error::TooManyShards) + ); + } +} + +#[cfg(test)] +mod cancellation_tests { + use super::*; + + fn scheduled(checks: usize) -> crate::read_control::ReadControl { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(checks); + control + } + + #[test] + fn cancellation_stops_marker_search_and_chunk_checksums() { + let noise = vec![0; 256 * 1024]; + assert_eq!( + find_inline_recovery_chunks_with_control(&noise, &scheduled(2)).unwrap_err(), + Error::Cancelled + ); + let prefix = vec![42; 256 * 1024]; + let data = build_structural_inline_recovery_data(&prefix, 10).unwrap(); + assert_eq!( + parse_inline_recovery_chunk_with_control(&data, &scheduled(1)).unwrap_err(), + Error::Cancelled + ); + } + + #[test] + fn cancellation_stops_reconstruction_and_record_rebuilding() { + let prefix = vec![42; 128 * 1024]; + let plan = plan_inline_recovery(prefix.len() as u64, 10).unwrap(); + let mut shards = split_prefix_shards(&prefix, plan).unwrap(); + let refs: Vec<_> = shards.iter().map(Vec::as_slice).collect(); + let parity = encode_parity_shards(&refs, plan.recovery_shards as usize).unwrap(); + shards[0].fill(0); + assert_eq!( + recover_damaged_shards_with_control( + &mut shards, + &[0], + &[(0, &parity[0])], + &scheduled(2) + ) + .unwrap_err(), + Error::Cancelled + ); + assert_eq!( + build_inline_recovery_data_for_plan_with_control(&prefix, plan, &scheduled(2)) + .unwrap_err(), + Error::Cancelled + ); + } + + #[test] + fn cancellation_stops_selected_equation_generation_and_inverse_application() { + let damaged: Vec<_> = (0..128).collect(); + let rows: Vec<_> = (0..128).map(|row| (row, &[][..])).collect(); + assert_eq!( + recovery_equations(shared_gf16(), 128, &damaged, &rows, &scheduled(2)).unwrap_err(), + Error::Cancelled + ); + let inverse = vec![vec![1; 128]; 128]; + assert_eq!( + apply_inverse_matrix_with_control(shared_gf16(), &inverse, &[1; 128], &scheduled(2)) + .unwrap_err(), + Error::Cancelled + ); + } + + #[test] + fn raw_repair_never_tolerates_cancellation_as_a_failed_record_rebuild() { + let prefix = vec![42; 20_000]; + let recovery = build_structural_inline_recovery_data(&prefix, 20).unwrap(); + let mut archive = prefix; + let record_start = archive.len(); + archive.extend_from_slice(&recovery); + archive.extend_from_slice(b"end bytes"); + let expected = archive.clone(); + // Damage one recovery chunk; surviving chunks can rebuild the record. + archive[record_start + 0x48] ^= 1; + let mut cancelled = 0; + let mut completed = 0; + for checks in (0..256).chain([usize::MAX]) { + let token = crate::ReadCancellation::new(); + let control = crate::read_control::ReadControl::new(Some(&token)); + control.cancel_after_checks(checks); + let options = InlineRepairOptions { + control: control.clone(), + ..Default::default() + }; + let result = repair_inline_recovery_archive_with_report(&archive, &options); + match result { + Err(Error::Cancelled) => cancelled += 1, + Ok((data, report)) => { + assert!(!token.is_cancelled()); + assert_eq!(data, expected); + assert!(report.recovery_record_rebuilt); + completed += 1; + } + other => panic!("unexpected repair result: {other:?}"), + } + } + assert!(cancelled > 0 && completed > 0); + } + + #[test] + fn recovery_cancellation_has_the_public_cancelled_error_kind() { + assert_eq!( + crate::Error::from(Error::Cancelled), + crate::Error::Cancelled + ); + assert_eq!( + crate::Error::Rar5Recovery(Error::Cancelled).kind(), + crate::ErrorKind::Cancelled + ); + } +} + +#[cfg(all(test, feature = "write"))] +#[test] +fn missing_end_header_repair_preserves_an_active_cancellation_token() { + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50) + .store(true) + .recovery_percent(Some(20)); + builder + .add_bytes( + b"recoverable".to_vec(), + b"protected payload".to_vec(), + None, + None, + ) + .unwrap(); + let original = builder.to_bytes().unwrap(); + let archive = crate::rar50::Archive::parse(&original).unwrap(); + let end_start = archive + .blocks + .iter() + .find_map(|block| match block { + crate::rar50::Block::End(end) => Some(end.block.offset), + _ => None, + }) + .unwrap(); + let truncated = &original[..end_start]; + let token = crate::ReadCancellation::new(); + let options = InlineRepairOptions { + control: crate::read_control::ReadControl::new(Some(&token)), + ..Default::default() + }; + let (repaired, report) = + repair_inline_recovery_archive_with_report(truncated, &options).unwrap(); + assert!(!token.is_cancelled()); + assert!(report.end_record_rebuilt); + assert_eq!(repaired, original); + token.cancel(); + assert_eq!( + repair_inline_recovery_archive_with_report(truncated, &options).unwrap_err(), + Error::Cancelled + ); +} diff --git a/arca-rar/vendor/rars/src/rewrite.rs b/arca-rar/vendor/rars/src/rewrite.rs new file mode 100644 index 00000000..4b5290a7 --- /dev/null +++ b/arca-rar/vendor/rars/src/rewrite.rs @@ -0,0 +1,642 @@ +//! Conservative preflight for the currently supported rewrite model. + +use crate::{Archive, ArchiveMemberMeta, AttrSource}; +use std::collections::HashSet; + +impl Archive { + /// Decodes comments in member order with one metadata traversal. Like + /// `member_comment_at`, this does not retain resource limits from parsing. + pub fn member_comments(&self, password: Option<&[u8]>) -> crate::Result>>> { + match self { + Archive::Rar13(a) => a.entries.iter().map(|entry| entry.file_comment()).collect(), + Archive::Rar15To40(a) => a.files().map(|file| file.file_comment()).collect(), + Archive::Rar50Plus(a) => { + let mut comments: Vec> = Vec::new(); + for block in &a.blocks { + match block { + crate::rar50::Block::File(_) => comments.push(None), + crate::rar50::Block::Service(service) if service.name == b"CMT" => { + if let Some(comment) = comments.last_mut() { + if comment.replace(service).is_some() { + return Err(crate::Error::InvalidHeader( + "duplicate member comment records", + )); + } + } + } + _ => {} + } + } + comments + .into_iter() + .map(|comment| { + comment + .map(|service| { + let mut data = Vec::new(); + service.write_to(a, password, &mut data)?; + Ok(data) + }) + .transpose() + }) + .collect() + } + } + } + + /// Decodes a member comment by original archive index, including directories. + /// Missing comments return `None`; an invalid index returns `EntryNotFound`. + /// Duplicate RAR5 CMT records are refused rather than silently dropping one. + /// This helper does not retain parsing/extraction resource policies. + pub fn member_comment_at( + &self, + index: usize, + password: Option<&[u8]>, + ) -> crate::Result>> { + match self { + Archive::Rar13(a) => a + .entries + .get(index) + .ok_or(crate::Error::EntryNotFound)? + .file_comment(), + Archive::Rar15To40(a) => a + .files() + .nth(index) + .ok_or(crate::Error::EntryNotFound)? + .file_comment(), + Archive::Rar50Plus(a) => { + let mut current = None; + let mut next = 0; + let mut found = false; + let mut comment = None; + for block in &a.blocks { + match block { + crate::rar50::Block::File(_) => { + if found { + break; + } + current = Some(next); + next += 1; + found = current == Some(index); + } + crate::rar50::Block::Service(service) + if current == Some(index) && service.name == b"CMT" => + { + if comment.is_some() { + return Err(crate::Error::InvalidHeader( + "duplicate member comment records", + )); + } + comment = Some(service); + } + _ => {} + } + } + if !found { + return Err(crate::Error::EntryNotFound); + } + comment + .map(|service| { + let mut data = Vec::new(); + service.write_to(a, password, &mut data)?; + Ok(data) + }) + .transpose() + } + } + } + + /// Decode the native target bytes carried as a legacy Unix symlink payload. + /// This never follows a filesystem link. Payload integrity is checked. + pub fn legacy_symlink_target_at( + &self, + index: usize, + password: Option<&[u8]>, + ) -> crate::Result>> { + let member = self + .members() + .nth(index) + .ok_or(crate::Error::EntryNotFound)?; + if !member.is_legacy_unix_symlink() { + return Ok(None); + } + let target = self + .read_member_at(index, password)? + .ok_or(crate::Error::EntryNotFound)?; + validate_legacy_link_target(&target, &member.meta.name)?; + Ok(Some(target)) + } + + /// Decode all legacy Unix link targets with one controlled traversal. + /// Results follow original member order, including `None` for directories, + /// ordinary files and modern redirections. No payloads are read when there + /// are no legacy links. This never follows filesystem links. + /// + /// Independent non-link payloads are skipped. Solid predecessors through the + /// last link are decoded and verified, but discarded. All collected targets + /// must pass integrity and target validation before any are returned. Targets + /// are retained in memory; this password-only helper uses default extraction + /// policies and does not retain limits supplied during parsing. + pub fn legacy_symlink_targets( + &self, + password: Option<&[u8]>, + ) -> crate::Result>>> { + use crate::{ArchiveReadOptions, Error, ExtractionDecision, SharedBuffer}; + use std::sync::{Arc, Mutex}; + + let Archive::Rar15To40(legacy) = self else { + return Ok(self.members().map(|_| None).collect()); + }; + let members: Vec<_> = self.members().collect(); + let Some(last) = members + .iter() + .rposition(|member| member.is_legacy_unix_symlink()) + else { + return Ok((0..members.len()).map(|_| None).collect()); + }; + let mut targets: Vec> = (0..members.len()).map(|_| None).collect(); + let solid = legacy.main.is_solid(); + let mut index = 0; + self.extract_with_control( + ArchiveReadOptions::with_optional_password(password), + |member| { + let current = index; + index += 1; + if current > last { + return Ok(ExtractionDecision::Stop); + } + // Finding a legacy link above confines this traversal to + // RAR1.5–4, whose member metadata has no redirection flag. + if member.is_legacy_unix_symlink() { + let bytes = Arc::new(Mutex::new(Some(Vec::new()))); + targets[current] = Some(SharedBuffer(bytes.clone())); + Ok(ExtractionDecision::Extract(Box::new(SharedBuffer(bytes)))) + } else if solid && !member.meta.is_directory { + Ok(ExtractionDecision::Extract(Box::new(std::io::sink()))) + } else { + Ok(ExtractionDecision::Skip) + } + }, + )?; + targets + .into_iter() + .zip(members) + .map(|(target, member)| { + if !member.is_legacy_unix_symlink() { + return Ok(None); + } + let target = + target + .and_then(|target| target.lock().take()) + .ok_or(Error::InvalidHeader( + "legacy link target disappeared while reading", + ))?; + validate_legacy_link_target(&target, &member.meta.name)?; + Ok(Some(target)) + }) + .collect() + } + + /// Configure a builder with supported source format, solid and encryption settings. + /// Member data/comment passwords are retained separately when entries are copied. + pub fn preserving_builder(&self, password: Option<&[u8]>) -> crate::Result { + let issues = self.rewrite_preservation_issues(); + if !issues.is_empty() { + return Err(crate::Error::InvalidArgument( + "archive has unsupported preservation settings", + )); + } + match self { + Archive::Rar13(archive) => { + let password = if archive.entries.iter().any(|entry| entry.is_encrypted()) { + Some( + password + .filter(|value| !value.is_empty()) + .ok_or(crate::Error::NeedPassword)? + .to_vec(), + ) + } else { + None + }; + Ok(crate::Builder::new(crate::ArchiveVersion::Rar14) + .compression_level(Some(3)) + .solid(archive.main.is_solid()) + .password(password)) + } + Archive::Rar15To40(archive) => { + let encrypted = archive.main.has_encrypted_headers() + || archive.files().any(|file| file.is_encrypted()) + || archive.new_subs().any(|sub| sub.file.is_encrypted()); + let password = if encrypted { + Some( + password + .filter(|password| !password.is_empty()) + .ok_or(crate::Error::NeedPassword)? + .to_vec(), + ) + } else { + None + }; + let version = archive.preservation_version(); + Ok(crate::Builder::new(version) + .compression_level(Some(3)) + .legacy_unpack_version( + (version == crate::ArchiveVersion::Rar20 + && archive.files().any(|file| file.unp_ver == 26)) + .then_some(26), + ) + .solid(archive.main.is_solid()) + // Preflight accepts only CMT new-sub records, and at most one. + .archive_comment_password( + archive + .new_subs() + .any(|sub| sub.file.is_encrypted()) + .then(|| password.clone()) + .flatten(), + ) + .password(password) + .header_encryption(archive.main.has_encrypted_headers()) + .legacy_archive_comment_metadata( + archive + .new_subs() + .next() + .map(|sub| (sub.file.file_time, sub.file.host_os)), + )) + } + Archive::Rar50Plus(archive) => { + let version = if archive + .files() + .any(|file| file.compression_info & 0x3f == 1) + { + crate::ArchiveVersion::Rar70 + } else { + crate::ArchiveVersion::Rar50 + }; + let rar7_dictionary_size = archive + .files() + .find(|file| file.compression_info & 0x3f == 1) + .map(|file| { + file.decoded_compression_info() + .map(|info| info.dictionary_size) + }) + .transpose()?; + let encrypted = archive.main.encrypted_headers + || archive.blocks.iter().any(|block| match block { + crate::rar50::Block::File(file) | crate::rar50::Block::Service(file) => { + file.encrypted + } + _ => false, + }); + let password = if encrypted { + Some( + password + .filter(|password| !password.is_empty()) + .ok_or(crate::Error::NeedPassword)? + .to_vec(), + ) + } else { + None + }; + let archive_comment_encrypted = archive.blocks.iter().take_while(|block| !matches!(block, crate::rar50::Block::File(_))) + .any(|block| matches!(block, crate::rar50::Block::Service(service) if service.name == b"CMT" && service.encrypted)); + let mut quick_open = false; + let mut recovery_percent = None; + for block in &archive.blocks { + if let crate::rar50::Block::Service(service) = block { + if service.name == b"QO" || service.name == b"RR" { + service.write_to(archive, password.as_deref(), &mut std::io::sink())?; + quick_open |= service.name == b"QO"; + if service.name == b"RR" { + recovery_percent = + service.recovery_record()?.map(|record| record.percent); + } + } + } + } + let metadata = archive.main.extras.iter().find_map(|extra| match extra { + crate::rar50::MainExtraRecord::ArchiveMetadata(metadata) => { + Some(metadata.clone()) + } + _ => None, + }); + crate::Builder::new(version) + .compression_level(Some(3)) + .rar50_dictionary_size(rar7_dictionary_size) + .solid(archive.main.is_solid()) + .password(password.clone()) + .header_encryption(archive.main.encrypted_headers) + .archive_comment_password(if archive_comment_encrypted { + password + } else { + None + }) + .recovery_percent(recovery_percent) + .archive_metadata(metadata, archive.main.is_locked(), quick_open) + } + } + } + + /// Whether each member's comment payload is encrypted, in archive member order. + pub fn member_comment_encryption(&self) -> Vec { + let Archive::Rar50Plus(archive) = self else { + return self.members().map(|_| false).collect(); + }; + let mut encrypted = Vec::new(); + for block in &archive.blocks { + match block { + crate::rar50::Block::File(_) => encrypted.push(false), + crate::rar50::Block::Service(service) if service.name == b"CMT" => { + if let Some(last) = encrypted.last_mut() { + *last = service.encrypted; + } + } + _ => {} + } + } + encrypted + } + + /// Properties the current rewrite adapters cannot promise to preserve. + /// + /// An empty list certifies only the supported metadata subset, not payload + /// integrity or byte-identical output. Legacy preservation accepts only + /// ordinary unpacker-29 files with supported native metadata and encryption. + /// Parsed unknown/incomplete RAR5 extras remain visible to this check even + /// though ordinary extraction tolerates them. Source files must stay stable. + pub fn rewrite_preservation_issues(&self) -> Vec { + let mut issues = Vec::new(); + if self.sfx_offset() != 0 { + issues.push("SFX executable prefix".into()); + } + let mut link_targets = std::collections::HashMap::new(); + for (index, member) in self.members().enumerate() { + let meta = &member.meta; + let label = format!("member {index} ({:?})", String::from_utf8_lossy(&meta.name)); + let link = member.supported_redirection(); + if let Some(link) = link.filter(|link| link.redirection_type >= 4) { + if link_targets.get(&link.target_name) != Some(&meta.unpacked_size) { + issues.push(format!( + "{label}: missing, forward or inconsistent redirection target" + )); + } + } + if !meta.is_directory + && (!meta.is_redirection || link.is_some_and(|link| link.redirection_type >= 4)) + { + link_targets.insert(meta.name.clone(), meta.unpacked_size); + } + if crate::builder::validate_entry_name(meta.name.clone()).is_err() { + issues.push(format!("{label}: unsupported output name")); + } + + if meta.is_split_before || meta.is_split_after { + issues.push(format!("{label}: split-volume layout")); + } + if meta.attr_source() == AttrSource::Unknown { + issues.push(format!("{label}: unknown host attributes")); + } + if special_entry(meta) + && member.supported_redirection().is_none() + && !member.is_legacy_unix_symlink() + { + issues.push(format!("{label}: special entry type or directory contents")); + } + if (meta.attr_source() == AttrSource::Unix + && (meta.file_attr & !0o177777 != 0 + || (meta.is_directory && meta.file_attr & 0o170000 == 0o100000))) + || (meta.attr_source() == AttrSource::Dos + && (meta.file_attr & 0x10 != 0) != meta.is_directory) + { + issues.push(format!("{label}: unsupported or inconsistent attributes")); + } + } + match self { + Archive::Rar13(archive) => { + issues.extend(archive.rewrite_preservation_issues()); + } + Archive::Rar15To40(archive) => { + issues.extend(archive.rewrite_preservation_issues()); + } + Archive::Rar50Plus(archive) => { + use crate::rar50::Block; + let main = &archive.main; + + if main.is_volume() || main.volume_number.is_some() { + issues.push("volume layout".into()); + } + + if !main.rewrite_metadata_complete + || main.archive_flags & !0x1f != 0 + || main.block.flags & !1 != 0 + || main.block.data_size.unwrap_or(0) != 0 + { + issues.push("main header metadata, extra records or unknown flags".into()); + } + let mut derived_services = HashSet::new(); + for extra in &main.extras { + if let crate::rar50::MainExtraRecord::ArchiveMetadata(metadata) = extra { + if crate::rar50::write::headers::retained_archive_metadata( + metadata, + &crate::WriterResources::default(), + ) + .is_err() + { + issues.push("unsupported archive metadata".into()); + } + } + } + let mut index = 0; + let mut comment_seen = false; + for block in &archive.blocks { + match block { + Block::File(file) => { + comment_seen = false; + if !file.rewrite_metadata_complete + || file.file_flags & !7 != 0 + || file.block.flags & !0x1b != 0 + || file.compression_info + & if file.compression_info & 0x3f == 0 { + !0x7fff + } else { + !0x1fffff + } + != 0 + { + issues.push(format!( + "member {index}: unsupported, duplicate or incomplete metadata" + )); + } + if file.compression_info & 0x3f > 1 { + issues.push(format!( + "member {index}: source format requires an unsupported compression algorithm" + )); + } + if file.compression_info & 0x40 != 0 && !main.is_solid() { + issues.push(format!( + "member {index}: solid dependency without a solid archive" + )); + } + index += 1; + } + Block::Service(service) => { + if service.name == b"QO" || service.name == b"RR" { + if !derived_services.insert(service.name.clone()) + || !service.rewrite_metadata_complete + || service.encrypted + || service.modification_time().is_some() + || service.file_times.is_some() + || service.file_flags & !4 != 0 + || service.block.flags & !3 != 0 + || service.attributes != 0 + || service.host_os != 0 + || service.compression_info != 0 + || (service.name == b"RR" + && !service.recovery_record().ok().flatten().is_some_and( + |record| (1..=100).contains(&record.percent), + )) + { + issues.push(format!( + "unsupported derived service {:?}", + String::from_utf8_lossy(&service.name) + )); + } + continue; + } + // One CMT per owner (archive or preceding member). + // Other services and ambiguous duplicates remain rejected. + if comment_seen + || service.name != b"CMT" + || !service.rewrite_metadata_complete + || service.modification_time().is_some() + || service.file_times.is_some() + || service.file_flags & !4 != 0 + || service.block.flags & !3 != 0 + || service.attributes != 0 + || service.host_os != 0 + || service.compression_info & !0x7fff != 0 + || service.compression_info & 0x7f != 0 + { + issues.push(format!( + "service record {:?}", + String::from_utf8_lossy(&service.name) + )); + } + comment_seen = true; + } + Block::End(end) => { + // Canonical end headers contain only type, block flags + // and end flags. Reject extra fields instead of silently + // certifying metadata this reader does not expose. + if end.flags != 0 || end.block.flags != 0 || end.block.header_size != 3 + { + issues.push( + "end header flags, volume continuation or extra metadata" + .into(), + ); + } + } + Block::Unknown(_) => issues.push("unknown archive block".into()), + } + } + if main.has_recovery_record() != derived_services.contains(b"RR".as_slice()) { + issues.push("recovery flag and service disagree".into()); + } + if main.encrypted_headers && derived_services.contains(b"QO".as_slice()) { + issues.push("quick-open index with encrypted headers".into()); + } + for extra in &main.extras { + if let crate::rar50::MainExtraRecord::Locator(locator) = extra { + if locator.quick_open_offset.is_some_and(|offset| offset != 0) + && !derived_services.contains(b"QO".as_slice()) + || locator + .recovery_record_offset + .is_some_and(|offset| offset != 0) + && !derived_services.contains(b"RR".as_slice()) + { + issues.push("locator refers to a missing service".into()); + } + } + } + } + } + issues + } +} + +pub(crate) fn special_entry(meta: &ArchiveMemberMeta) -> bool { + let kind = meta.file_attr & 0o170000; + meta.is_redirection + || (meta.is_directory && meta.unpacked_size != 0) + || (meta.attr_source() == AttrSource::Unix + && !matches!(kind, 0 | 0o100000) + && !(meta.is_directory && kind == 0o040000)) + || (meta.attr_source() == AttrSource::Dos && meta.file_attr & 0x400 != 0) +} + +fn validate_legacy_link_target(target: &[u8], name: &[u8]) -> crate::Result<()> { + if target.is_empty() || target.contains(&0) { + return Err(crate::Error::InvalidArgument( + "legacy symbolic link target is empty or contains NUL", + ) + .at_entry(name.to_vec(), "reading link target")); + } + Ok(()) +} + +impl crate::ArchiveMember { + /// Legacy Unix links store the native target as ordinary member data. + pub fn is_legacy_unix_symlink(&self) -> bool { + self.meta.family == crate::ArchiveFamily::Rar15To40 + && self.meta.attr_source() == AttrSource::Unix + && self.meta.file_attr & !0o7777 == 0o120000 + && !self.meta.is_directory + } + + /// Complete supported file times. Legacy DOS fields use the established local-zone policy. + pub fn file_times(&self) -> crate::Result> { + match &self.detail { + crate::ArchiveMemberDetail::Rar50Plus { file_times, .. } => Ok(*file_times), + crate::ArchiveMemberDetail::Rar15To40 { extended_times, .. } => { + crate::FileTimes::legacy(extended_times, self.meta.file_time) + } + _ => Ok(None), + } + } + + /// A redirection whose known kind and header metadata can be retained. + pub fn supported_redirection(&self) -> Option<&crate::rar50::FileRedirection> { + let crate::ArchiveMemberDetail::Rar50Plus { + redirection: Some(link), + .. + } = &self.detail + else { + return None; + }; + (link.supports_header( + self.meta.host_os?, + self.meta.file_attr, + self.meta.is_directory, + ) && (link.redirection_type != 1 || self.unix_symlink().is_some()) + && self.meta.packed_size == 0) + .then_some(link) + } + + /// Supported RAR5 Unix symbolic link metadata. No filesystem lookup occurs. + pub fn unix_symlink(&self) -> Option<&crate::rar50::FileRedirection> { + let crate::ArchiveMemberDetail::Rar50Plus { + redirection: Some(link), + .. + } = &self.detail + else { + return None; + }; + (link.is_supported_unix_symlink() + && self.meta.host_os == Some(1) + && self.meta.file_attr & !0o7777 == 0o120000 + && !self.meta.is_directory + && (self.meta.unpacked_size == 0 + || self.meta.unpacked_size + == crate::filename::decode_rar50(&link.target_name).len() as u64) + && self.meta.packed_size == 0) + .then_some(link) + } +} diff --git a/arca-rar/vendor/rars/src/rewrite_staging.rs b/arca-rar/vendor/rars/src/rewrite_staging.rs new file mode 100644 index 00000000..c845ab1b --- /dev/null +++ b/arca-rar/vendor/rars/src/rewrite_staging.rs @@ -0,0 +1,533 @@ +//! Verified payload staging for archive rewrites. + +use crate::{Archive, ArchiveReadOptions, EntrySource, Result}; +use std::path::PathBuf; +use std::sync::Arc; + +/// Disk policy for [`Archive::stage_rewrite_sources`]. +/// +/// The directory must already exist and be trusted: private files are reopened +/// by path. Payloads are plaintext, even for encrypted input. Cleanup on drop is +/// best effort, not secure erasure; process termination may leave files behind. +/// The byte limit covers retained payloads only, not filesystem overhead, +/// discarded solid dependencies, decoder workspace or writer output spools. +#[derive(Debug, Clone)] +pub struct RewriteStaging { + /// Existing, trusted directory for private temporary payload files. + pub directory: PathBuf, + /// Inclusive limit on the sum of retained, uncompressed payload bytes. + pub max_staged_bytes: u64, +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +mod pipeline; + +impl Archive { + /// Supply verified payloads on demand during one writer call. Decoding uses + /// one archive-order traversal, including required solid predecessors. + /// Sources belong to one write in this call only: assign each source to one + /// output member, and do not retain it after the call returns. + /// The staging limit covers simultaneously retained plaintext payloads. + /// Writers release compressed payload sources when no reread is needed; + /// stored fallback can retain sources through emission. Output streams may + /// contain a prefix on failure; use staged path publication for rollback. + pub fn with_rewrite_sources( + &self, + indices: &[usize], + options: ArchiveReadOptions<'_>, + staging: &RewriteStaging, + progress: Option>, + consume: impl FnOnce(Vec) -> Result, + ) -> Result { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + { + pipeline::run(self, indices, options, staging, progress, consume) + } + #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] + { + let _ = (indices, options, staging, progress, consume); + Err(crate::Error::InvalidArgument( + "rewrite staging requires disk storage", + )) + } + } + + /// Verify and stage selected payloads in one archive-order extraction pass. + /// + /// Indices count all members, including directories and redirections, but + /// selected indices must identify distinct, unsplit payload members. Results + /// follow the requested order. Metadata must be transferred separately. + /// Solid predecessors are decoded and verified even when not selected; + /// unrelated independent payloads and the suffix after the last selection + /// are not decoded. Read options apply to this entire traversal. + /// + /// No sources are returned on failure. Successful sources can be reopened + /// independently without reading the archive again. Temporary files survive + /// until the last source or open reader drops. This stages the entire + /// selection before returning, with an explicit disk limit; it is not a + /// total memory limit or an incremental writer pipeline. Bare WebAssembly + /// is unsupported because this operation requires disk storage. + pub fn stage_rewrite_sources( + &self, + indices: &[usize], + options: ArchiveReadOptions<'_>, + staging: &RewriteStaging, + ) -> Result> { + self.stage_rewrite_sources_with_progress(indices, options, staging, None) + } + + /// Staging with a separate [`crate::WriteOperation::Staging`] progress phase. + /// Counts decoded bytes, including discarded solid predecessors. Entry indices + /// count decoded payloads in traversal order, not original archive indices. + /// Byte progress precedes integrity verification; finished events follow it. + /// Declared progress totals saturate at `u64::MAX`. + /// + /// Callback cancellation is checked around reports, between members and at + /// bounded output writes. Supply `options.cancellation` to also interrupt + /// decoder work that has not produced output. Blocked I/O cannot be preempted. + pub fn stage_rewrite_sources_with_progress( + &self, + indices: &[usize], + options: ArchiveReadOptions<'_>, + staging: &RewriteStaging, + progress: Option>, + ) -> Result> { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + { + native::stage(self, indices, options, staging, progress, None) + } + #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] + { + let _ = (indices, options, staging, progress); + Err(crate::Error::InvalidArgument( + "rewrite staging requires disk storage", + )) + } + } +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +mod native { + use super::*; + use crate::atomic64::AtomicU64; + use crate::{ + streaming::Spool, Error, ExtractionDecision, WriteOperation, WriteProgress, + WriteProgressEvent, WriterResources, + }; + use std::sync::atomic::Ordering; + use std::{ + cell::{Cell, RefCell}, + collections::BTreeMap, + io::Write, + rc::Rc, + }; + + struct Sink { + spool: Rc>, + used: Arc, + limit: u64, + } + + impl Write for Sink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + let count = bytes.len() as u64; + let mut used = self.used.load(Ordering::Acquire); + loop { + let Some(required) = used + .checked_add(count) + .filter(|required| *required <= self.limit) + else { + return Err(std::io::Error::other(Error::RewriteStagingLimitExceeded { + limit: self.limit, + required: used.saturating_add(count), + })); + }; + match self.used.compare_exchange_weak( + used, + required, + Ordering::AcqRel, + Ordering::Acquire, + ) { + Ok(_) => break, + Err(actual) => used = actual, + } + } + let written = match self.spool.borrow_mut().write(bytes) { + Ok(written) => written, + Err(error) => { + self.used.fetch_sub(count, Ordering::AcqRel); + return Err(error); + } + }; + self.used + .fetch_sub(count - written as u64, Ordering::AcqRel); + Ok(written) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.spool.borrow_mut().flush() + } + } + + impl Drop for Sink { + fn drop(&mut self) { + self.spool.borrow_mut().park(); + } + } + + struct Progress { + callback: Arc, + completed: Cell, + total: u64, + entries: usize, + } + + impl Progress { + fn check(&self) -> Result<()> { + if self.callback.is_cancelled() { + Err(Error::Cancelled) + } else { + Ok(()) + } + } + + fn report(&self, event: WriteProgressEvent<'_>) -> Result<()> { + self.check()?; + self.callback.report(event); + self.check() + } + + fn finish_entry(&self, entry: &(usize, Vec, u64)) -> Result<()> { + self.report(WriteProgressEvent::EntryFinished { + operation: WriteOperation::Staging, + index: entry.0, + total_entries: self.entries, + name: &entry.1, + input_bytes: entry.2, + }) + } + } + + struct ProgressSink { + inner: Box, + progress: Rc, + } + + impl Write for ProgressSink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.progress.check().map_err(std::io::Error::other)?; + let written = self.inner.write(&bytes[..bytes.len().min(64 * 1024)])?; + let completed = self.progress.completed.get().saturating_add(written as u64); + self.progress.completed.set(completed); + self.progress + .report(WriteProgressEvent::Advanced { + operation: WriteOperation::Staging, + completed_bytes: completed, + total_bytes: self.progress.total, + pass: 1, + }) + .map_err(std::io::Error::other)?; + Ok(written) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.inner.flush() + } + } + + pub(super) fn stage( + archive: &Archive, + indices: &[usize], + options: ArchiveReadOptions<'_>, + staging: &RewriteStaging, + progress: Option>, + delivery: Option<&super::pipeline::Delivery>, + ) -> Result> { + options.check_cancelled()?; + if progress + .as_ref() + .is_some_and(|progress| progress.is_cancelled()) + { + return Err(Error::Cancelled); + } + let mut selected = BTreeMap::new(); + for &index in indices { + if selected.insert(index, None).is_some() { + return Err(Error::DuplicateEntry); + } + } + let Some(&last) = selected.keys().next_back() else { + return Ok(Vec::new()); + }; + let mut required = 0u64; + let mut found = 0; + let solid = match archive { + Archive::Rar13(a) => a.main.is_solid(), + Archive::Rar15To40(a) => a.main.is_solid(), + Archive::Rar50Plus(a) => a.main.is_solid(), + }; + let mut total = 0u64; + let mut entries = 0; + for (index, member) in archive.members().enumerate() { + options.check_cancelled()?; + if index <= last + && (selected.contains_key(&index) || solid) + && !member.meta.is_directory + && !member.meta.is_redirection + { + total = total.saturating_add(member.meta.unpacked_size); + entries += 1; + } + if !selected.contains_key(&index) { + continue; + } + let meta = member.meta; + if meta.is_directory + || meta.is_redirection + || meta.is_split_before + || meta.is_split_after + { + return Err(Error::InvalidArgument( + "rewrite staging requires unsplit payload members", + )); + } + let sum = if delivery.is_some() { + Some(required.max(meta.unpacked_size)) + } else { + required.checked_add(meta.unpacked_size) + }; + if sum.is_none_or(|sum| sum > staging.max_staged_bytes) { + return Err(Error::RewriteStagingLimitExceeded { + limit: staging.max_staged_bytes, + required: sum.unwrap_or(u64::MAX), + }); + } + required = sum.unwrap(); + found += 1; + } + if found != selected.len() { + return Err(Error::EntryNotFound); + } + let progress = progress.map(|callback| { + Rc::new(Progress { + callback, + completed: Cell::new(0), + total, + entries, + }) + }); + if let Some(progress) = &progress { + progress.report(WriteProgressEvent::OperationStarted { + operation: WriteOperation::Staging, + total_bytes: Some(total), + total_entries: Some(entries), + pass: 1, + })?; + } + let resources = WriterResources::new(0).with_temp_dir(&staging.directory); + let used = delivery.map_or_else( + || Arc::new(AtomicU64::new(0)), + |delivery| delivery.used.clone(), + ); + let mut index = 0; + let mut pending = None; + let mut decoded = 0; + let mut staged_pending = None; + archive.extract_with_control(options, |member| { + publish_pending(&mut staged_pending, &mut selected, delivery)?; + if let Some(progress) = &progress { + if let Some(entry) = pending.take() { + progress.finish_entry(&entry)?; + } + } + let current = index; + index += 1; + if current > last { + return Ok(ExtractionDecision::Stop); + } + let wanted = selected.contains_key(¤t); + let dependency = solid && !member.meta.is_directory && !member.meta.is_redirection; + if !wanted && !dependency { + return Ok(ExtractionDecision::Skip); + } + if let Some(delivery) = delivery { + // Dependencies are decoded only on demand for the next retained member. + let next = selected + .range(current..) + .next() + .map(|(&index, _)| index) + .unwrap_or(last); + delivery.wait_for(next)?; + } + if let Some(progress) = &progress { + progress.report(WriteProgressEvent::EntryStarted { + operation: WriteOperation::Staging, + index: decoded, + total_entries: entries, + name: &member.meta.name, + input_bytes: member.meta.unpacked_size, + })?; + pending = Some((decoded, member.meta.name.clone(), member.meta.unpacked_size)); + } + decoded += 1; + let sink: Box = if let Some(slot) = selected.get_mut(¤t) { + let spool = Rc::new(RefCell::new(Spool::create(&resources)?)); + *slot = Some(spool.clone()); + staged_pending = Some(current); + Box::new(Sink { + spool, + used: used.clone(), + limit: staging.max_staged_bytes, + }) + } else { + Box::new(std::io::sink()) + }; + Ok(ExtractionDecision::Extract( + if let Some(progress) = &progress { + Box::new(ProgressSink { + inner: sink, + progress: progress.clone(), + }) + } else { + sink + }, + )) + })?; + if let Some(progress) = &progress { + if let Some(entry) = pending.take() { + progress.finish_entry(&entry)?; + } + progress.report(WriteProgressEvent::OperationFinished { + operation: WriteOperation::Staging, + total_bytes: Some(total), + total_entries: Some(entries), + pass: 1, + })?; + } + publish_pending(&mut staged_pending, &mut selected, delivery)?; + if delivery.is_some() { + return Ok(Vec::new()); + } + indices + .iter() + .map(|index| { + let spool = selected + .remove(index) + .flatten() + .ok_or(Error::InvalidHeader("staged rewrite member disappeared"))?; + let spool = Rc::try_unwrap(spool) + .map_err(|_| Error::InvalidHeader("rewrite sink still active"))? + .into_inner(); + Ok(spool.into_source()) + }) + .collect() + } + + fn publish_pending( + pending: &mut Option, + selected: &mut BTreeMap>>>, + delivery: Option<&super::pipeline::Delivery>, + ) -> Result<()> { + if let (Some(index), Some(delivery)) = (pending.take(), delivery) { + let spool = selected + .remove(&index) + .flatten() + .ok_or(Error::WriterFailure("rewrite spool disappeared"))?; + let spool = Rc::try_unwrap(spool) + .map_err(|_| Error::WriterFailure("rewrite sink still active"))? + .into_inner(); + delivery.publish(index, spool.into_source())?; + } + Ok(()) + } + + #[cfg(test)] + mod tests { + use super::*; + + #[test] + fn progress_sink_forwards_flush_failure() { + struct FailingFlush(Arc); + + impl Write for FailingFlush { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.0.fetch_add(1, Ordering::Relaxed); + Err(std::io::Error::other("injected staging flush failure")) + } + } + + let calls = Arc::new(AtomicU64::new(0)); + let progress = Rc::new(Progress { + callback: Arc::new(|_: WriteProgressEvent<'_>| {}), + completed: Cell::new(0), + total: 0, + entries: 0, + }); + let mut sink = ProgressSink { + inner: Box::new(FailingFlush(calls.clone())), + progress, + }; + assert_eq!( + sink.flush().unwrap_err().to_string(), + "injected staging flush failure" + ); + assert_eq!(calls.load(Ordering::Relaxed), 1); + } + + #[test] + fn runtime_limit_counts_all_sinks_and_refuses_before_writing() { + let root = crate::scratch::case("rewrite-runtime-limit"); + let resources = WriterResources::new(0).with_temp_dir(&*root); + let used = Arc::new(AtomicU64::new(0)); + let make_sink = || Sink { + spool: Rc::new(RefCell::new(Spool::create(&resources).unwrap())), + used: used.clone(), + limit: 5, + }; + let mut first = make_sink(); + let mut second = make_sink(); + first.write_all(b"abc").unwrap(); + second.write_all(b"de").unwrap(); + let error = Error::from(second.write_all(b"f").unwrap_err()); + assert_eq!( + error, + Error::RewriteStagingLimitExceeded { + limit: 5, + required: 6 + } + ); + assert_eq!(used.load(Ordering::Acquire), 5); + assert_eq!(second.spool.borrow().len(), 2); + } + + #[test] + fn spool_write_failure_releases_the_provisional_staging_charge() { + let root = crate::scratch::case("rewrite-spool-write-failure"); + let resources = WriterResources::new(0).with_temp_dir(&*root); + let used = Arc::new(AtomicU64::new(0)); + let mut sink = Sink { + spool: Rc::new(RefCell::new(Spool::create(&resources).unwrap())), + used: used.clone(), + limit: 16, + }; + sink.flush().unwrap(); + sink.spool.borrow_mut().park(); + let path = std::fs::read_dir(&root) + .unwrap() + .next() + .unwrap() + .unwrap() + .path(); + std::fs::remove_file(path).unwrap(); + assert_eq!( + sink.write(b"payload").unwrap_err().kind(), + std::io::ErrorKind::NotFound + ); + assert_eq!(used.load(Ordering::Acquire), 0); + } + } +} diff --git a/arca-rar/vendor/rars/src/rewrite_staging/pipeline.rs b/arca-rar/vendor/rars/src/rewrite_staging/pipeline.rs new file mode 100644 index 00000000..23eb0e3a --- /dev/null +++ b/arca-rar/vendor/rars/src/rewrite_staging/pipeline.rs @@ -0,0 +1,496 @@ +//! Demand-driven, archive-order decoding for one scoped writer call. +use super::*; +use crate::atomic64::AtomicU64; +use crate::streaming::SourceFactory; +use crate::{Error, ReadCancellation}; +use std::collections::BTreeMap; +use std::io::{Read, Seek, SeekFrom}; +use std::sync::{atomic::Ordering, Condvar, Mutex}; + +#[derive(Default)] +struct State { + requested: Option, + ready: BTreeMap>, + error: Option, + done: bool, + published: std::collections::BTreeSet, +} + +pub(super) struct Delivery { + state: Mutex, + changed: Condvar, + cancellation: ReadCancellation, + pub(super) used: Arc, + max_preparation_window: usize, +} + +struct Lease { + source: Option, + size: u64, + used: Arc, +} +impl Drop for Lease { + fn drop(&mut self) { + drop(self.source.take()); + self.used.fetch_sub(self.size, Ordering::AcqRel); + } +} + +struct Reader { + reader: Box, + _lease: Arc, +} +impl Read for Reader { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + self.reader.read(bytes) + } +} +impl Seek for Reader { + fn seek(&mut self, position: SeekFrom) -> std::io::Result { + self.reader.seek(position) + } +} +struct Source { + index: usize, + size: u64, + delivery: Arc, +} +impl SourceFactory for Source { + fn max_preparation_window(&self) -> usize { + self.delivery.max_preparation_window + } + fn len(&self) -> Result { + Ok(self.size) + } + fn open(&self) -> Result> { + self.open_with_cancellation(|| self.delivery.cancellation.is_cancelled()) + } + fn release(&self) { + self.delivery + .state + .lock() + .unwrap() + .ready + .remove(&self.index); + self.delivery.changed.notify_all(); + } +} + +impl Source { + fn open_with_cancellation( + &self, + mut is_cancelled: impl FnMut() -> bool, + ) -> Result> { + let mut state = self.delivery.state.lock().unwrap(); + state.requested = Some( + state + .requested + .map_or(self.index, |index| index.max(self.index)), + ); + self.delivery.changed.notify_all(); + loop { + if let Some(error) = &state.error { + return Err(error.clone()); + } + if is_cancelled() { + return Err(Error::Cancelled); + } + if let Some(lease) = state.ready.get(&self.index).cloned() { + drop(state); + return Ok(Box::new(Reader { + reader: lease.source.as_ref().expect("live lease").open()?, + _lease: lease, + })); + } + if state.published.contains(&self.index) { + return Err(Error::WriterFailure("rewrite source already consumed")); + } + if state.done || is_cancelled() { + return Err(Error::Cancelled); + } + state = self.delivery.changed.wait(state).unwrap(); + } + } +} + +impl Delivery { + pub(super) fn wait_for(&self, index: usize) -> Result<()> { + let mut state = self.state.lock().unwrap(); + while state.requested.is_none_or(|requested| requested < index) { + if self.cancellation.is_cancelled() { + return Err(Error::Cancelled); + } + state = self + .changed + .wait_timeout(state, std::time::Duration::from_millis(50)) + .unwrap() + .0; + } + if self.cancellation.is_cancelled() { + return Err(Error::Cancelled); + } + Ok(()) + } + pub(super) fn publish(&self, index: usize, source: EntrySource) -> Result<()> { + let size = source.len()?; + if self.cancellation.is_cancelled() { + return Err(Error::Cancelled); + } + let mut state = self.state.lock().unwrap(); + state.published.insert(index); + state.ready.insert( + index, + Arc::new(Lease { + source: Some(source), + size, + used: self.used.clone(), + }), + ); + self.changed.notify_all(); + Ok(()) + } +} + +struct StopOnDrop(Arc); +impl Drop for StopOnDrop { + fn drop(&mut self) { + self.0.cancellation.cancel(); + self.0.state.lock().unwrap().ready.clear(); + self.0.changed.notify_all(); + } +} + +pub(super) fn run( + archive: &Archive, + indices: &[usize], + options: ArchiveReadOptions<'_>, + staging: &RewriteStaging, + progress: Option>, + consume: impl FnOnce(Vec) -> Result, +) -> Result { + options.check_cancelled()?; + let sizes: BTreeMap<_, _> = archive + .members() + .enumerate() + .map(|(i, member)| (i, member.meta.unpacked_size)) + .collect(); + // A preparation window can retain every source until its members are emitted. + // Bound it by the largest selected payload so even mixed-size windows fit. + let largest = indices + .iter() + .filter_map(|index| sizes.get(index)) + .copied() + .max() + .unwrap_or(0); + let max_preparation_window = usize::try_from(staging.max_staged_bytes / largest.max(1)) + .unwrap_or(usize::MAX) + .max(1); + let delivery = Arc::new(Delivery { + state: Mutex::new(State::default()), + changed: Condvar::new(), + cancellation: options + .cancellation + .map_or_else(ReadCancellation::new, ReadCancellation::child), + used: Arc::new(AtomicU64::new(0)), + max_preparation_window, + }); + let sources = indices + .iter() + .map(|&index| { + let size = *sizes.get(&index).ok_or(Error::EntryNotFound)?; + Ok(EntrySource::from_factory(Source { + index, + size, + delivery: delivery.clone(), + })) + }) + .collect::>>()?; + std::thread::scope(|scope| { + let worker = &delivery; + let decoder = scope.spawn(move || { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + super::native::stage( + archive, + indices, + options.with_cancellation(&worker.cancellation), + staging, + progress, + Some(worker), + ) + })) + .unwrap_or(Err(Error::WriterFailure("rewrite decoder thread panicked"))); + let mut state = worker.state.lock().unwrap(); + state.error = result.as_ref().err().cloned(); + state.done = true; + worker.changed.notify_all(); + result.map(|_| ()) + }); + // Unwind, writer failure and unused sources must all wake a waiting decoder. + let guard = StopOnDrop(delivery.clone()); + let result = consume(sources); + let requested = delivery.state.lock().unwrap().requested; + if result.is_err() || requested != indices.iter().copied().max() { + delivery.cancellation.cancel(); + delivery.changed.notify_all(); + } + let decoded = decoder + .join() + .map_err(|_| Error::WriterFailure("rewrite decoder thread panicked"))?; + drop(guard); + match result { + Err(error) => Err(error), + Ok(value) => { + finish_decoder(decoded, requested != indices.iter().copied().max())?; + Ok(value) + } + } + }) +} + +fn finish_decoder(decoded: Result<()>, unused_sources: bool) -> Result<()> { + match decoded { + // Stopping an unused source can race with entry selection, which adds + // context to cancellation. Its category is unchanged by that context. + Err(error) if unused_sources && error.kind() == crate::ErrorKind::Cancelled => Ok(()), + other => other, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::sync::atomic::AtomicBool; + + #[test] + fn unused_source_shutdown_accepts_contextual_cancellation_only() { + let cancelled = Error::AtEntry { + name: b"file".to_vec(), + operation: "selecting", + source: Box::new(Error::Cancelled), + }; + assert_eq!(finish_decoder(Err(cancelled.clone()), true), Ok(())); + assert_eq!( + finish_decoder(Err(cancelled.clone()), false), + Err(cancelled) + ); + let error = Error::InvalidArgument("decoder refused"); + assert_eq!(finish_decoder(Err(error.clone()), true), Err(error)); + } + + struct CancelAtStagingFinish(AtomicBool); + + impl crate::WriteProgress for CancelAtStagingFinish { + fn report(&self, event: crate::WriteProgressEvent<'_>) { + if matches!( + event, + crate::WriteProgressEvent::OperationFinished { + operation: crate::WriteOperation::Staging, + .. + } + ) { + self.0.store(true, Ordering::Relaxed); + } + } + + fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) + } + } + + fn delivery() -> Arc { + Arc::new(Delivery { + state: Mutex::new(State::default()), + changed: Condvar::new(), + cancellation: ReadCancellation::new(), + used: Arc::new(AtomicU64::new(0)), + max_preparation_window: usize::MAX, + }) + } + + #[test] + fn rewrite_source_reopens_a_live_lease_and_refuses_a_consumed_one() { + let delivery = delivery(); + delivery.used.store(6, Ordering::Relaxed); + delivery.state.lock().unwrap().ready.insert( + 0, + Arc::new(Lease { + source: Some(EntrySource::from_bytes(b"abcdef".to_vec())), + size: 6, + used: delivery.used.clone(), + }), + ); + let source = Source { + index: 0, + size: 6, + delivery: delivery.clone(), + }; + let mut reader = source.open().unwrap(); + assert_eq!(reader.seek(SeekFrom::Start(3)).unwrap(), 3); + let mut suffix = Vec::new(); + reader.read_to_end(&mut suffix).unwrap(); + assert_eq!(suffix, b"def"); + delivery.wait_for(0).unwrap(); + source.release(); + assert_eq!(delivery.used.load(Ordering::Relaxed), 6); + drop(reader); + assert_eq!(delivery.used.load(Ordering::Relaxed), 0); + delivery.state.lock().unwrap().published.insert(0); + assert!(matches!( + source.open(), + Err(Error::WriterFailure("rewrite source already consumed")) + )); + delivery.state.lock().unwrap().published.clear(); + delivery.state.lock().unwrap().done = true; + assert!(matches!(source.open(), Err(Error::Cancelled))); + } + + #[test] + fn cancelled_delivery_refuses_waits_opens_and_publication() { + let delivery = delivery(); + delivery.cancellation.cancel(); + let source = Source { + index: 0, + size: 1, + delivery: delivery.clone(), + }; + assert!(matches!(delivery.wait_for(1), Err(Error::Cancelled))); + assert!(matches!(source.open(), Err(Error::Cancelled))); + assert!(matches!(delivery.wait_for(0), Err(Error::Cancelled))); + assert!(matches!( + delivery.publish(0, EntrySource::from_bytes(b"x".to_vec())), + Err(Error::Cancelled) + )); + assert_eq!(delivery.used.load(Ordering::Relaxed), 0); + } + + #[test] + fn cancellation_between_observations_refuses_to_wait_for_a_source() { + let delivery = delivery(); + let source = Source { + index: 0, + size: 1, + delivery: delivery.clone(), + }; + let mut observations = 0; + let result = source.open_with_cancellation(|| { + let cancelled = delivery.cancellation.is_cancelled(); + observations += 1; + if observations == 1 { + // Model cancellation after the first atomic load returned false. + delivery.cancellation.cancel(); + } + cancelled + }); + assert!(matches!(result, Err(Error::Cancelled))); + assert_eq!(observations, 2); + let state = delivery.state.lock().unwrap(); + assert_eq!(state.requested, Some(0)); + assert!(!state.done); + assert!(state.ready.is_empty()); + assert!(state.published.is_empty()); + assert_eq!(delivery.used.load(Ordering::Relaxed), 0); + } + + #[test] + fn published_source_delivers_bytes_and_releases_its_charge() { + let delivery = delivery(); + let source = Source { + index: 0, + size: 7, + delivery: delivery.clone(), + }; + assert_eq!(source.len().unwrap(), 7); + // Native staging charges the bytes before publishing the lease. + delivery.used.store(7, Ordering::Relaxed); + delivery + .publish(0, EntrySource::from_bytes(b"payload".to_vec())) + .unwrap(); + let mut reader = source.open().unwrap(); + delivery.wait_for(0).unwrap(); + let mut bytes = Vec::new(); + reader.read_to_end(&mut bytes).unwrap(); + assert_eq!(bytes, b"payload"); + source.release(); + assert_eq!(delivery.used.load(Ordering::Relaxed), 7); + drop(reader); + assert_eq!(delivery.used.load(Ordering::Relaxed), 0); + assert!(matches!( + source.open(), + Err(Error::WriterFailure("rewrite source already consumed")) + )); + } + + #[test] + fn writer_that_never_opens_its_rewrite_source_stops_the_decoder() { + let root = crate::scratch::case("rewrite-unused-source"); + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let staging = RewriteStaging { + directory: root.to_path_buf(), + max_staged_bytes: 7, + }; + + let value = run( + &archive, + &[0], + ArchiveReadOptions::default(), + &staging, + None, + |sources| { + assert_eq!(sources.len(), 1); + Ok(17) + }, + ) + .unwrap(); + assert_eq!(value, 17); + assert_eq!(std::fs::read_dir(&root).unwrap().count(), 0); + + assert_eq!( + run( + &archive, + &[0], + ArchiveReadOptions::default(), + &staging, + None, + |_sources| -> Result<()> { Err(Error::InvalidArgument("writer refused")) }, + ) + .unwrap_err(), + Error::InvalidArgument("writer refused") + ); + assert_eq!(std::fs::read_dir(&root).unwrap().count(), 0); + } + + #[test] + fn cancellation_after_final_source_request_reaches_writer() { + let root = crate::scratch::case("rewrite-final-request-cancelled"); + let mut builder = crate::Builder::new(crate::ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let archive = crate::ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let staging = RewriteStaging { + directory: root.to_path_buf(), + max_staged_bytes: 7, + }; + let progress = Arc::new(CancelAtStagingFinish(AtomicBool::new(false))); + + let result = run( + &archive, + &[0], + ArchiveReadOptions::default(), + &staging, + Some(progress.clone()), + |sources| { + let error = sources[0].open().err().expect("staging should cancel"); + assert_eq!(error.kind(), crate::ErrorKind::Cancelled, "{error:?}"); + Ok(17) + }, + ); + assert!(progress.0.load(Ordering::Relaxed)); + assert_eq!(result.unwrap_err(), Error::Cancelled); + assert_eq!(std::fs::read_dir(&root).unwrap().count(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/source.rs b/arca-rar/vendor/rars/src/source.rs new file mode 100644 index 00000000..1789157f --- /dev/null +++ b/arca-rar/vendor/rars/src/source.rs @@ -0,0 +1,253 @@ +use crate::error::{Error, Result}; +use crate::io_util::read_exact_at; +use std::fs::File; +use std::io::{Cursor, Read, Seek, SeekFrom, Write}; +use std::ops::Range; +use std::path::PathBuf; +use std::sync::{Arc, Mutex}; + +trait ReadSeek: Read + Seek + Send {} +impl ReadSeek for T {} + +pub(crate) struct ReaderSource { + reader: Mutex>, + len: usize, +} + +impl std::fmt::Debug for ReaderSource { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("ReaderSource") + .field("len", &self.len) + .finish_non_exhaustive() + } +} + +impl ReaderSource { + pub(crate) fn new(mut reader: impl Read + Seek + Send + 'static) -> Result> { + let len = usize::try_from(reader.seek(SeekFrom::End(0))?) + .map_err(|_| Error::InvalidHeader("archive size overflows host address size"))?; + Ok(Arc::new(Self { + reader: Mutex::new(Box::new(reader)), + len, + })) + } + + pub(crate) fn cursor(self: &Arc) -> SourceCursor { + SourceCursor { + source: self.clone(), + position: 0, + } + } +} + +pub(crate) struct SourceCursor { + source: Arc, + position: u64, +} + +impl Read for SourceCursor { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + let remaining = (self.source.len as u64).saturating_sub(self.position); + let count = bytes.len().min(remaining as usize); + if count == 0 { + return Ok(0); + } + let mut reader = self + .source + .reader + .lock() + .map_err(|_| std::io::Error::other("archive reader lock poisoned"))?; + // The seek and read share one lock; sibling cursors never share a position. + reader.seek(SeekFrom::Start(self.position))?; + let count = reader.read(&mut bytes[..count])?; + self.position += count as u64; + Ok(count) + } +} + +impl Seek for SourceCursor { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + let position = match from { + SeekFrom::Start(position) => position as i128, + SeekFrom::Current(offset) => self.position as i128 + offset as i128, + SeekFrom::End(offset) => self.source.len as i128 + offset as i128, + }; + self.position = u64::try_from(position) + .map_err(|_| std::io::Error::from(std::io::ErrorKind::InvalidInput))?; + Ok(self.position) + } +} + +/// Range cursors contain only inline state and references to the archive's +/// existing source. Reading a member does not need another heap allocation. +pub(crate) enum RangeReader<'a> { + Memory(Cursor<&'a [u8]>), + File(std::io::Take), + Reader(std::io::Take), +} +impl Read for RangeReader<'_> { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + match self { + Self::Memory(reader) => reader.read(bytes), + Self::File(reader) => reader.read(bytes), + Self::Reader(reader) => reader.read(bytes), + } + } +} + +#[derive(Debug, Clone)] +pub(crate) enum ArchiveSource { + Memory(Arc<[u8]>), + File(Arc), + Reader(Arc), +} + +impl ArchiveSource { + pub(crate) fn read_range(&self, range: Range) -> Result> { + match self { + Self::Memory(data) => data + .get(range) + .map(|data| data.to_vec()) + .ok_or(Error::TooShort), + Self::File(path) => { + let mut file = File::open(path.as_ref())?; + read_exact_at(&mut file, range.start, range.len()) + } + Self::Reader(source) => read_exact_at(&mut source.cursor(), range.start, range.len()), + } + } + + pub(crate) fn copy_range_to(&self, range: Range, writer: &mut dyn Write) -> Result<()> { + match self { + Self::Reader(_) => { + let mut reader = self.range_reader(range)?; + std::io::copy(&mut reader, writer)?; + } + Self::Memory(data) => { + let data = data.get(range).ok_or(Error::TooShort)?; + writer.write_all(data)?; + } + Self::File(path) => { + let mut file = File::open(path.as_ref())?; + file.seek(SeekFrom::Start(range.start as u64))?; + let mut limited = file.take(range.len() as u64); + std::io::copy(&mut limited, writer)?; + } + } + Ok(()) + } + + pub(crate) fn range_reader(&self, range: Range) -> Result> { + match self { + Self::Reader(source) => { + if range.start > range.end || range.end > source.len { + return Err(Error::TooShort); + } + let mut reader = source.cursor(); + reader.seek(SeekFrom::Start(range.start as u64))?; + Ok(RangeReader::Reader(reader.take(range.len() as u64))) + } + Self::Memory(data) => { + let data = data.get(range).ok_or(Error::TooShort)?; + Ok(RangeReader::Memory(Cursor::new(data))) + } + Self::File(path) => { + let mut file = File::open(path.as_ref())?; + file.seek(SeekFrom::Start(range.start as u64))?; + Ok(RangeReader::File(file.take(range.len() as u64))) + } + } + } + + pub(crate) fn len(&self) -> Result { + match self { + Self::Reader(source) => Ok(source.len), + Self::Memory(data) => Ok(data.len()), + Self::File(path) => usize::try_from(std::fs::metadata(path.as_ref())?.len()) + .map_err(|_| Error::InvalidHeader("archive size overflows host address size")), + } + } + + #[cfg(feature = "recovery")] + pub(crate) fn bytes(&self) -> Result> { + match self { + Self::Reader(source) => self.read_range(0..source.len), + Self::Memory(data) => Ok(data.to_vec()), + Self::File(path) => Ok(std::fs::read(path.as_ref())?), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sibling_cursors_keep_independent_positions_and_range_boundaries() { + let source = ReaderSource::new(Cursor::new(b"0123456789".to_vec())).unwrap(); + let mut first = source.cursor(); + let mut second = source.cursor(); + second.seek(SeekFrom::End(-3)).unwrap(); + let mut bytes = [0; 2]; + first.read_exact(&mut bytes).unwrap(); + assert_eq!(&bytes, b"01"); + second.read_exact(&mut bytes).unwrap(); + assert_eq!(&bytes, b"78"); + first.read_exact(&mut bytes).unwrap(); + assert_eq!(&bytes, b"23"); + assert!(first.seek(SeekFrom::Current(-5)).is_err()); + assert_eq!(first.stream_position().unwrap(), 4); + let source = ArchiveSource::Reader(source); + let mut range = source.range_reader(4..6).unwrap(); + let mut result = Vec::new(); + range.read_to_end(&mut result).unwrap(); + assert_eq!(result, b"45"); + assert!(source.range_reader(9..11).is_err()); + let start = 6; + let end = 4; + assert!(source.range_reader(start..end).is_err()); + } + + #[test] + fn empty_and_exhausted_cursors_do_not_read_the_underlying_source() { + let source = ReaderSource::new(Cursor::new(b"0123".to_vec())).unwrap(); + assert_eq!(format!("{source:?}"), "ReaderSource { len: 4, .. }"); + let mut cursor = source.cursor(); + assert_eq!(cursor.read(&mut []).unwrap(), 0); + assert_eq!(cursor.stream_position().unwrap(), 0); + cursor.seek(SeekFrom::End(0)).unwrap(); + let mut bytes = [0xff; 2]; + assert_eq!(cursor.read(&mut bytes).unwrap(), 0); + assert_eq!(bytes, [0xff; 2]); + cursor.seek(SeekFrom::End(10)).unwrap(); + assert_eq!(cursor.read(&mut bytes).unwrap(), 0); + assert_eq!(cursor.stream_position().unwrap(), 14); + } + + #[test] + fn a_panicking_reader_leaves_sibling_cursors_with_a_typed_io_error() { + struct PanicReader(Cursor>); + impl Seek for PanicReader { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.0.seek(from) + } + } + impl Read for PanicReader { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + panic!("reader failed during callback"); + } + } + let source = ReaderSource::new(PanicReader(Cursor::new(vec![1]))).unwrap(); + let mut first = source.cursor(); + let mut sibling = source.cursor(); + assert!(std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + first.read_exact(&mut [0]).unwrap(); + })) + .is_err()); + let error = sibling.read(&mut [0]).unwrap_err(); + assert_eq!(error.kind(), std::io::ErrorKind::Other); + assert_eq!(error.to_string(), "archive reader lock poisoned"); + assert!(matches!(Error::from(error), Error::Io(_))); + assert_eq!(sibling.stream_position().unwrap(), 0); + } +} diff --git a/arca-rar/vendor/rars/src/streaming.rs b/arca-rar/vendor/rars/src/streaming.rs new file mode 100644 index 00000000..ec38da5b --- /dev/null +++ b/arca-rar/vendor/rars/src/streaming.rs @@ -0,0 +1,1634 @@ +use crate::{Error, Result}; +#[cfg(any(test, all(target_arch = "wasm32", target_os = "unknown")))] +mod memory_spool; +pub(crate) mod output; +pub(crate) mod preparation; +use std::fmt; +use std::fs::File; +use std::io::{Cursor, Read, Seek, SeekFrom, Write}; +use std::path::{Path, PathBuf}; +#[cfg(test)] +use std::sync::atomic::AtomicU64; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Condvar, Mutex}; + +/// Default aggregate compression workspace budget (256 MiB). +pub const DEFAULT_WRITER_MEMORY_LIMIT: u64 = 256 * 1024 * 1024; + +/// A rewindable input reader used by streaming archive writers. +pub trait EntryReader: Read + Seek + Send {} +impl EntryReader for T {} + +pub(crate) trait SourceFactory: Send + Sync { + /// Bound simultaneous preparation when a scoped producer retains plaintext. + fn max_preparation_window(&self) -> usize { + usize::MAX + } + fn release(&self) {} + fn len(&self) -> Result; + fn open(&self) -> Result>; +} + +#[derive(Clone)] +/// A reopenable byte source for an archive member. +/// +/// Reopening is not a snapshot: callers must keep the source stable for the +/// duration of a write. Writers check emitted stored data against the prepared +/// size and archive checksums. A mismatch fails the write, but a caller-provided +/// output stream can already contain partial data when the error is returned. +pub struct EntrySource(Arc); + +impl fmt::Debug for EntrySource { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("EntrySource") + .field("len", &self.len().ok()) + .finish_non_exhaustive() + } +} + +impl EntrySource { + pub(crate) fn from_factory(factory: impl SourceFactory + 'static) -> Self { + Self(Arc::new(factory)) + } + + pub(crate) fn max_preparation_window(&self) -> usize { + self.0.max_preparation_window() + } + + /// Release a session-owned payload once this write will never reopen it. + pub(crate) fn release(&self) { + self.0.release(); + } + + pub fn from_bytes(data: impl Into>) -> Self { + Self::from_factory(MemorySource(data.into())) + } + + pub(crate) fn copy_for_writer(data: &[u8], resources: &WriterResources) -> Result { + let Some(mut charge) = resources.execution_charge() else { + return Ok(Self::from_bytes(Arc::<[u8]>::from(data))); + }; + let bytes = data + .len() + .checked_add(std::mem::size_of::()) + .and_then(|bytes| bytes.checked_add(std::mem::size_of::())) + .ok_or(Error::InvalidArgument("writer source capacity overflows"))?; + charge.grow_to(bytes as u64)?; + let data = Arc::new(WriterMemoryData { + bytes: data.to_vec(), + _charge: charge, + }); + Ok(Self::from_factory(WriterMemorySource { + data, + resources: resources.clone(), + })) + } + + pub fn from_path(path: impl Into) -> Self { + Self::from_factory(PathSource(path.into())) + } + + pub fn from_opener(len: u64, open: F) -> Self + where + F: Fn() -> Result> + Send + Sync + 'static, + { + Self::from_factory(OpenerSource { + len, + open: Arc::new(open), + }) + } + + pub fn len(&self) -> Result { + self.0.len() + } + + pub fn is_empty(&self) -> Result { + self.len().map(|len| len == 0) + } + + pub fn open(&self) -> Result> { + self.0.open() + } +} + +struct MemorySource(Arc<[u8]>); + +impl SourceFactory for MemorySource { + fn len(&self) -> Result { + Ok(self.0.len() as u64) + } + + fn open(&self) -> Result> { + Ok(Box::new(Cursor::new(Arc::clone(&self.0)))) + } +} + +// The shared owner keeps both its bytes and its charge alive if a reader +// outlives the converted entry. Reader boxes get separate capacity charges. +struct WriterMemoryData { + bytes: Vec, + _charge: CapacityCharge, +} +struct WriterMemorySource { + data: Arc, + resources: WriterResources, +} +struct WriterMemoryReader { + data: Arc, + position: u64, + _charge: CapacityCharge, +} +impl SourceFactory for WriterMemorySource { + fn len(&self) -> Result { + Ok(self.data.bytes.len() as u64) + } + fn open(&self) -> Result> { + // WriterMemorySource is constructed only after copy_for_writer has + // admitted an execution charge from these same resources. + let mut charge = self + .resources + .execution_charge() + .expect("writer memory source has an execution allowance"); + charge.grow_to(std::mem::size_of::() as u64)?; + Ok(Box::new(WriterMemoryReader { + data: self.data.clone(), + position: 0, + _charge: charge, + })) + } +} +impl Read for WriterMemoryReader { + fn read(&mut self, out: &mut [u8]) -> std::io::Result { + let mut cursor = Cursor::new(&self.data.bytes); + cursor.set_position(self.position); + let count = cursor.read(out)?; + self.position = cursor.position(); + Ok(count) + } +} +impl Seek for WriterMemoryReader { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + let mut cursor = Cursor::new(&self.data.bytes); + cursor.set_position(self.position); + self.position = cursor.seek(from)?; + Ok(self.position) + } +} + +struct PathSource(PathBuf); + +struct OpenerSource { + len: u64, + open: Arc Result> + Send + Sync>, +} + +impl SourceFactory for OpenerSource { + fn len(&self) -> Result { + Ok(self.len) + } + + fn open(&self) -> Result> { + (self.open)() + } +} + +impl SourceFactory for PathSource { + fn len(&self) -> Result { + Ok(std::fs::metadata(&self.0)?.len()) + } + + fn open(&self) -> Result> { + Ok(Box::new(File::open(&self.0)?)) + } +} + +/// A shared, one-way cancellation signal for archive writes. +/// +/// Clone the token for another thread, or cancel it from an input/output callback. +/// Cancellation is cooperative: it is checked between chunks and during resource +/// waits; it cannot interrupt a caller's blocked I/O or an individual codec step. +#[derive(Clone, Debug, Default)] +pub struct WriteCancellation(Arc); + +impl WriteCancellation { + pub fn new() -> Self { + Self::default() + } + pub fn cancel(&self) { + self.0.store(true, Ordering::Relaxed); + } + pub fn is_cancelled(&self) -> bool { + self.0.load(Ordering::Relaxed) + } +} + +#[derive(Clone, Debug)] +/// Shared compression-workspace and temporary-file policy for streaming writers. +/// +/// Native RAR5 writers retain packed payloads on disk and bound active input and +/// spool handles by compression concurrency, rather than the archive entry count. +/// The workspace limit is not a total process-RAM or temporary-disk quota. On bare +/// WebAssembly (`wasm32-unknown-unknown`), spools stay in memory and their retained +/// payloads are additional to this limit. `with_max_spool_bytes` separately caps +/// logical spool contents on both backends. `with_max_spool_memory_bytes` caps +/// bare-WASM spool payload and index capacity, excluding other writer memory. +pub struct WriterResources { + memory_limit: u64, + temp_dir: Option>, + budget: Arc, + spool_budget: Option>, + spool_memory_budget: Option>, + prepared_header_budget: Option>, + preparation_budget: Option>, + cancellation: Option, + pub(crate) execution: Option, +} + +impl Default for WriterResources { + fn default() -> Self { + Self::new(DEFAULT_WRITER_MEMORY_LIMIT) + } +} + +impl WriterResources { + pub fn new(memory_limit: u64) -> Self { + Self { + memory_limit, + temp_dir: None, + budget: Arc::new(MemoryBudget::new(memory_limit)), + spool_budget: None, + spool_memory_budget: None, + prepared_header_budget: None, + preparation_budget: None, + cancellation: None, + execution: None, + } + } + + /// Set a hard ceiling on managed writer allocation capacity for RAR5/7. + /// Includes active work, retained spools/headers, conversion and owned output. + /// Caller-owned inputs and external sinks, allocator/runtime overhead, stacks + /// and OS memory are excluded. This is not a process-RAM limit. + /// Legacy writers refuse this policy. The estimated workspace policy remains + /// independent. Configure before execution; clones share the new ledger. + pub fn with_max_memory_bytes(mut self, limit: u64) -> Self { + self.execution = Some(crate::codec::workspace::Allowance::limited(limit)); + self + } + + pub fn max_memory_bytes(&self) -> Option { + self.execution + .as_ref() + .map(crate::codec::workspace::Limited::limit) + } + + /// Live managed capacity plus reservations for admitted workers. + pub fn managed_memory_in_use(&self) -> u64 { + self.execution + .as_ref() + .map_or(0, crate::codec::workspace::Limited::used) + } + + pub(crate) fn execution_charge(&self) -> Option { + CapacityCharge::new(self, &None) + } + + /// Cap the sum of live logical spool lengths, including reserved growth. + /// Native spools use files; bare-WASM spools use memory. This does not cap + /// filesystem allocation, Vec capacity, codec workspace or final output. + /// Zero allows empty spools only. Growth fails immediately rather than waiting. + /// + /// Configuring this creates a fresh quota group; subsequent clones share it. + /// Configure before dispatching work. Parking a spool or returning from a + /// write does not release storage still owned by an EntrySource or reader. + /// Failed native cleanup retains its charge conservatively in this group. + pub fn with_max_spool_bytes(mut self, limit: u64) -> Self { + self.spool_budget = Some(Arc::new(StorageBudget { + resource: StorageResource::LogicalBytes, + limit, + used: Mutex::new(0), + #[cfg(test)] + refusal: None, + })); + self + } + + /// The optional logical spool quota, independent of `memory_limit()`. + pub fn max_spool_bytes(&self) -> Option { + self.spool_budget.as_ref().map(|budget| budget.limit) + } + + /// Cap shared in-memory spool payload and index capacity on bare WASM. + /// Bounded spools allocate zeroed 4096-byte blocks and a boxed index. Growth + /// reserves both old and replacement indexes before allocation. Allocator + /// overhead, codec workspace and output are not included. + /// This is not an aggregate managed-memory or process-RAM ceiling. + /// + /// Native file spools have no in-memory payload charge. The default remains + /// an unbounded Vec backend on WASM; zero permits only empty memory spools. + /// Configuring creates a fresh group, shared by subsequent resource clones. + /// Logical spool lengths remain independently limited by `max_spool_bytes`. + pub fn with_max_spool_memory_bytes(mut self, limit: u64) -> Self { + self.spool_memory_budget = Some(Arc::new(StorageBudget { + resource: StorageResource::PayloadMemory, + limit, + used: Mutex::new(0), + #[cfg(test)] + refusal: None, + })); + self + } + + /// The optional memory-spool payload and index capacity quota. + pub fn max_spool_memory_bytes(&self) -> Option { + self.spool_memory_budget.as_ref().map(|budget| budget.limit) + } + + /// Cap final RAR5/7 member and service header images retained by single-archive + /// preparation. Counts encryption IVs and padding, with admission before + /// allocation. Serializer scratch, main/end headers, volume fragment headers, + /// legacy headers and coordinator records are outside this quota. + /// Defaults to unlimited. Configuring creates a fresh group shared by clones. + pub fn with_max_prepared_header_bytes(mut self, limit: u64) -> Self { + self.prepared_header_budget = Some(Arc::new(StorageBudget { + resource: StorageResource::PreparedHeaders, + limit, + used: Mutex::new(0), + #[cfg(test)] + refusal: None, + })); + self + } + + /// The optional quota for retained RAR5/7 prepared header images. + pub fn max_prepared_header_bytes(&self) -> Option { + self.prepared_header_budget + .as_ref() + .map(|budget| budget.limit) + } + + pub(crate) fn reserve_prepared_header(&self, bytes: u64) -> Result> { + self.prepared_header_budget + .as_ref() + .map(|budget| { + let mut charge = StorageCharge { + budget: budget.clone(), + bytes: 0, + }; + charge.grow_to(bytes)?; + Ok(charge) + }) + .transpose() + } + + /// Bound RAR5/7 engine header scratch, images, descriptor arrays and boxed + /// preparation state, including volume and recovery headers. Capacity is + /// reserved before allocation, including old/replacement overlap on growth. + /// Configuring creates a new ledger shared by resource clones; default is + /// unlimited. Legacy writers explicitly refuse this policy. + /// + /// Coordinator plan/job/result descriptor arrays also count; their pointed-to + /// input/history and codec payload buffers do not. Codec/KDF/recovery workspace, + /// input conversion, source/sink callbacks, collectors, diagnostics and allocator + /// overhead are outside this quota. This is not a total writer-memory cap. + pub fn with_max_preparation_bytes(mut self, limit: u64) -> Self { + self.preparation_budget = Some(Arc::new(StorageBudget { + resource: StorageResource::Preparation, + limit, + used: Mutex::new(0), + #[cfg(test)] + refusal: None, + })); + self + } + + #[cfg(test)] + pub(crate) fn refuse_preparation_growth_at( + self, + fail_at: usize, + ) -> (Self, Arc) { + let mut resources = self.with_max_preparation_bytes(u64::MAX); + let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0)); + Arc::get_mut(resources.preparation_budget.as_mut().unwrap()) + .unwrap() + .refusal = Some((attempts.clone(), fail_at)); + (resources, attempts) + } + + /// The optional shared RAR5/7 engine preparation capacity limit. + pub fn max_preparation_bytes(&self) -> Option { + self.preparation_budget.as_ref().map(|budget| budget.limit) + } + + pub(crate) fn preparation_charge(&self) -> Option { + CapacityCharge::new(self, &self.preparation_budget) + } + + #[cfg(any(test, all(target_arch = "wasm32", target_os = "unknown")))] + fn spool_capacity_charge(&self) -> Option { + CapacityCharge::new(self, &self.spool_memory_budget) + } + + // A coordinator supplies a child scope to its admitted workers. + pub(crate) fn with_execution_allowance( + mut self, + allowance: crate::codec::workspace::Limited, + ) -> Self { + self.execution = Some(allowance); + self + } + + /// Place temporary spools in this existing directory (default: the current + /// directory). Use a directory whose contents untrusted users cannot replace: + /// idle spools are closed and later reopened by path. + /// + /// Spools may contain unencrypted compressed data even for encrypted output. + /// Files are created exclusively, with owner-only access on Unix (0600 before + /// applying the umask); other platforms use inherited directory permissions. + /// Dropping a spool closes its handle before attempting removal, including on + /// errors and unwind. Removal is best-effort, not secure erasure, and process + /// termination can leave files behind. Bare WASM ignores this setting. + pub fn with_temp_dir(mut self, path: impl Into) -> Self { + self.temp_dir = Some(Arc::new(path.into())); + self + } + + /// Attach a cancellation token to archive writes using this policy. + /// The token works without a progress callback. Cancellation returns + /// [`Error::Cancelled`]; a direct output sink may already contain partial data. + pub fn with_cancellation(mut self, cancellation: WriteCancellation) -> Self { + self.cancellation = Some(cancellation); + self + } + + pub(crate) fn has_cancellation(&self) -> bool { + self.cancellation.is_some() + } + + pub(crate) fn is_cancelled(&self) -> bool { + self.cancellation + .as_ref() + .is_some_and(WriteCancellation::is_cancelled) + } + + pub fn memory_limit(&self) -> u64 { + self.memory_limit + } + + pub fn temp_dir(&self) -> Option<&Path> { + self.temp_dir.as_deref().map(PathBuf::as_path) + } + + #[cfg(test)] + pub(crate) fn workspace_in_use(&self) -> u64 { + *self.budget.used.lock().unwrap() + } + + #[cfg(test)] + pub(crate) fn preparation_in_use(&self) -> u64 { + self.preparation_budget + .as_ref() + .map_or(0, |budget| *budget.used.lock().unwrap()) + } + + #[cfg(test)] + pub(crate) fn acquire(&self, required: u64, dictionary_size: u64) -> Result { + self.acquire_cancellable(required, dictionary_size, &|| false) + } + + pub(crate) fn acquire_cancellable( + &self, + required: u64, + dictionary_size: u64, + cancelled: &dyn Fn() -> bool, + ) -> Result { + let cancelled = || self.is_cancelled() || cancelled(); + if cancelled() { + return Err(Error::Cancelled); + } + if required > self.memory_limit { + return Err(Error::MemoryLimitExceeded { + limit: self.memory_limit, + required, + dictionary_size, + }); + } + self.budget.acquire_cancellable(required, &cancelled) + } + + /// Reserves what a member needs, or the whole budget if one member needs + /// more than that. + /// + /// The RAR 1.3 to 4.x codecs compress a member as a unit, so there is no + /// smaller piece to fall back to when one does not fit. Here the budget + /// decides how many members are compressed at once rather than whether the + /// job can run at all, and a member larger than the budget runs alone. + pub(crate) fn acquire_serialising_cancellable( + &self, + required: u64, + cancelled: &dyn Fn() -> bool, + ) -> Result { + self.budget + .acquire_cancellable(required.min(self.memory_limit), &|| { + self.is_cancelled() || cancelled() + }) + } +} + +/// Live storage and reservations share one ledger across resource clones. +/// No waiter can make progress by waiting for spools it must itself retain. +#[derive(Debug, Clone, Copy)] +enum StorageResource { + LogicalBytes, + PayloadMemory, + PreparedHeaders, + Preparation, +} + +#[derive(Debug)] +struct StorageBudget { + resource: StorageResource, + limit: u64, + used: Mutex, + #[cfg(test)] + refusal: Option<(Arc, usize)>, +} + +#[derive(Debug)] +pub(crate) struct StorageCharge { + budget: Arc, + bytes: u64, +} + +impl StorageCharge { + fn new(resources: &WriterResources) -> Option { + resources.spool_budget.as_ref().map(|budget| Self { + budget: budget.clone(), + bytes: 0, + }) + } + + pub(crate) fn grow_to(&mut self, bytes: u64) -> Result<()> { + let growth = bytes.saturating_sub(self.bytes); + if growth == 0 { + return Ok(()); + } + #[cfg(test)] + if let Some((attempts, fail_at)) = &self.budget.refusal { + if attempts.fetch_add(1, std::sync::atomic::Ordering::Relaxed) == *fail_at { + return Err(Error::WriterFailure( + "injected preparation admission failure", + )); + } + } + let mut used = self.budget.used.lock().expect("spool budget lock poisoned"); + let required = used.checked_add(growth); + if required.is_none_or(|required| required > self.budget.limit) { + let required = required.unwrap_or(u64::MAX); + return Err(match self.budget.resource { + StorageResource::LogicalBytes => Error::WriterSpoolLimitExceeded { + limit: self.budget.limit, + required, + used: *used, + }, + StorageResource::Preparation => Error::WriterPreparationLimitExceeded { + limit: self.budget.limit, + required, + used: *used, + }, + StorageResource::PreparedHeaders => Error::WriterPreparedHeaderLimitExceeded { + limit: self.budget.limit, + required, + used: *used, + }, + StorageResource::PayloadMemory => Error::WriterSpoolMemoryLimitExceeded { + limit: self.budget.limit, + required, + used: *used, + }, + }); + } + *used = required.unwrap(); + self.bytes = bytes; + Ok(()) + } + + fn shrink_to(&mut self, bytes: u64) { + let released = self.bytes - bytes; + if released != 0 { + let mut used = self.budget.used.lock().expect("spool budget lock poisoned"); + *used -= released; + self.bytes = bytes; + } + } +} + +impl Drop for StorageCharge { + fn drop(&mut self) { + self.shrink_to(0); + } +} + +/// A capacity owner can satisfy its existing class quota and an execution +/// reservation together. Failed admission rolls both ledgers back. +#[derive(Debug)] +pub(crate) enum CapacityCharge { + Storage(StorageCharge), + Execution { + storage: Option, + charge: crate::codec::workspace::Charge, + }, +} +impl CapacityCharge { + fn new(_resources: &WriterResources, budget: &Option>) -> Option { + let storage = budget.as_ref().map(|budget| StorageCharge { + budget: budget.clone(), + bytes: 0, + }); + if let Some(allowance) = &_resources.execution { + return Some(Self::Execution { + storage, + charge: crate::codec::workspace::Budget::charge(allowance), + }); + } + storage.map(Self::Storage) + } + fn bytes(&self) -> u64 { + match self { + Self::Storage(storage) => storage.bytes, + Self::Execution { charge, .. } => charge.bytes(), + } + } + pub(crate) fn grow_to(&mut self, bytes: u64) -> Result<()> { + if bytes <= self.bytes() { + return Ok(()); + } + match self { + Self::Storage(storage) => storage.grow_to(bytes), + Self::Execution { storage, charge } => { + use crate::codec::workspace::{Budget, Limited}; + let old = charge.bytes(); + Limited::resize(charge, bytes)?; + if let Some(storage) = storage { + if let Err(error) = storage.grow_to(bytes) { + Limited::resize(charge, old).expect("rolling back capacity cannot fail"); + return Err(error); + } + } + Ok(()) + } + } + } + fn shrink_to(&mut self, bytes: u64) { + match self { + Self::Storage(storage) => storage.shrink_to(bytes), + Self::Execution { storage, charge } => { + use crate::codec::workspace::{Budget, Limited}; + if let Some(storage) = storage { + storage.shrink_to(bytes); + } + Limited::resize(charge, bytes).expect("releasing capacity cannot fail"); + } + } + } +} + +#[derive(Debug)] +struct MemoryBudget { + limit: u64, + used: Mutex, + changed: Condvar, +} + +impl MemoryBudget { + fn new(limit: u64) -> Self { + Self { + limit, + used: Mutex::new(0), + changed: Condvar::new(), + } + } + + fn acquire_cancellable( + self: &Arc, + bytes: u64, + cancelled: &dyn Fn() -> bool, + ) -> Result { + // Call user cancellation code outside the budget mutex: a callback can + // release a permit, and must not deadlock with its own admission wait. + loop { + if cancelled() { + return Err(Error::Cancelled); + } + let mut used = self.used.lock().expect("memory budget lock poisoned"); + if self.limit.saturating_sub(*used) >= bytes { + *used += bytes; + return Ok(MemoryPermit { + budget: Arc::clone(self), + bytes, + }); + } + // Tokens and progress callbacks need not notify this condition + // variable, so wake periodically even while all permits are held. + drop( + self.changed + .wait_timeout(used, std::time::Duration::from_millis(25)) + .expect("memory budget lock poisoned while waiting"), + ); + } + } +} + +pub(crate) struct MemoryPermit { + budget: Arc, + bytes: u64, +} + +/// Where a spool keeps its bytes. +/// +/// A file on every real platform, which is the point: the RAR 5 writer spools +/// so that a member larger than the memory budget still gets written. Bare +/// WebAssembly has no filesystem, so there it is a buffer, and the budget stops +/// covering their retained storage. The optional logical spool quota applies +/// to both backends, independently of Vec capacity. Both are `Read + Write + Seek`. +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +type SpoolStore = File; +#[cfg(all(target_arch = "wasm32", target_os = "unknown"))] +type SpoolStore = memory_spool::MemorySpool; + +/// Owns a temporary payload until drop; parking releases only its handle. +/// Writes are unbuffered, so parking requires no flush and preserves the cursor. +/// The file must live until assembly finishes, even when no handle is open. +pub(crate) struct Spool { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + path: PathBuf, + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + _path_charge: Option, + file: Option, + len: u64, + pos: u64, + charge: Option, +} + +impl Spool { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + pub(crate) fn create(resources: &WriterResources) -> Result { + Self::create_with_sequence(resources, crate::temp_file::next_sequence) + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + fn create_with_sequence( + resources: &WriterResources, + next_sequence: impl FnMut() -> u64, + ) -> Result { + let directory = resources.temp_dir().unwrap_or_else(|| Path::new(".")); + let (path, file, path_charge) = crate::temp_file::create_with_sequence( + directory, + |capacity| { + let mut charge = CapacityCharge::new(resources, &None); + if let Some(charge) = &mut charge { + charge.grow_to(capacity as u64)?; + } + Ok(charge) + }, + next_sequence, + )?; + Ok(Self { + path, + _path_charge: path_charge, + file: Some(file), + len: 0, + pos: 0, + charge: StorageCharge::new(resources), + }) + } + + #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] + pub(crate) fn create(resources: &WriterResources) -> Result { + crate::temp_file::next_sequence(); + Ok(Self { + file: Some(memory_spool::MemorySpool::new(resources)), + len: 0, + pos: 0, + charge: StorageCharge::new(resources), + }) + } + + /// Allocate a spool whose handle is not retained while waiting for work. + pub(crate) fn create_parked(resources: &WriterResources) -> Result { + let mut spool = Self::create(resources)?; + spool.park(); + Ok(spool) + } + + /// Release the OS handle, retaining ownership of the file and its cursor. + /// Bare WASM has no handle to release and must retain the in-memory bytes. + pub(crate) fn park(&mut self) { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + { + self.file = None; + } + } + + fn file(&mut self) -> std::io::Result<&mut SpoolStore> { + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + if self.file.is_none() { + let mut file = File::options().read(true).write(true).open(&self.path)?; + file.seek(SeekFrom::Start(self.pos))?; + self.file = Some(file); + } + Ok(self.file.as_mut().expect("spool backing store is present")) + } + + pub(crate) fn len(&self) -> u64 { + self.len + } + + pub(crate) fn rewind(&mut self) -> Result<()> { + self.seek_to(0) + } + + /// Moves the read/write cursor to an absolute offset. + pub(crate) fn seek_to(&mut self, pos: u64) -> Result<()> { + self.seek(SeekFrom::Start(pos))?; + Ok(()) + } + + pub(crate) fn copy_to(&mut self, output: &mut dyn Write) -> Result { + let result = (|| { + self.rewind()?; + Ok(std::io::copy(self, output)?) + })(); + self.park(); + result + } + + /// Copies `len` bytes starting at `start` to `output`, which is how a + /// volume set takes one fragment of a member at a time. + pub(crate) fn copy_range_to( + &mut self, + start: u64, + len: u64, + output: &mut dyn Write, + ) -> Result { + let result = (|| { + self.seek_to(start)?; + let copied = std::io::copy(&mut self.take(len), output)?; + if copied != len { + return Err(std::io::Error::new( + std::io::ErrorKind::UnexpectedEof, + "spooled range is shorter than expected", + ) + .into()); + } + Ok(copied) + })(); + self.park(); + result + } +} + +impl Spool { + // Keep reservation/reconciliation identical for native and memory stores. + // The operation also permits deterministic short-write regression tests. + fn write_with( + &mut self, + buffer: &[u8], + write: impl FnOnce(&mut SpoolStore, &[u8]) -> std::io::Result, + ) -> std::io::Result { + if buffer.is_empty() { + return Ok(0); + } + let end = self.pos.checked_add(buffer.len() as u64).ok_or_else(|| { + std::io::Error::other(Error::InvalidArgument("spool length overflows u64")) + })?; + if let Some(charge) = &mut self.charge { + charge + .grow_to(self.len.max(end)) + .map_err(std::io::Error::other)?; + } + // Keep the reservation while the backing store grows. Release only the + // unwritten allowance on errors or short writes; overwrites cost nothing. + let result = self.file().and_then(|file| write(file, buffer)); + match result { + Ok(written) if written != 0 => { + self.pos += written as u64; + self.len = self.len.max(self.pos); + } + _ => {} + } + if let Some(charge) = &mut self.charge { + charge.shrink_to(self.len); + } + result + } +} + +impl Write for Spool { + fn write(&mut self, buffer: &[u8]) -> std::io::Result { + self.write_with(buffer, |file, bytes| file.write(bytes)) + } + + fn flush(&mut self) -> std::io::Result<()> { + self.file()?.flush() + } +} + +impl Read for Spool { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + let read = self.file()?.read(buffer)?; + self.pos = self.pos.saturating_add(read as u64); + Ok(read) + } +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +impl Spool { + pub(crate) fn into_source(mut self) -> EntrySource { + self.park(); + let owner = Arc::new(self); + EntrySource::from_opener(owner.len(), move || { + Ok(Box::new(SpoolReader { + file: std::fs::File::open(&owner.path)?, + _owner: owner.clone(), + })) + }) + } +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +struct SpoolReader { + file: std::fs::File, + _owner: Arc, +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +impl Read for SpoolReader { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + self.file.read(buffer) + } +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +impl Seek for SpoolReader { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.file.seek(from) + } +} + +impl Seek for Spool { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.pos = self.file()?.seek(from)?; + Ok(self.pos) + } +} + +impl Drop for Spool { + fn drop(&mut self) { + self.file = None; + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + if let Err(error) = std::fs::remove_file(&self.path) { + if error.kind() != std::io::ErrorKind::NotFound { + // The backing file may still occupy storage. Keep that debt in + // the shared quota group instead of admitting replacement bytes. + if let Some(charge) = &mut self.charge { + charge.bytes = 0; + } + } + } + } +} + +impl Drop for MemoryPermit { + fn drop(&mut self) { + let mut used = self + .budget + .used + .lock() + .expect("memory budget lock poisoned"); + *used = used.saturating_sub(self.bytes); + self.budget.changed.notify_all(); + } +} + +#[cfg(test)] +mod tests { + #[test] + fn entry_source_length_helpers_handle_empty_data_and_length_errors() { + use super::*; + + let empty = EntrySource::from_bytes(Arc::<[u8]>::from(&b""[..])); + assert!(empty.is_empty().unwrap()); + assert!(format!("{empty:?}").contains("len: Some(0)")); + + let nonempty = EntrySource::from_bytes(Arc::<[u8]>::from(&b"x"[..])); + assert!(!nonempty.is_empty().unwrap()); + + let missing = + EntrySource::from_path(crate::scratch::case("missing-source").join("missing")); + assert!(missing.is_empty().is_err()); + assert!(format!("{missing:?}").contains("len: None")); + } + + #[test] + fn preparation_refusal_is_one_shot_and_releases_the_charge() { + use super::preparation::Bytes; + use super::*; + use std::sync::atomic::Ordering; + + let (resources, attempts) = WriterResources::default().refuse_preparation_growth_at(0); + assert_eq!( + Bytes::zeroed(1, &resources).unwrap_err(), + Error::WriterFailure("injected preparation admission failure") + ); + assert_eq!(attempts.load(Ordering::Relaxed), 1); + assert_eq!( + *resources + .preparation_budget + .as_ref() + .unwrap() + .used + .lock() + .unwrap(), + 0 + ); + drop(Bytes::zeroed(1, &resources).unwrap()); + assert_eq!( + *resources + .preparation_budget + .as_ref() + .unwrap() + .used + .lock() + .unwrap(), + 0 + ); + } + #[test] + fn workspace_admission_reports_preexisting_cancellation_before_budget_checks() { + use super::*; + + let cancellation = WriteCancellation::new(); + cancellation.cancel(); + let resources = WriterResources::new(1).with_cancellation(cancellation); + assert!(matches!( + resources.acquire_cancellable(2, 0, &|| false), + Err(Error::Cancelled) + )); + assert!(matches!( + resources.acquire_cancellable(1, 0, &|| true), + Err(Error::Cancelled) + )); + assert!(matches!( + resources.acquire_serialising_cancellable(1, &|| { + panic!("pre-cancelled resources called the progress callback") + }), + Err(Error::Cancelled) + )); + assert_eq!(resources.workspace_in_use(), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_rejects_length_overflow_before_writing_or_charging() { + use super::*; + + let root = crate::scratch::case("spool-length-overflow"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(16); + let mut spool = Spool::create(&resources).unwrap(); + spool.pos = u64::MAX; + let error = spool.write(b"ab").unwrap_err(); + assert_eq!(error.kind(), std::io::ErrorKind::Other); + assert_eq!(spool.len, 0); + assert_eq!(spool_used(&resources), 0); + } + + #[test] + fn writer_memory_reader_retains_payload_after_source_drop() { + use super::*; + let resources = WriterResources::default().with_max_memory_bytes(8192); + let source = EntrySource::copy_for_writer(&[42; 4096], &resources).unwrap(); + let retained = resources.managed_memory_in_use(); + assert!(retained >= 4096); + let mut reader = source.open().unwrap(); + drop(source); + assert!(resources.managed_memory_in_use() > retained); + let mut bytes = [0; 4096]; + reader.read_exact(&mut bytes).unwrap(); + assert_eq!(bytes, [42; 4096]); + drop(reader); + assert_eq!(resources.managed_memory_in_use(), 0); + } + + use super::*; + fn spool_used(resources: &WriterResources) -> u64 { + *resources + .spool_budget + .as_ref() + .unwrap() + .used + .lock() + .unwrap() + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_path_capacity_survives_parking_and_refuses_before_file_creation() { + let root = crate::scratch::case("spool-path-capacity"); + let limited = crate::codec::workspace::Allowance::limited(1); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_execution_allowance(limited.clone()); + assert_eq!( + Spool::create(&resources).err().unwrap().kind(), + crate::ErrorKind::ResourceLimit + ); + assert_eq!(limited.used(), 0); + assert_eq!(std::fs::read_dir(&*root).unwrap().count(), 0); + let ledger = crate::codec::workspace::Allowance::limited(4096); + let resources = resources.with_execution_allowance(ledger.clone()); + let mut spool = Spool::create(&resources).unwrap(); + let capacity = spool.path.capacity() as u64; + assert_eq!(ledger.used(), capacity); + spool.write_all(b"payload").unwrap(); + spool.park(); + assert_eq!(ledger.used(), capacity); + let mut copied = Vec::new(); + spool.copy_to(&mut copied).unwrap(); + assert_eq!(copied, b"payload"); + assert_eq!(ledger.used(), capacity); + drop(spool); + assert_eq!(ledger.used(), 0); + assert_eq!(std::fs::read_dir(&*root).unwrap().count(), 0); + } + + #[test] + fn spool_reservations_refuse_arithmetic_overflow() { + let resources = WriterResources::default().with_max_spool_bytes(u64::MAX); + let mut first = StorageCharge::new(&resources).unwrap(); + let mut second = StorageCharge::new(&resources).unwrap(); + first.grow_to(u64::MAX).unwrap(); + assert_eq!( + second.grow_to(1).unwrap_err(), + Error::WriterSpoolLimitExceeded { + limit: u64::MAX, + required: u64::MAX, + used: u64::MAX, + } + ); + drop(first); + second.grow_to(1).unwrap(); + assert_eq!(spool_used(&resources), 1); + } + + #[test] + fn spool_quota_counts_live_extents_across_parking_and_overwrites() { + let root = crate::scratch::case("spool-quota-extents"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(10); + let mut first = Spool::create(&resources).unwrap(); + first.write_all(b"abcdef").unwrap(); + first.park(); + let mut second = Spool::create(&resources.clone()).unwrap(); + second.write_all(b"1234").unwrap(); + assert_eq!(spool_used(&resources), 10); + let error = Error::from(second.write(b"x").unwrap_err()); + assert_eq!( + error, + Error::WriterSpoolLimitExceeded { + limit: 10, + required: 11, + used: 10 + } + ); + assert_eq!(second.len(), 4); + first.seek_to(1).unwrap(); + first.write_all(b"XY").unwrap(); + assert_eq!(spool_used(&resources), 10); + drop(second); + assert_eq!(spool_used(&resources), 6); + first.seek_to(9).unwrap(); + assert_eq!(spool_used(&resources), 6); + first.write_all(b"Z").unwrap(); // charge the hole as well + assert_eq!(spool_used(&resources), 10); + let mut bytes = Vec::new(); + first.copy_to(&mut bytes).unwrap(); + assert_eq!(bytes, b"aXYdef\0\0\0Z"); + drop(first); + assert_eq!(spool_used(&resources), 0); + } + + #[test] + fn spool_short_writes_hold_then_reconcile_the_growth_reservation() { + let root = crate::scratch::case("spool-quota-short-write"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(10); + let mut spool = Spool::create(&resources).unwrap(); + let written = spool + .write_with(b"0123456789", |file, bytes| { + assert_eq!(spool_used(&resources), 10); + file.write(&bytes[..3]) + }) + .unwrap(); + assert_eq!(written, 3); + assert_eq!(spool.len(), 3); + assert_eq!(spool_used(&resources), 3); + spool.seek_to(9).unwrap(); + assert_eq!( + spool + .write_with(b"x", |_, _| { + assert_eq!(spool_used(&resources), 10); + Ok(0) + }) + .unwrap(), + 0 + ); + assert_eq!(spool.len(), 3); + assert_eq!(spool_used(&resources), 3); + assert!(spool + .write_with(b"xx", |_, _| panic!("refusal must precede backing I/O")) + .is_err()); + assert_eq!(spool_used(&resources), 3); + } + + #[test] + fn spool_zero_limit_allows_empty_writes_but_no_growth() { + let root = crate::scratch::case("spool-quota-zero"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(0); + let mut spool = Spool::create(&resources).unwrap(); + spool.seek_to(100).unwrap(); + assert_eq!(spool.write(b"").unwrap(), 0); + assert_eq!(spool.len(), 0); + assert_eq!(spool_used(&resources), 0); + assert!(matches!( + Error::from(spool.write(b"x").unwrap_err()), + Error::WriterSpoolLimitExceeded { + limit: 0, + required: 101, + used: 0 + } + )); + assert_eq!(spool.len(), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn failed_backing_write_releases_only_its_reservation() { + let root = crate::scratch::case("spool-quota-io"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(10); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abc").unwrap(); + spool.park(); + let mut read_only = File::open(&spool.path).unwrap(); + read_only.seek(SeekFrom::Start(3)).unwrap(); + spool.file = Some(read_only); + assert!(spool.write_all(b"1234567").is_err()); + assert_eq!(spool_used(&resources), 3); + assert_eq!(spool.len(), 3); + spool.park(); + spool.write_all(b"1234567").unwrap(); + assert_eq!(spool_used(&resources), 10); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_sources_and_readers_retain_their_charge() { + let root = crate::scratch::case("spool-quota-source"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(3); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abc").unwrap(); + let source = spool.into_source(); + let mut reader = source.open().unwrap(); + drop(source); + assert_eq!(spool_used(&resources), 3); + let mut another = Spool::create(&resources).unwrap(); + assert!(another.write(b"x").is_err()); + let mut bytes = Vec::new(); + reader.read_to_end(&mut bytes).unwrap(); + assert_eq!(bytes, b"abc"); + drop(reader); + another.write_all(b"xyz").unwrap(); + assert_eq!(spool_used(&resources), 3); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn concurrent_spool_growth_cannot_overbook_shared_resources() { + let root = crate::scratch::case("spool-quota-concurrent"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(10); + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::scope(|scope| { + for _ in 0..4 { + let tx = tx.clone(); + let resources = resources.clone(); + scope.spawn(move || { + let mut spool = Spool::create(&resources).unwrap(); + let result = spool.write_all(b"1234567").map_err(Error::from); + tx.send((spool, result)).unwrap(); + }); + } + }); + drop(tx); + let outcomes: Vec<_> = rx.into_iter().collect(); + assert_eq!( + outcomes.iter().filter(|(_, result)| result.is_ok()).count(), + 1 + ); + assert_eq!(spool_used(&resources), 7); + for (_, result) in &outcomes { + if let Err(error) = result { + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + } + } + drop(outcomes); + assert_eq!(spool_used(&resources), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_cleanup_failure_retains_debt_in_the_quota_group() { + let root = crate::scratch::case("spool-quota-cleanup"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(3); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abc").unwrap(); + spool.park(); + let original = spool.path.clone(); + // Force removal to fail without relying on root/Windows permissions. + std::fs::rename(&original, root.join("orphan")).unwrap(); + std::fs::create_dir(&original).unwrap(); + drop(spool); + assert_eq!(spool_used(&resources), 3); + let mut another = Spool::create(&resources).unwrap(); + assert!(another.write_all(b"x").is_err()); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_cleanup_failure_without_quota_does_not_panic() { + let root = crate::scratch::case("spool-unlimited-cleanup"); + let resources = WriterResources::default().with_temp_dir(&*root); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abc").unwrap(); + let original = spool.path.clone(); + std::fs::rename(&original, root.join("orphan")).unwrap(); + std::fs::create_dir(&original).unwrap(); + drop(spool); + assert!(original.is_dir()); + assert_eq!(std::fs::read(root.join("orphan")).unwrap(), b"abc"); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_creation_accepts_the_maximum_sequence() { + let root = crate::scratch::case("spool-max-sequence"); + let resources = WriterResources::default().with_temp_dir(&*root); + let spool = Spool::create_with_sequence(&resources, || u64::MAX).unwrap(); + let path = root.join(format!( + ".rars-spool-{}-ffffffffffffffff", + std::process::id() + )); + assert_eq!(spool.path, path); + assert!(path.is_file()); + drop(spool); + assert!(!path.exists()); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_creation_retries_collisions_and_reports_exhaustion() { + let root = crate::scratch::case("spool-name-collision"); + let name = |sequence| format!(".rars-spool-{}-{sequence:016x}", std::process::id()); + std::fs::write(root.join(name(0)), b"occupied").unwrap(); + let resources = WriterResources::default().with_temp_dir(&*root); + let mut sequence = 0; + let spool = Spool::create_with_sequence(&resources, || { + let value = sequence; + sequence += 1; + value + }) + .unwrap(); + assert_eq!(sequence, 2); + assert_eq!(spool.path, root.join(name(1))); + drop(spool); + + for sequence in 1..128 { + std::fs::write(root.join(name(sequence)), b"occupied").unwrap(); + } + let mut sequence = 0; + let error = Spool::create_with_sequence(&resources, || { + let value = sequence; + sequence += 1; + value + }) + .err() + .unwrap(); + assert_eq!(sequence, 128); + assert_eq!(error.kind(), crate::ErrorKind::Io); + assert_eq!(std::fs::read(root.join(name(0))).unwrap(), b"occupied"); + + let missing = WriterResources::default().with_temp_dir(root.join("missing")); + let error = Spool::create_with_sequence(&missing, || 0).err().unwrap(); + assert_eq!(error.kind(), crate::ErrorKind::Io); + } + + #[test] + fn spool_quota_is_released_on_unwind() { + let root = crate::scratch::case("spool-quota-unwind"); + let resources = WriterResources::default() + .with_temp_dir(&*root) + .with_max_spool_bytes(3); + let result = std::panic::catch_unwind(|| { + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abc").unwrap(); + panic!("injected unwind"); + }); + assert!(result.is_err()); + assert_eq!(spool_used(&resources), 0); + } + + #[test] + fn byte_sources_are_rewindable_without_copying() { + let source = EntrySource::from_bytes(Arc::<[u8]>::from(&b"hello"[..])); + let mut first = source.open().unwrap(); + let mut second = source.open().unwrap(); + let mut a = Vec::new(); + let mut b = Vec::new(); + first.read_to_end(&mut a).unwrap(); + second.read_to_end(&mut b).unwrap(); + assert_eq!(a, b"hello"); + assert_eq!(b, b"hello"); + } + + #[test] + fn spool_tracks_length_across_seeks_and_overwrites() { + let scratch = crate::scratch::case("rars-spool"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"0123456789").unwrap(); + assert_eq!(spool.len(), 10); + + // Rewriting earlier bytes must not extend the spool. + spool.seek_to(4).unwrap(); + spool.write_all(b"ab").unwrap(); + assert_eq!(spool.len(), 10); + + // Writing past the end does extend it. + spool.seek_to(9).unwrap(); + spool.write_all(b"xyz").unwrap(); + assert_eq!(spool.len(), 12); + + let mut copied = Vec::new(); + spool.copy_to(&mut copied).unwrap(); + assert_eq!(copied, b"0123ab678xyz"); + } + + #[test] + fn spool_reads_from_the_seeked_position() { + let scratch = crate::scratch::case("rars-spool"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"abcdefgh").unwrap(); + spool.seek(SeekFrom::Start(3)).unwrap(); + + let mut buffer = [0u8; 4]; + spool.read_exact(&mut buffer).unwrap(); + assert_eq!(&buffer, b"defg"); + assert_eq!(spool.stream_position().unwrap(), 7); + } + + #[test] + fn parked_spools_preserve_cursor_and_release_handles_after_copy_errors() { + let scratch = crate::scratch::case("parked-spool"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + let mut spool = Spool::create_parked(&resources).unwrap(); + spool.write_all(b"abcdef").unwrap(); + spool.seek_to(2).unwrap(); + spool.park(); + spool.write_all(b"XY").unwrap(); + spool.park(); + spool.write_all(b"Z").unwrap(); + assert_eq!(spool.len(), 6); + let mut bytes = Vec::new(); + spool.copy_range_to(1, 4, &mut bytes).unwrap(); + assert_eq!(bytes, b"bXYZ"); + struct FailingSink; + impl Write for FailingSink { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(std::io::Error::from(std::io::ErrorKind::PermissionDenied)) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + assert!(spool.copy_to(&mut FailingSink).is_err()); + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + assert!(spool.file.is_none()); + assert!(spool.copy_range_to(0, 7, &mut Vec::new()).is_err()); + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + assert!(spool.file.is_none()); + bytes.clear(); + spool.copy_to(&mut bytes).unwrap(); + assert_eq!(bytes, b"abXYZf"); + drop(spool); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn spool_cleanup_owns_both_active_and_parked_files() { + let scratch = crate::scratch::case("spool-cleanup"); + let resources = WriterResources::default().with_temp_dir(&*scratch); + for parked in [false, true] { + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"private compressed payload").unwrap(); + let path = spool.path.clone(); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + assert_eq!( + std::fs::metadata(&path).unwrap().permissions().mode() & 0o077, + 0 + ); + } + if parked { + spool.park(); + } + assert!(path.exists()); + drop(spool); + assert!(!path.exists()); + } + let unwind = std::panic::catch_unwind(|| { + let mut spool = Spool::create(&resources).unwrap(); + spool.write_all(b"unfinished").unwrap(); + panic!("injected failure"); + }); + assert!(unwind.is_err()); + assert_eq!(std::fs::read_dir(&*scratch).unwrap().count(), 0); + } + + #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] + #[test] + fn admission_waits_can_be_cancelled_without_releasing_the_held_permit() { + use std::sync::mpsc; + use std::time::Duration; + for via_callback in [false, true] { + let cancel = WriteCancellation::new(); + let resources = WriterResources::new(100).with_cancellation(if via_callback { + WriteCancellation::new() + } else { + cancel.clone() + }); + let held = resources.acquire(100, 0).unwrap(); + let (entered_tx, entered_rx) = mpsc::channel(); + let (done_tx, done_rx) = mpsc::channel(); + let callback_cancel = cancel.clone(); + let worker = std::thread::spawn(move || { + let polls = AtomicU64::new(0); + let result = resources.acquire_cancellable(1, 0, &|| { + // Admission checks once before entering the budget and + // again before locking. The third poll proves a timed + // wait occurred while the permit was still held. + if polls.fetch_add(1, Ordering::Relaxed) >= 2 { + let _ = entered_tx.send(()); + } + via_callback && callback_cancel.is_cancelled() + }); + done_tx.send(result.map(|_| ())).unwrap(); + resources + }); + entered_rx.recv_timeout(Duration::from_secs(2)).unwrap(); + cancel.cancel(); + assert_eq!( + done_rx.recv_timeout(Duration::from_secs(2)).unwrap(), + Err(Error::Cancelled) + ); + let resources = worker.join().unwrap(); + assert_eq!(*resources.budget.used.lock().unwrap(), 100); + drop(held); + assert_eq!(*resources.budget.used.lock().unwrap(), 0); + } + } + + #[test] + fn oversized_workspace_is_rejected_before_waiting() { + let resources = WriterResources::new(1024); + assert!(matches!( + resources.acquire(1025, 512), + Err(Error::MemoryLimitExceeded { .. }) + )); + } +} diff --git a/arca-rar/vendor/rars/src/streaming/memory_spool.rs b/arca-rar/vendor/rars/src/streaming/memory_spool.rs new file mode 100644 index 00000000..795e4f53 --- /dev/null +++ b/arca-rar/vendor/rars/src/streaming/memory_spool.rs @@ -0,0 +1,513 @@ +//! Optional bounded storage for bare-WASM spools. +//! Payload blocks and index replacements have known sizes before allocation. +use super::{CapacityCharge, WriterResources}; +use std::io::{self, Cursor, Read, Seek, SeekFrom, Write}; + +const BLOCK_BYTES: usize = 4096; +type Block = Box<[u8; BLOCK_BYTES]>; +const INDEX_ENTRY_BYTES: usize = std::mem::size_of::>(); + +pub(super) struct MemorySpool { + store: Store, +} + +enum Store { + Unbounded(Cursor>), + Bounded(BoundedSpool), +} + +struct BoundedSpool { + // Only index slots move during growth; payload allocations stay in place. + blocks: Box<[Option]>, + block_count: usize, + len: usize, + pos: u64, + // Drop payload and index allocations before releasing their shared charge. + charge: CapacityCharge, +} + +impl MemorySpool { + pub(super) fn new(resources: &WriterResources) -> Self { + let store = match resources.spool_capacity_charge() { + Some(charge) => Store::Bounded(BoundedSpool { + blocks: Box::default(), + block_count: 0, + len: 0, + pos: 0, + charge, + }), + None => Store::Unbounded(Cursor::new(Vec::new())), + }; + Self { store } + } +} + +impl BoundedSpool { + fn grow(&mut self, end: usize) -> io::Result<()> { + let count = end.div_ceil(BLOCK_BYTES); + if count <= self.block_count { + return Ok(()); + } + let overflow = || { + io::Error::new( + io::ErrorKind::InvalidInput, + "memory spool capacity overflow", + ) + }; + let slots = if count > self.blocks.len() { + count.checked_next_power_of_two().ok_or_else(overflow)? + } else { + self.blocks.len() + }; + let payload_bytes = count.checked_mul(BLOCK_BYTES).ok_or_else(overflow)?; + let index_bytes = slots.checked_mul(INDEX_ENTRY_BYTES).ok_or_else(overflow)?; + let retained = payload_bytes + .checked_add(index_bytes) + .ok_or_else(overflow)?; + let old_index_bytes = if slots != self.blocks.len() { + self.blocks.len() * INDEX_ENTRY_BYTES + } else { + 0 + }; + let peak = retained.checked_add(old_index_bytes).ok_or_else(overflow)?; + self.charge.grow_to(peak as u64).map_err(io::Error::other)?; + if slots != self.blocks.len() { + // vec![value; n] requests exactly n elements. The boxed slice keeps + // that layout; no unspecified Vec growth capacity enters the quota. + let mut replacement = vec![None; slots].into_boxed_slice(); + for (target, source) in replacement.iter_mut().zip(self.blocks.iter_mut()) { + *target = source.take(); + } + self.blocks = replacement; + // Assignment freed the old index before its allowance is released. + self.charge.shrink_to(retained as u64); + } + while self.block_count < count { + self.blocks[self.block_count] = Some(Box::new([0; BLOCK_BYTES])); + self.block_count += 1; + } + Ok(()) + } + + fn write(&mut self, bytes: &[u8]) -> io::Result { + if bytes.is_empty() { + return Ok(0); + } + let pos = usize::try_from(self.pos).map_err(|_| { + io::Error::new( + io::ErrorKind::InvalidInput, + "memory spool position overflow", + ) + })?; + let end = pos.checked_add(bytes.len()).ok_or_else(|| { + io::Error::new(io::ErrorKind::InvalidInput, "memory spool length overflow") + })?; + self.grow(end)?; + let mut copied = 0; + while copied < bytes.len() { + let offset = pos + copied; + let within = offset % BLOCK_BYTES; + let count = (BLOCK_BYTES - within).min(bytes.len() - copied); + self.blocks[offset / BLOCK_BYTES].as_mut().unwrap()[within..within + count] + .copy_from_slice(&bytes[copied..copied + count]); + copied += count; + } + self.pos = end as u64; + self.len = self.len.max(end); + Ok(bytes.len()) + } + + fn read(&mut self, bytes: &mut [u8]) -> io::Result { + if self.pos >= self.len as u64 { + return Ok(0); + } + let pos = self.pos as usize; + let size = bytes.len().min(self.len - pos); + let mut copied = 0; + while copied < size { + let offset = pos + copied; + let within = offset % BLOCK_BYTES; + let count = (BLOCK_BYTES - within).min(size - copied); + bytes[copied..copied + count].copy_from_slice( + &self.blocks[offset / BLOCK_BYTES].as_ref().unwrap()[within..within + count], + ); + copied += count; + } + self.pos += size as u64; + Ok(size) + } + + fn seek(&mut self, from: SeekFrom) -> io::Result { + let pos = match from { + SeekFrom::Start(pos) => Some(pos), + SeekFrom::End(offset) => (self.len as u64).checked_add_signed(offset), + SeekFrom::Current(offset) => self.pos.checked_add_signed(offset), + } + .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "invalid memory spool seek"))?; + self.pos = pos; + Ok(pos) + } +} + +impl Write for MemorySpool { + fn write(&mut self, bytes: &[u8]) -> io::Result { + match &mut self.store { + Store::Unbounded(cursor) => cursor.write(bytes), + Store::Bounded(spool) => spool.write(bytes), + } + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} +impl Read for MemorySpool { + fn read(&mut self, bytes: &mut [u8]) -> io::Result { + match &mut self.store { + Store::Unbounded(cursor) => cursor.read(bytes), + Store::Bounded(spool) => spool.read(bytes), + } + } +} +impl Seek for MemorySpool { + fn seek(&mut self, from: SeekFrom) -> io::Result { + match &mut self.store { + Store::Unbounded(cursor) => cursor.seek(from), + Store::Bounded(spool) => spool.seek(from), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{Error, ErrorKind}; + + #[test] + fn impossible_spool_growth_is_rejected_before_allocation() { + let resources = WriterResources::default().with_max_spool_memory_bytes(u64::MAX); + let mut spool = MemorySpool::new(&resources); + let Store::Bounded(bounded) = &mut spool.store else { + panic!("memory limit must select bounded storage"); + }; + let error = bounded.grow(usize::MAX).unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::InvalidInput); + assert_eq!(used(&resources), 0); + spool.flush().unwrap(); + } + + #[test] + fn impossible_write_extent_keeps_position_and_capacity() { + let resources = WriterResources::default().with_max_spool_memory_bytes(u64::MAX); + let mut spool = MemorySpool::new(&resources); + spool.seek(SeekFrom::Start(usize::MAX as u64)).unwrap(); + let error = spool.write(b"x").unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::InvalidInput); + assert_eq!(error.to_string(), "memory spool length overflow"); + assert_eq!(spool.stream_position().unwrap(), usize::MAX as u64); + assert_eq!(used(&resources), 0); + spool.seek(SeekFrom::Start(0)).unwrap(); + assert_eq!(spool.read(&mut [0]).unwrap(), 0); + spool.write_all(b"valid").unwrap(); + spool.seek(SeekFrom::Start(0)).unwrap(); + let mut payload = [0; 5]; + spool.read_exact(&mut payload).unwrap(); + assert_eq!(&payload, b"valid"); + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn position_wider_than_address_space_is_rejected_before_allocation() { + let resources = WriterResources::default().with_max_spool_memory_bytes(u64::MAX); + let mut spool = MemorySpool::new(&resources); + let position = u64::from(u32::MAX) + 1; + spool.seek(SeekFrom::Start(position)).unwrap(); + let error = spool.write(b"x").unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::InvalidInput); + assert_eq!(error.to_string(), "memory spool position overflow"); + assert_eq!(spool.stream_position().unwrap(), position); + assert_eq!(used(&resources), 0); + // Empty writes need no addressable extent. + assert_eq!(spool.write(&[]).unwrap(), 0); + assert_eq!(spool.stream_position().unwrap(), position); + } + + #[test] + fn admitted_spool_retains_its_capacity_after_worker_retirement() { + use crate::codec::workspace::{Allowance, Buffer, RESERVATION_BYTES}; + use crate::streaming::preparation::Bytes; + let ledger = Allowance::limited(20000); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + let prepared = Bytes::zeroed(32, &resources).unwrap(); + let mut reservation = ledger.reserve(capacity(2)).unwrap(); + let allowance = reservation.allowance(); + let worker = resources + .clone() + .with_execution_allowance(allowance.clone()); + reservation.start(); + let scratch = Buffer::filled(64, 0u8, &allowance).unwrap(); + let mut spool = MemorySpool::new(&worker); + spool.write_all(b"payload").unwrap(); + assert_eq!(ledger.used(), 32 + capacity(2) + RESERVATION_BYTES); + reservation.retire(); + assert_eq!(ledger.used(), 32 + 64 + capacity(1) + RESERVATION_BYTES); + drop(scratch); + drop(prepared); + assert_eq!(ledger.used(), capacity(1) + RESERVATION_BYTES); + spool.seek(SeekFrom::Start(BLOCK_BYTES as u64)).unwrap(); + let error = spool.write_all(b"growth after retirement").unwrap_err(); + assert_eq!( + error.downcast::().unwrap().kind(), + ErrorKind::ResourceLimit + ); + assert_eq!(ledger.used(), capacity(1) + RESERVATION_BYTES); + spool.seek(SeekFrom::Start(0)).unwrap(); + let mut bytes = [0; 7]; + spool.read_exact(&mut bytes).unwrap(); + assert_eq!(&bytes, b"payload"); + drop(spool); + assert_eq!(ledger.used(), RESERVATION_BYTES); + drop((worker, allowance)); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn copying_retired_worker_output_counts_source_and_spool_together() { + use crate::codec::workspace::{Allowance, Buffer, RESERVATION_BYTES}; + let payload = 32; + let ledger = Allowance::limited(capacity(1) + payload + RESERVATION_BYTES); + let resources = WriterResources::default().with_execution_allowance(ledger.clone()); + let mut reservation = ledger.reserve(payload).unwrap(); + reservation.start(); + let bytes = Buffer::filled(payload as usize, 7u8, &reservation.allowance()).unwrap(); + reservation.retire(); + let mut spool = MemorySpool::new(&resources); + spool.write_all(&bytes).unwrap(); + assert_eq!(ledger.used(), capacity(1) + payload + RESERVATION_BYTES); + // A second destination must not borrow the still-live source charge. + assert!(MemorySpool::new(&resources).write_all(&bytes).is_err()); + drop(bytes); + assert_eq!(ledger.used(), capacity(1)); + spool.seek(SeekFrom::Start(0)).unwrap(); + let mut actual = [0; 32]; + spool.read_exact(&mut actual).unwrap(); + assert_eq!(actual, [7; 32]); + drop(spool); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn class_quota_refusal_rolls_back_execution_spool_growth() { + use crate::codec::workspace::Allowance; + let ledger = Allowance::limited(20000); + let resources = WriterResources::default() + .with_max_spool_memory_bytes(capacity(1)) + .with_execution_allowance(ledger.clone()); + let mut spool = MemorySpool::new(&resources); + spool.write_all(b"payload").unwrap(); + spool.seek(SeekFrom::Start(BLOCK_BYTES as u64)).unwrap(); + assert!(spool.write_all(b"overflow").is_err()); + assert_eq!(ledger.used(), capacity(1)); + drop(spool); + assert_eq!(ledger.used(), 0); + MemorySpool::new(&resources).write_all(b"retry").unwrap(); + assert_eq!(ledger.used(), 0); + } + + fn capacity(blocks: usize) -> u64 { + (blocks * BLOCK_BYTES + blocks.next_power_of_two() * INDEX_ENTRY_BYTES) as u64 + } + + fn used(resources: &WriterResources) -> u64 { + *resources + .spool_memory_budget + .as_ref() + .unwrap() + .used + .lock() + .unwrap() + } + + #[test] + fn quota_admits_payload_capacity_before_allocating_any_blocks() { + for limit in [0, BLOCK_BYTES as u64, capacity(1) - 1] { + let resources = WriterResources::default().with_max_spool_memory_bytes(limit); + let mut spool = MemorySpool::new(&resources); + let error = Error::from(spool.write(b"x").unwrap_err()); + assert_eq!( + error, + Error::WriterSpoolMemoryLimitExceeded { + limit, + required: capacity(1), + used: 0, + } + ); + assert_eq!(error.kind(), ErrorKind::ResourceLimit); + assert_eq!(used(&resources), 0); + let Store::Bounded(bounded) = &spool.store else { + panic!("bounded storage required") + }; + assert!(bounded.blocks.is_empty()); + assert_eq!(bounded.len, 0); + assert_eq!(bounded.pos, 0); + } + } + + #[test] + fn spare_payload_capacity_is_shared_and_stays_charged_until_drop() { + let resources = WriterResources::default().with_max_spool_memory_bytes(capacity(1)); + let mut first = MemorySpool::new(&resources); + first.write_all(b"x").unwrap(); + assert_eq!(used(&resources), capacity(1)); + let mut second = MemorySpool::new(&resources.clone()); + assert!(second.write(b"y").is_err()); + first.rewind().unwrap(); + first.write_all(b"replacement").unwrap(); + assert_eq!(used(&resources), capacity(1)); + first.seek(SeekFrom::Start(BLOCK_BYTES as u64 - 1)).unwrap(); + assert!(first.write_all(b"ab").is_err()); + assert_eq!(used(&resources), capacity(1)); + let mut bytes = Vec::new(); + first.rewind().unwrap(); + first.read_to_end(&mut bytes).unwrap(); + assert_eq!(bytes, b"replacement"); + drop(first); + second.write_all(b"y").unwrap(); + assert_eq!(used(&resources), capacity(1)); + drop(second); + assert_eq!(used(&resources), 0); + } + + #[test] + fn index_replacement_requires_both_indexes_before_growth() { + let peak = capacity(2) + INDEX_ENTRY_BYTES as u64; + for limit in [peak - 1, peak] { + let resources = WriterResources::default().with_max_spool_memory_bytes(limit); + let mut spool = MemorySpool::new(&resources); + spool.write_all(b"original").unwrap(); + spool.seek(SeekFrom::Start(BLOCK_BYTES as u64)).unwrap(); + let result = spool.write(b"next"); + if limit < peak { + assert_eq!( + Error::from(result.unwrap_err()), + Error::WriterSpoolMemoryLimitExceeded { + limit, + required: peak, + used: capacity(1), + } + ); + assert_eq!(used(&resources), capacity(1)); + assert_eq!(spool.stream_position().unwrap(), BLOCK_BYTES as u64); + assert_eq!(spool.seek(SeekFrom::End(0)).unwrap(), 8); + } else { + assert_eq!(result.unwrap(), 4); + // The replaced index is no longer charged after growth. + assert_eq!(used(&resources), capacity(2)); + } + spool.rewind().unwrap(); + let mut original = [0; 8]; + spool.read_exact(&mut original).unwrap(); + assert_eq!(&original, b"original"); + drop(spool); + assert_eq!(used(&resources), 0); + } + } + + #[test] + fn unused_index_slots_remain_charged_and_reused() { + let resources = WriterResources::default().with_max_spool_memory_bytes(capacity(4)); + let mut spool = MemorySpool::new(&resources); + // Three payload blocks allocate four index slots. + spool.write_all(&vec![7; BLOCK_BYTES * 3]).unwrap(); + assert_eq!(used(&resources), capacity(3)); + spool.write_all(b"fourth").unwrap(); + assert_eq!(used(&resources), capacity(4)); + // A second spool cannot use the retained capacity. + assert!(MemorySpool::new(&resources).write(b"x").is_err()); + assert_eq!(used(&resources), capacity(4)); + drop(spool); + assert_eq!(used(&resources), 0); + } + + #[test] + fn block_boundaries_overwrites_and_holes_match_cursor_contents() { + let resources = + WriterResources::default().with_max_spool_memory_bytes((BLOCK_BYTES * 8) as u64); + let mut actual = MemorySpool::new(&resources); + let mut expected = Cursor::new(Vec::new()); + for (position, data) in [ + (0, b"start".as_slice()), + (BLOCK_BYTES as u64 - 3, b"cross a block boundary".as_slice()), + ( + (BLOCK_BYTES * 3) as u64 + 1, + b"after a zero-filled hole".as_slice(), + ), + (2, b"overwrite".as_slice()), + ] { + actual.seek(SeekFrom::Start(position)).unwrap(); + expected.seek(SeekFrom::Start(position)).unwrap(); + actual.write_all(data).unwrap(); + expected.write_all(data).unwrap(); + } + assert_eq!(used(&resources), capacity(4)); + assert_eq!( + actual.seek(SeekFrom::End(-5)).unwrap(), + expected.seek(SeekFrom::End(-5)).unwrap() + ); + actual.write_all(b"tail!").unwrap(); + expected.write_all(b"tail!").unwrap(); + actual.rewind().unwrap(); + let mut bytes = Vec::new(); + let mut buffer = [0; 73]; + loop { + let count = actual.read(&mut buffer).unwrap(); + if count == 0 { + break; + } + bytes.extend_from_slice(&buffer[..count]); + } + assert_eq!(bytes, expected.into_inner()); + } + + #[test] + fn seek_and_empty_io_do_not_allocate_or_change_length() { + let resources = WriterResources::default().with_max_spool_memory_bytes(0); + let mut spool = MemorySpool::new(&resources); + spool.seek(SeekFrom::Start(u64::MAX)).unwrap(); + assert_eq!(spool.write(b"").unwrap(), 0); + assert_eq!(spool.read(&mut [0; 1]).unwrap(), 0); + assert!(spool.write(b"x").is_err()); + assert_eq!(used(&resources), 0); + assert!(spool.seek(SeekFrom::Current(1)).is_err()); + assert_eq!(spool.stream_position().unwrap(), u64::MAX); + assert!(spool.seek(SeekFrom::End(-1)).is_err()); + assert_eq!(spool.seek(SeekFrom::End(0)).unwrap(), 0); + } + + #[test] + fn unwinding_releases_payload_blocks_and_their_charge() { + let resources = WriterResources::default().with_max_spool_memory_bytes(capacity(1)); + let failure = std::panic::catch_unwind(|| { + let mut spool = MemorySpool::new(&resources); + spool.write_all(b"payload").unwrap(); + panic!("injected failure"); + }); + assert!(failure.is_err()); + assert_eq!(used(&resources), 0); + MemorySpool::new(&resources) + .write_all(b"replacement") + .unwrap(); + assert_eq!(used(&resources), 0); + } + + #[test] + fn default_storage_remains_the_unbounded_cursor() { + let resources = WriterResources::default(); + let mut spool = MemorySpool::new(&resources); + assert!(matches!(spool.store, Store::Unbounded(_))); + spool.write_all(b"payload").unwrap(); + spool.rewind().unwrap(); + let mut bytes = Vec::new(); + spool.read_to_end(&mut bytes).unwrap(); + assert_eq!(bytes, b"payload"); + } +} diff --git a/arca-rar/vendor/rars/src/streaming/output.rs b/arca-rar/vendor/rars/src/streaming/output.rs new file mode 100644 index 00000000..4468acfc --- /dev/null +++ b/arca-rar/vendor/rars/src/streaming/output.rs @@ -0,0 +1,253 @@ +//! Final collectors retain capacity until transfer, including adapter copies. +use super::{ + preparation::{Bytes, Records}, + CapacityCharge, WriterResources, +}; +use crate::{Error, Result}; +use std::{ + io::{self, Write}, + sync::{Arc, Mutex}, +}; + +/// Encoded bytes whose managed capacity remains charged until dropped or handed +/// to the caller with `into_vec`. Bindings use `copy_with` for a counted copy. +#[derive(Debug)] +pub struct WriterOutput { + bytes: Bytes, + resources: WriterResources, +} +impl WriterOutput { + pub(crate) fn new(resources: &WriterResources) -> Self { + Self { + bytes: Bytes::output(resources), + resources: resources.clone(), + } + } + pub fn as_bytes(&self) -> &[u8] { + &self.bytes + } + pub fn into_vec(mut self) -> Vec { + self.bytes.take_vec() + } + /// Reserve the destination payload while this source remains live. The + /// callback must make one copy of the bytes; its result belongs to the caller. + pub fn copy_with(&self, copy: impl FnOnce(&[u8]) -> T) -> Result { + let mut charge = self.resources.execution_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(self.bytes.len() as u64)?; + } + Ok(copy(&self.bytes)) + } +} +impl Write for WriterOutput { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.bytes + .extend_from_slice(bytes) + .map_err(io::Error::other)?; + Ok(bytes.len()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +/// A collected volume set retaining its aggregate charge through adapter copies. +pub struct WriterVolumes { + outputs: Records, + resources: WriterResources, +} +impl WriterVolumes { + pub fn volumes(&self) -> &[WriterOutput] { + &self.outputs + } + pub fn into_vec(mut self) -> Result>> { + let mut charge = self.resources.execution_charge(); + let bytes = self + .outputs + .len() + .checked_mul(std::mem::size_of::>()) + .ok_or(Error::InvalidArgument("volume output capacity overflows"))?; + if let Some(charge) = &mut charge { + charge.grow_to(bytes as u64)?; + } + let mut out = Vec::with_capacity(self.outputs.len()); + // Keep all source charges in the old array until the handoff, although + // the buffers have moved to the destination array without copying. + for output in self.outputs.iter_mut() { + out.push(output.bytes.take_vec()); + } + Ok(out) + } + /// Count all destination payloads while the full source set stays retained. + pub fn copy_with(&self, copy: impl FnOnce(&[WriterOutput]) -> T) -> Result { + let bytes = self + .outputs + .iter() + .try_fold(0u64, |total, out| total.checked_add(out.bytes.len() as u64)) + .ok_or(Error::InvalidArgument("volume copy capacity overflows"))?; + let mut charge = self.resources.execution_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(bytes)?; + } + Ok(copy(&self.outputs)) + } +} + +struct Shared { + outputs: Mutex>, + _charge: Option, +} +pub(crate) struct VolumeCollector { + shared: Arc, + resources: WriterResources, +} +struct VolumeOutput { + shared: Arc, + index: usize, + _charge: Option, +} +impl VolumeCollector { + pub(crate) fn new(resources: &WriterResources) -> Result { + let mut charge = resources.execution_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(std::mem::size_of::() as u64)?; + } + Ok(Self { + shared: Arc::new(Shared { + outputs: Mutex::new(Records::with_charge(0, resources.execution_charge())?), + _charge: charge, + }), + resources: resources.clone(), + }) + } + pub(crate) fn finish(self) -> Result { + let shared = Arc::try_unwrap(self.shared) + .map_err(|_| Error::WriterFailure("volume output still open"))?; + Ok(WriterVolumes { + outputs: shared.outputs.into_inner().unwrap(), + resources: self.resources, + }) + } +} +impl crate::rar50::VolumeSink for VolumeCollector { + fn start_volume(&mut self, index: u64) -> Result> { + let index = + usize::try_from(index).map_err(|_| Error::InvalidArgument("volume index overflows"))?; + let mut outputs = self.shared.outputs.lock().unwrap(); + if index != outputs.len() { + return Err(Error::WriterFailure("nonsequential volume output")); + } + let mut charge = self.resources.execution_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(std::mem::size_of::() as u64)?; + } + outputs.push_growing(WriterOutput::new(&self.resources))?; + Ok(Box::new(VolumeOutput { + shared: self.shared.clone(), + index, + _charge: charge, + })) + } +} +impl Write for VolumeOutput { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.shared.outputs.lock().unwrap()[self.index].write(bytes) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::rar50::VolumeSink; + + #[test] + fn refused_adapter_copy_keeps_source_charged_and_never_calls_adapter() { + let resources = WriterResources::default().with_max_memory_bytes(4096); + let mut output = WriterOutput::new(&resources); + output.write_all(&[42; 4096]).unwrap(); + assert_eq!(resources.managed_memory_in_use(), 4096); + let error = output + .copy_with(|_| panic!("copy must be refused before allocation")) + .unwrap_err(); + assert_eq!(error.kind(), crate::ErrorKind::ResourceLimit); + assert_eq!(output.as_bytes(), &[42; 4096]); + assert_eq!(resources.managed_memory_in_use(), 4096); + drop(output); + assert_eq!(resources.managed_memory_in_use(), 0); + } + + #[test] + fn adapter_copy_charges_source_and_destination_until_handoff() { + let resources = WriterResources::default().with_max_memory_bytes(8192); + let mut output = WriterOutput::new(&resources); + output.write_all(&[42; 4096]).unwrap(); + let copied = output + .copy_with(|bytes| { + assert_eq!(resources.managed_memory_in_use(), 8192); + bytes.to_vec() + }) + .unwrap(); + assert_eq!(resources.managed_memory_in_use(), 4096); + assert_eq!(output.into_vec(), copied); + assert_eq!(resources.managed_memory_in_use(), 0); + } + + #[test] + fn unbounded_output_copy_and_flush_preserve_bytes() { + let mut output = WriterOutput::new(&WriterResources::default()); + output.write_all(b"payload").unwrap(); + output.flush().unwrap(); + assert_eq!( + output.copy_with(|bytes| bytes.to_vec()).unwrap(), + b"payload" + ); + assert_eq!(output.into_vec(), b"payload"); + } + + #[test] + fn volume_collector_requires_sequential_closed_outputs() { + let resources = WriterResources::default(); + let mut collector = VolumeCollector::new(&resources).unwrap(); + assert!(matches!( + collector.start_volume(1), + Err(Error::WriterFailure("nonsequential volume output")) + )); + let mut output = collector.start_volume(0).unwrap(); + output.write_all(b"first").unwrap(); + output.flush().unwrap(); + assert!(matches!( + collector.start_volume(0), + Err(Error::WriterFailure("nonsequential volume output")) + )); + assert!(matches!( + collector.finish(), + Err(Error::WriterFailure("volume output still open")) + )); + drop(output); + + let mut collector = VolumeCollector::new(&resources).unwrap(); + let mut first = collector.start_volume(0).unwrap(); + first.write_all(b"first").unwrap(); + drop(first); + let mut second = collector.start_volume(1).unwrap(); + second.write_all(b"second").unwrap(); + drop(second); + let volumes = collector.finish().unwrap(); + assert_eq!( + volumes + .copy_with(|parts| parts + .iter() + .map(|part| part.as_bytes().to_vec()) + .collect::>()) + .unwrap(), + [b"first".to_vec(), b"second".to_vec()] + ); + assert_eq!( + volumes.into_vec().unwrap(), + [b"first".to_vec(), b"second".to_vec()] + ); + } +} diff --git a/arca-rar/vendor/rars/src/streaming/preparation.rs b/arca-rar/vendor/rars/src/streaming/preparation.rs new file mode 100644 index 00000000..6c74aad8 --- /dev/null +++ b/arca-rar/vendor/rars/src/streaming/preparation.rs @@ -0,0 +1,503 @@ +//! Ownership of preparation capacity, including temporary replacement peaks. +use super::{CapacityCharge, WriterResources}; +use crate::{Error, Result}; + +#[derive(Debug)] +pub(crate) struct Bytes { + bytes: Vec, + len: usize, + charge: Option, +} +impl Bytes { + pub(crate) fn new(resources: &WriterResources) -> Self { + Self { + bytes: Vec::new(), + len: 0, + charge: resources.preparation_charge(), + } + } + pub(crate) fn output(resources: &WriterResources) -> Self { + Self { + bytes: Vec::new(), + len: 0, + charge: resources.execution_charge(), + } + } + pub(crate) fn take_vec(&mut self) -> Vec { + self.bytes.truncate(self.len); + self.len = 0; + std::mem::take(&mut self.bytes) + } + pub(crate) fn zeroed(len: usize, resources: &WriterResources) -> Result { + let mut out = Self::new(resources); + out.grow(len)?; + out.len = len; + Ok(out) + } + fn grow(&mut self, capacity: usize) -> Result<()> { + if capacity <= self.bytes.len() { + return Ok(()); + } + if capacity > isize::MAX as usize { + return Err(Error::InvalidArgument("preparation capacity overflows")); + } + let peak = self + .bytes + .len() + .checked_add(capacity) + .ok_or(Error::InvalidArgument("preparation capacity overflows"))?; + if let Some(charge) = &mut self.charge { + charge.grow_to(peak as u64)?; + } + let mut replacement = vec![0; capacity]; + replacement[..self.len].copy_from_slice(&self.bytes[..self.len]); + self.bytes = replacement; + if let Some(charge) = &mut self.charge { + charge.shrink_to(capacity as u64); + } + Ok(()) + } + pub(crate) fn extend_from_slice(&mut self, bytes: &[u8]) -> Result<()> { + if self.charge.is_none() { + self.bytes.truncate(self.len); + self.bytes.extend_from_slice(bytes); + self.len = self.bytes.len(); + return Ok(()); + } + let end = self + .len + .checked_add(bytes.len()) + .ok_or(Error::InvalidArgument("preparation length overflows"))?; + if end > self.bytes.len() { + let capacity = end + .checked_next_power_of_two() + .ok_or(Error::InvalidArgument("preparation capacity overflows"))?; + self.grow(capacity)?; + } + self.bytes[self.len..end].copy_from_slice(bytes); + self.len = end; + Ok(()) + } + pub(crate) fn vint(&mut self, mut value: u64) -> Result<()> { + let mut bytes = [0; 10]; + let mut len = 0; + loop { + bytes[len] = (value as u8 & 0x7f) | if value >= 128 { 128 } else { 0 }; + len += 1; + value >>= 7; + if value == 0 { + break; + } + } + self.extend_from_slice(&bytes[..len]) + } + #[cfg(test)] + pub(crate) fn as_slice(&self) -> &[u8] { + self + } + #[cfg(test)] + pub(crate) fn capacity(&self) -> usize { + self.bytes.capacity() + } +} +impl std::ops::Deref for Bytes { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.bytes[..self.len] + } +} +impl std::ops::DerefMut for Bytes { + fn deref_mut(&mut self) -> &mut [u8] { + &mut self.bytes[..self.len] + } +} + +/// Fixed-capacity descriptor array, admitted before allocating. Consuming its +/// elements keeps the backing allocation charged until the iterator is dropped. +#[derive(Debug)] +pub(crate) struct Records { + values: Vec, + limit: usize, + charge: Option, +} +#[cfg(test)] +impl Clone for Records { + fn clone(&self) -> Self { + assert!( + self.charge.is_none(), + "charged owners require fallible copying" + ); + self.values.clone().into() + } +} +#[cfg(test)] +impl From> for Records { + fn from(values: Vec) -> Self { + Self { + limit: values.capacity(), + values, + charge: None, + } + } +} +impl Records { + pub(crate) fn new(limit: usize, resources: &WriterResources) -> Result { + Self::with_charge(limit, resources.preparation_charge()) + } + pub(crate) fn with_charge(limit: usize, mut charge: Option) -> Result { + let bytes = limit + .checked_mul(std::mem::size_of::()) + .filter(|bytes| *bytes <= isize::MAX as usize) + .ok_or(Error::InvalidArgument( + "preparation records capacity overflows", + ))?; + if let Some(charge) = &mut charge { + charge.grow_to(bytes as u64)?; + } + // with_capacity requests exactly this layout. No subsequent growth is allowed. + Ok(Self { + values: Vec::with_capacity(limit), + limit, + charge, + }) + } + pub(crate) fn collect(values: I, resources: &WriterResources) -> Result + where + I: ExactSizeIterator>, + { + let mut out = Self::new(values.len(), resources)?; + for value in values { + out.push(value?)?; + } + Ok(out) + } + + /// Grow only on explicit request, reserving the old and replacement arrays + /// together before moving elements. Fixed-admission callers use `push`. + pub(crate) fn push_growing(&mut self, value: T) -> Result<()> { + if self.values.len() == self.limit { + let limit = self + .limit + .max(1) + .checked_mul(2) + .ok_or(Error::InvalidArgument( + "preparation records capacity overflows", + ))?; + let bytes = limit + .checked_mul(std::mem::size_of::()) + .filter(|bytes| *bytes <= isize::MAX as usize) + .ok_or(Error::InvalidArgument( + "preparation records capacity overflows", + ))?; + if let Some(charge) = &mut self.charge { + charge.grow_to((bytes as u64).checked_add(charge.bytes()).ok_or( + Error::InvalidArgument("preparation records capacity overflows"), + )?)?; + } + let mut replacement = Vec::with_capacity(limit); + replacement.append(&mut self.values); + self.values = replacement; + self.limit = limit; + if let Some(charge) = &mut self.charge { + charge.shrink_to(bytes as u64); + } + } + self.push(value) + } + + pub(crate) fn pop(&mut self) -> Option { + self.values.pop() + } + + pub(crate) fn push(&mut self, value: T) -> Result<()> { + if self.values.len() == self.limit { + return Err(Error::WriterFailure( + "preparation record count exceeded admission", + )); + } + self.values.push(value); + Ok(()) + } +} +impl std::ops::Deref for Records { + type Target = [T]; + fn deref(&self) -> &[T] { + &self.values + } +} +impl std::ops::DerefMut for Records { + fn deref_mut(&mut self) -> &mut [T] { + &mut self.values + } +} +pub(crate) struct RecordIter { + iter: std::vec::IntoIter, + _charge: Option, +} +impl Iterator for RecordIter { + type Item = T; + fn next(&mut self) -> Option { + self.iter.next() + } + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} +impl ExactSizeIterator for RecordIter {} + +impl IntoIterator for Records { + type Item = T; + type IntoIter = RecordIter; + fn into_iter(self) -> Self::IntoIter { + RecordIter { + iter: self.values.into_iter(), + _charge: self.charge, + } + } +} +impl<'a, T> IntoIterator for &'a Records { + type Item = &'a T; + type IntoIter = std::slice::Iter<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.values.iter() + } +} +impl<'a, T> IntoIterator for &'a mut Records { + type Item = &'a mut T; + type IntoIter = std::slice::IterMut<'a, T>; + fn into_iter(self) -> Self::IntoIter { + self.values.iter_mut() + } +} + +pub(crate) struct Owned { + value: Box, + _charge: Option, +} +impl Owned { + pub(crate) fn new(value: T, resources: &WriterResources) -> Result { + let mut charge = resources.preparation_charge(); + if let Some(charge) = &mut charge { + charge.grow_to(std::mem::size_of::() as u64)?; + } + Ok(Self { + value: Box::new(value), + _charge: charge, + }) + } + pub(crate) fn into_inner(self) -> T { + *self.value + } +} +impl std::ops::Deref for Owned { + type Target = T; + fn deref(&self) -> &T { + &self.value + } +} +impl std::ops::DerefMut for Owned { + fn deref_mut(&mut self) -> &mut T { + &mut self.value + } +} + +impl AsRef for Owned { + fn as_ref(&self) -> &T { + self + } +} +impl PartialEq for Bytes { + fn eq(&self, other: &Self) -> bool { + **self == **other + } +} +impl PartialEq> for Bytes { + fn eq(&self, other: &Vec) -> bool { + &**self == other.as_slice() + } +} +impl PartialEq for Vec { + fn eq(&self, other: &Bytes) -> bool { + self.as_slice() == &**other + } +} + +#[cfg(test)] +mod tests { + #[test] + fn preparation_vint_encodes_single_and_multiple_byte_boundaries() { + use super::*; + + let mut bytes = Bytes::new(&WriterResources::default()); + bytes.vint(127).unwrap(); + bytes.vint(128).unwrap(); + bytes.vint(u64::MAX).unwrap(); + let mut expected = vec![0x7f, 0x80, 0x01]; + expected.extend_from_slice(&[0xff; 9]); + expected.push(0x01); + assert_eq!(bytes.as_slice(), expected); + } + + #[test] + fn fixed_preparation_capacity_refuses_extra_records_and_impossible_growth() { + use super::*; + + let resources = WriterResources::default().with_max_preparation_bytes(64); + let mut bytes = Bytes::zeroed(4, &resources).unwrap(); + bytes.grow(4).unwrap(); + assert_eq!( + bytes.grow(isize::MAX as usize + 1).unwrap_err().kind(), + crate::ErrorKind::InvalidArgument + ); + assert_eq!(&*bytes, &[0; 4]); + assert_eq!(bytes, vec![0; 4]); + assert_eq!(vec![0; 4], bytes); + assert_eq!(bytes, Bytes::zeroed(4, &resources).unwrap()); + + let mut records = Records::new(1, &resources).unwrap(); + records.push(7u8).unwrap(); + assert!(matches!( + records.push(9), + Err(Error::WriterFailure( + "preparation record count exceeded admission" + )) + )); + assert_eq!(&*records, &[7]); + } + + #[test] + fn preparation_growth_satisfies_both_ledgers_or_leaves_both_unchanged() { + use crate::codec::workspace::Allowance; + let ledger = Allowance::limited(1024); + let resources = WriterResources::default() + .with_max_preparation_bytes(64) + .with_execution_allowance(ledger.clone()); + let mut bytes = Bytes::zeroed(32, &resources).unwrap(); + assert!(bytes.extend_from_slice(&[1; 40]).is_err()); + assert_eq!(&*bytes, &[0; 32]); + assert_eq!(ledger.used(), 32); + drop(bytes); + assert_eq!(ledger.used(), 0); + drop(Bytes::zeroed(64, &resources).unwrap()); + let small = Allowance::limited(16); + let constrained = resources.clone().with_execution_allowance(small.clone()); + assert!(Bytes::zeroed(32, &constrained).is_err()); + assert_eq!(small.used(), 0); + drop(Bytes::zeroed(64, &resources).unwrap()); + assert_eq!(ledger.used(), 0); + } + + #[test] + fn descriptor_growth_counts_replacement_peak_and_preserves_refused_input() { + let resources = WriterResources::default().with_max_preparation_bytes(23); + let mut records = Records::new(1, &resources).unwrap(); + records.push(7u64).unwrap(); + assert!(matches!( + records.push_growing(9), + Err(Error::WriterPreparationLimitExceeded { required: 24, .. }) + )); + assert_eq!(&*records, &[7]); + assert_eq!(used(&resources), 8); + drop(records); + assert_eq!(used(&resources), 0); + let resources = resources.with_max_preparation_bytes(24); + let mut records = Records::new(1, &resources).unwrap(); + records.push(7u64).unwrap(); + records.push_growing(9).unwrap(); + assert_eq!(&*records, &[7, 9]); + assert_eq!(used(&resources), 16); + drop(records); + assert_eq!(used(&resources), 0); + } + + use super::*; + fn used(resources: &WriterResources) -> u64 { + *resources + .preparation_budget + .as_ref() + .unwrap() + .used + .lock() + .unwrap() + } + + #[test] + fn byte_growth_admits_replacement_peak_and_preserves_refused_contents() { + let resources = WriterResources::default().with_max_preparation_bytes(11); + let mut bytes = Bytes::new(&resources); + bytes.extend_from_slice(b"abcd").unwrap(); + assert_eq!(used(&resources), 4); + assert_eq!( + bytes.extend_from_slice(b"e").unwrap_err(), + Error::WriterPreparationLimitExceeded { + limit: 11, + required: 12, + used: 4 + } + ); + assert_eq!(&*bytes, b"abcd"); + assert_eq!(used(&resources), 4); + drop(bytes); + assert_eq!(used(&resources), 0); + let resources = resources.with_max_preparation_bytes(12); + let mut bytes = Bytes::new(&resources); + bytes.extend_from_slice(b"abcd").unwrap(); + bytes.extend_from_slice(b"e").unwrap(); + assert_eq!(bytes.capacity(), 8); + assert_eq!(used(&resources), 8); + let mut other = Bytes::new(&resources.clone()); + assert!(other.extend_from_slice(b"12345").is_err()); + drop(bytes); + other.extend_from_slice(b"12345").unwrap(); + drop(other); + assert_eq!(used(&resources), 0); + } + + #[test] + fn records_and_boxed_state_keep_their_allocation_charged_until_freed() { + struct Probe(WriterResources); + impl Drop for Probe { + fn drop(&mut self) { + assert!(used(&self.0) > 0); + } + } + let resources = WriterResources::default().with_max_preparation_bytes(4096); + let mut records = Records::new(2, &resources).unwrap(); + records.push(Probe(resources.clone())).unwrap(); + records.push(Probe(resources.clone())).unwrap(); + let bytes = 2 * std::mem::size_of::() as u64; + assert_eq!(used(&resources), bytes); + let mut iter = records.into_iter(); + drop(iter.next()); + assert_eq!(used(&resources), bytes); + drop(iter); + assert_eq!(used(&resources), 0); + let failure = std::panic::catch_unwind(|| { + let _owned = Owned::new(Probe(resources.clone()), &resources).unwrap(); + let _bytes = Bytes::zeroed(100, &resources).unwrap(); + panic!("injected failure"); + }); + assert!(failure.is_err()); + assert_eq!(used(&resources), 0); + } + + #[test] + fn concurrent_preparation_shares_one_admission_boundary() { + let resources = WriterResources::default().with_max_preparation_bytes(128); + std::thread::scope(|scope| { + let hold = Bytes::zeroed(128, &resources).unwrap(); + scope + .spawn(|| assert!(Bytes::zeroed(1, &resources.clone()).is_err())) + .join() + .unwrap(); + drop(hold); + scope + .spawn(|| { + Bytes::zeroed(128, &resources.clone()).unwrap(); + }) + .join() + .unwrap(); + }); + assert_eq!(used(&resources), 0); + } +} diff --git a/arca-rar/vendor/rars/src/temp_file.rs b/arca-rar/vendor/rars/src/temp_file.rs new file mode 100644 index 00000000..2caa0b8f --- /dev/null +++ b/arca-rar/vendor/rars/src/temp_file.rs @@ -0,0 +1,181 @@ +//! Temporary creation shared by private spools and archive publication. + +use crate::atomic64::AtomicU64; +use crate::{Error, Result}; +use std::fs::File; +use std::io::{Read, Seek, SeekFrom, Write}; +use std::path::{Path, PathBuf}; +use std::sync::atomic::Ordering; + +static SEQUENCE: AtomicU64 = AtomicU64::new(0); + +#[derive(Clone, Copy, PartialEq, Eq)] +pub(crate) enum TemporaryKind { + Spool, + #[cfg(any(feature = "write", feature = "recovery"))] + Archive, +} + +pub(crate) fn next_sequence() -> u64 { + SEQUENCE.fetch_add(1, Ordering::Relaxed) +} + +pub(crate) fn create_with_sequence( + directory: &Path, + admit: impl FnMut(usize) -> Result, + next_sequence: impl FnMut() -> u64, +) -> Result<(PathBuf, File, C)> { + create_named_with_sequence(TemporaryKind::Spool, directory, admit, next_sequence) +} + +pub(crate) fn create_named_with_sequence( + kind: TemporaryKind, + directory: &Path, + mut admit: impl FnMut(usize) -> Result, + mut next_sequence: impl FnMut() -> u64, +) -> Result<(PathBuf, File, C)> { + let (prefix, overflow, collision) = match kind { + TemporaryKind::Spool => ( + ".rars-spool", + "spool path capacity overflows", + "could not allocate a unique rars spool file", + ), + #[cfg(any(feature = "write", feature = "recovery"))] + TemporaryKind::Archive => ( + ".rars-writing", + "temporary path capacity overflows", + "could not allocate a unique archive temporary file", + ), + }; + for _ in 0..128 { + let sequence = next_sequence(); + // Both prefixes, a process ID and u64 hex sequence fit this buffer. + let mut name = [0u8; 64]; + let mut name_writer = std::io::Cursor::new(&mut name[..]); + write!( + name_writer, + "{prefix}-{}-{sequence:016x}", + std::process::id() + ) + .expect("temporary name fits its fixed buffer"); + let name_len = name_writer.position() as usize; + let name = std::str::from_utf8(&name[..name_len]).expect("ASCII temporary name"); + let capacity = directory + .as_os_str() + .len() + .checked_add(1 + name_len) + .ok_or(Error::InvalidArgument(overflow))?; + let path_charge = admit(capacity)?; + let mut path = PathBuf::with_capacity(capacity); + path.push(directory); + path.push(name); + let mut options = File::options(); + options.write(true).create_new(true); + if kind == TemporaryKind::Spool { + options.read(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt; + // Temporary storage can hold plaintext before encryption or after + // decryption, so keep its creation mode private. + options.mode(0o600); + } + } + match options.open(&path) { + Ok(file) => { + return Ok((path, file, path_charge)); + } + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue, + Err(error) => return Err(error.into()), + } + } + Err(std::io::Error::new(std::io::ErrorKind::AlreadyExists, collision).into()) +} + +/// An uncharged file owner. The reader applies its own logical disk quota. +pub(crate) struct TemporaryFile { + path: PathBuf, + file: Option, +} + +impl TemporaryFile { + pub(crate) fn create(directory: &Path) -> Result { + let (path, file, ()) = create_with_sequence(directory, |_| Ok(()), next_sequence)?; + Ok(Self { + path, + file: Some(file), + }) + } +} + +impl Read for TemporaryFile { + fn read(&mut self, bytes: &mut [u8]) -> std::io::Result { + self.file + .as_mut() + .expect("temporary file is present") + .read(bytes) + } +} +impl Write for TemporaryFile { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.file + .as_mut() + .expect("temporary file is present") + .write(bytes) + } + fn flush(&mut self) -> std::io::Result<()> { + self.file + .as_mut() + .expect("temporary file is present") + .flush() + } +} +impl Seek for TemporaryFile { + fn seek(&mut self, from: SeekFrom) -> std::io::Result { + self.file + .as_mut() + .expect("temporary file is present") + .seek(from) + } +} +impl Drop for TemporaryFile { + fn drop(&mut self) { + self.file = None; + let _ = std::fs::remove_file(&self.path); + } +} + +#[cfg(all(test, unix, any(feature = "write", feature = "recovery")))] +mod tests { + use super::*; + use std::os::unix::fs::PermissionsExt; + + #[test] + fn creation_permissions_preserve_private_spools_and_default_archives() { + let root = crate::scratch::case("temporary-creation-permissions"); + let reference = File::create(root.join("reference")).unwrap(); + let default_mode = reference.metadata().unwrap().permissions().mode() & 0o777; + for kind in [TemporaryKind::Spool, TemporaryKind::Archive] { + let (_, mut file, ()) = + create_named_with_sequence(kind, &root, |_| Ok(()), || 0).unwrap(); + let mode = file.metadata().unwrap().permissions().mode() & 0o777; + if kind == TemporaryKind::Spool { + assert_eq!(mode & 0o077, 0, "plaintext spool must remain private"); + file.write_all(b"payload").unwrap(); + file.rewind().unwrap(); + let mut bytes = Vec::new(); + file.read_to_end(&mut bytes).unwrap(); + assert_eq!(bytes, b"payload"); + } else { + assert_eq!( + mode, default_mode, + "publication retains ordinary archive permissions" + ); + assert!( + file.read(&mut [0]).is_err(), + "publication file remains write-only" + ); + } + } + } +} diff --git a/arca-rar/vendor/rars/src/test_features.rs b/arca-rar/vendor/rars/src/test_features.rs new file mode 100644 index 00000000..edd86c13 --- /dev/null +++ b/arca-rar/vendor/rars/src/test_features.rs @@ -0,0 +1,283 @@ +//! Unit-test fixtures track independently selected Cargo capabilities. + +#[cfg(feature = "write")] +pub(crate) fn encryption_cases() -> impl Iterator { + std::iter::once(false).chain(cfg!(feature = "encryption").then_some(true)) +} + +#[test] +fn plain_readers_and_fixed_key_comments_remain_available() { + use crate::ArchiveReader; + let cases: &[(&[u8], &[&[u8]])] = &[ + ( + include_bytes!("../tests/fixtures/rar13/README.RAR"), + &[include_bytes!("../tests/fixtures/rar13/README")], + ), + ( + include_bytes!("../tests/fixtures/rar15_40/rar300/solid_simple_rar300.rar"), + &[ + b"shared prefix shared prefix shared prefix alpha\n", + b"shared prefix shared prefix shared prefix beta\n", + ], + ), + ( + include_bytes!("../tests/fixtures/rar50/stored.rar"), + &[b"Hello, RAR 5.0 fixture world.\n"], + ), + ]; + for &(data, expected) in cases { + let archive = ArchiveReader::read(data).unwrap(); + assert_eq!(archive.members().count(), expected.len()); + for (index, bytes) in expected.iter().enumerate() { + assert_eq!( + &archive + .read_member_at(index, None) + .unwrap() + .expect("indexed member"), + bytes + ); + } + } + let archive = + ArchiveReader::read(include_bytes!("../tests/fixtures/rar13/COMMENT.RAR")).unwrap(); + assert_eq!( + archive.comment(None).unwrap().unwrap(), + b"This is the archive comment.\r\n" + ); +} + +#[cfg(not(feature = "encryption"))] +#[test] +fn disabled_crypto_retains_metadata_and_typed_payload_and_header_refusals() { + use crate::{ArchiveReadOptions, ArchiveReader, Error}; + for data in [ + include_bytes!("../tests/fixtures/rar13/README_password=password.rar").as_slice(), + include_bytes!("../tests/fixtures/rar15_40/rar154/readme_154_password.rar").as_slice(), + include_bytes!("../tests/fixtures/rar15_40/encrypted/per_file_rar300_password.rar") + .as_slice(), + include_bytes!("../tests/fixtures/rar50/password_aes.rar").as_slice(), + ] { + for password in [None, Some(b"password".as_slice())] { + let archive = ArchiveReader::read_with_options( + data, + ArchiveReadOptions::with_optional_password(password), + ) + .unwrap(); + let index = archive.members().position(|m| m.meta.is_encrypted).unwrap(); + assert_eq!( + archive + .read_member_at(index, password) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "encryption" + } + ); + } + } + for data in [ + include_bytes!("../tests/fixtures/rar15_40/encrypted/header_rar300_password.rar") + .as_slice(), + include_bytes!("../tests/fixtures/rar50/header_encrypted.rar").as_slice(), + ] { + for password in [None, Some(b"password".as_slice())] { + assert_eq!( + ArchiveReader::read_with_options( + data, + ArchiveReadOptions::with_optional_password(password) + ) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "encryption" + } + ); + } + } + assert!(matches!( + crate::crypto::rar50::Rar50Keys::derive(b"password", [0; 16], 255), + Err(crate::crypto::rar50::Error::FeatureDisabled) + )); +} + +#[cfg(not(feature = "recovery"))] +#[test] +fn disabled_recovery_keeps_record_metadata_and_preserves_output() { + use crate::{ArchiveReadOptions, ArchiveReader, Error, ReadCancellation}; + let data = include_bytes!("../tests/fixtures/rar50/with_recovery.rar"); + let archive = ArchiveReader::read(data).unwrap(); + assert!(archive + .as_rar50() + .unwrap() + .services() + .any(|s| s.recovery_record().unwrap().is_some())); + let mut output = b"untouched".to_vec(); + assert_eq!( + archive + .repair_recovery_to(&mut output) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "recovery" + } + ); + assert_eq!(output, b"untouched"); + let token = ReadCancellation::new(); + token.cancel(); + assert_eq!( + archive + .repair_recovery_with_options(ArchiveReadOptions::new().with_cancellation(&token)) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "recovery" + } + ); +} + +#[cfg(all(feature = "write", not(feature = "encryption")))] +#[test] +fn disabled_encrypted_writers_refuse_before_source_access_or_output() { + use crate::{ArchiveVersion, Builder, EntrySource, Error, WriterResources}; + for version in ArchiveVersion::ALL { + let mut builder = Builder::new(version) + .store(true) + .password(Some(b"password".to_vec())); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(1, || panic!("crypto refusal must precede source access")), + None, + None, + ) + .unwrap(); + let mut output = b"untouched".to_vec(); + assert_eq!( + builder + .write_to(&mut output, &WriterResources::default(), None) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "encryption" + } + ); + assert_eq!(output, b"untouched"); + } +} + +#[cfg(all(feature = "write", not(feature = "recovery")))] +#[test] +fn disabled_recovery_writers_refuse_before_source_access_or_output() { + use crate::{ArchiveVersion, Builder, EntrySource, Error, WriterResources}; + let mut builder = Builder::new(ArchiveVersion::Rar50).recovery_percent(Some(1)); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(1, || panic!("recovery refusal must precede source access")), + None, + None, + ) + .unwrap(); + let mut output = b"untouched".to_vec(); + assert_eq!( + builder + .write_to(&mut output, &WriterResources::default(), None) + .unwrap_err() + .root_cause(), + &Error::FeatureDisabled { + feature: "recovery" + } + ); + assert_eq!(output, b"untouched"); +} + +#[test] +fn crypto_key_equality_and_debug_do_not_require_derivation() { + use crate::crypto::rar50::Rar50Keys; + let keys = Rar50Keys { + key: [1; 32], + hash_key: [2; 32], + password_check: [3; 8], + }; + assert_eq!(keys, keys.clone()); + for field in 0..3 { + let mut different = keys.clone(); + match field { + 0 => different.key[31] ^= 1, + 1 => different.hash_key[31] ^= 1, + _ => different.password_check[7] ^= 1, + } + assert_ne!(keys, different); + } + assert_eq!(format!("{keys:?}"), "Rar50Keys { .. }"); +} + +#[cfg(feature = "write")] +#[test] +fn small_explicit_delta_decodes_without_crypto_or_recovery() { + use crate::rar50::{ArchiveEntry, Rar50Writer, WriterOptions}; + use crate::{ + ArchiveReadOptions, ArchiveReader, ArchiveVersion, EntrySource, Error, FeatureSet, + FilterKind, FilterPolicy, FilterSpec, + }; + let data: Vec = (0..512).map(|i| (i / 4) as u8).collect(); + let bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1) + .with_dictionary_size(128 * 1024), + ) + .entry(ArchiveEntry::new( + b"small-delta".to_vec(), + EntrySource::from_bytes(data.clone()), + )) + .filter_policy(FilterPolicy::Explicit(FilterSpec::whole( + FilterKind::Delta { channels: 4 }, + ))) + .finish() + .unwrap(); + let archive = ArchiveReader::read(&bytes).unwrap(); + assert!(!archive + .as_rar50() + .unwrap() + .files() + .next() + .unwrap() + .is_stored()); + assert_eq!(archive.read_member_at(0, None).unwrap().unwrap(), data); + // An unfiltered compressed member succeeds on this route. This exact + // refusal proves the produced archive actually contains a filter command. + let error = archive + .test_with_options(ArchiveReadOptions::new().with_rar50_buffered_decode_limit(0)) + .unwrap_err(); + assert_eq!( + error.root_cause(), + &Error::Rar50BufferedDecodeLimitExceeded { + limit: 0, + required: 512 + } + ); + let plain_bytes = Rar50Writer::new( + WriterOptions::new(ArchiveVersion::Rar50, FeatureSet::store_only()) + .with_compression_level(1) + .with_dictionary_size(128 * 1024), + ) + .entry(ArchiveEntry::new( + b"small-plain".to_vec(), + EntrySource::from_bytes(data.clone()), + )) + .filter_policy(FilterPolicy::None) + .finish() + .unwrap(); + let plain = ArchiveReader::read(&plain_bytes).unwrap(); + assert!(!plain + .as_rar50() + .unwrap() + .files() + .next() + .unwrap() + .is_stored()); + plain + .test_with_options(ArchiveReadOptions::new().with_rar50_buffered_decode_limit(0)) + .unwrap(); + assert_eq!(plain.read_member_at(0, None).unwrap().unwrap(), data); +} diff --git a/arca-rar/vendor/rars/src/timestamp.rs b/arca-rar/vendor/rars/src/timestamp.rs new file mode 100644 index 00000000..85e464a6 --- /dev/null +++ b/arca-rar/vendor/rars/src/timestamp.rs @@ -0,0 +1,342 @@ +//! Timestamp conversions shared by archive consumers. +//! Legacy DOS values follow the established extracting-machine local-zone policy. + +use crate::tzif::TimeZone; +use crate::{ArchiveFamily, TimeRefinement}; +use std::fs; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +/// A stored timestamp with its interpretation attached, before refinements. +/// +/// This is a view of archive metadata, not necessarily a valid instant. +/// Presence is represented separately by `Option`: +/// `DosLocal(0)` is an invalid stored date, while `UnixSeconds(0)` is the Unix +/// epoch. Odd-second and subsecond refinements remain separate. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum StoredTimestamp { + /// Packed DOS date/time fields with no stored timezone and two-second + /// resolution. Obtaining an instant requires a timezone policy. + DosLocal(u32), + /// Absolute whole seconds since the Unix epoch. + UnixSeconds(u32), +} + +impl StoredTimestamp { + pub(crate) fn from_family(family: ArchiveFamily, raw: u32) -> Self { + match family { + ArchiveFamily::Rar13 | ArchiveFamily::Rar15To40 => Self::DosLocal(raw), + ArchiveFamily::Rar50Plus => Self::UnixSeconds(raw), + } + } + + /// Calendar fields `(year, month, day, hour, minute, second)` for display. + /// + /// DOS values expose the stored wall-clock fields without timezone + /// conversion; Unix values use UTC. Refinements are not applied. For + /// compatibility with Python date tuples, a zero DOS month or day returns + /// `None`; other field values are exposed without validation. + /// Use [`crate::ArchiveMemberMeta::modification_time`] to obtain an instant + /// under the existing local-zone and refinement policy instead. + pub fn calendar_fields(self) -> Option<(u16, u8, u8, u8, u8, u8)> { + match self { + Self::UnixSeconds(seconds) => Some(unix_datetime(seconds)), + Self::DosLocal(raw) => { + let year = 1980 + ((raw >> 25) & 0x7f) as u16; + let month = ((raw >> 21) & 0x0f) as u8; + let day = ((raw >> 16) & 0x1f) as u8; + let hour = ((raw >> 11) & 0x1f) as u8; + let minute = ((raw >> 5) & 0x3f) as u8; + let second = ((raw & 0x1f) * 2) as u8; + (month != 0 && day != 0).then_some((year, month, day, hour, minute, second)) + } + } + } +} + +pub fn current_filetime() -> u64 { + const FILETIME_UNIX_EPOCH_SECONDS: u64 = 11_644_473_600; + const FILETIME_TICKS_PER_SECOND: u64 = 10_000_000; + + let duration = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default(); + let seconds = duration + .as_secs() + .saturating_add(FILETIME_UNIX_EPOCH_SECONDS) + .saturating_mul(FILETIME_TICKS_PER_SECOND); + seconds.saturating_add(u64::from(duration.subsec_nanos() / 100)) +} + +pub fn format_filetime_utc(filetime: u64) -> String { + filetime_to_system_time(filetime) + .and_then(format_system_time_utc) + .unwrap_or_else(|| format!("{filetime:#018x}")) +} + +pub fn source_unix_mtime(metadata: &fs::Metadata) -> Option { + metadata + .modified() + .ok()? + .duration_since(UNIX_EPOCH) + .ok() + .and_then(|duration| u32::try_from(duration.as_secs()).ok()) +} + +/// UTC calendar fields for a RAR5 whole-second timestamp, including Unix epoch. +pub fn unix_datetime(seconds: u32) -> (u16, u8, u8, u8, u8, u8) { + let (year, month, day) = civil_from_days(i64::from(seconds / 86_400)); + let within_day = seconds % 86_400; + ( + year as u16, + month as u8, + day as u8, + (within_day / 3600) as u8, + ((within_day % 3600) / 60) as u8, + (within_day % 60) as u8, + ) +} + +pub fn source_dos_mtime(metadata: &fs::Metadata) -> u32 { + metadata + .modified() + .ok() + .and_then(system_time_to_dos_time) + .unwrap_or(0) +} + +/// Converts a present stored timestamp without treating Unix epoch as missing. +/// Legacy DOS zero remains invalid under the existing local-zone conversion. +pub fn extracted_system_time( + family: ArchiveFamily, + file_time: Option, + refinement: Option, +) -> Option { + let file_time = file_time?; + let base = match family { + ArchiveFamily::Rar13 | ArchiveFamily::Rar15To40 => dos_time_to_system_time(file_time), + ArchiveFamily::Rar50Plus => Some(UNIX_EPOCH + Duration::from_secs(u64::from(file_time))), + }?; + // A DOS timestamp counts in two-second steps, so an odd second and any + // sub-second detail arrive separately and have to be added back on. + let Some(refinement) = refinement else { + return Some(base); + }; + let extra = Duration::from_secs(u64::from(refinement.add_second)) + + Duration::from_nanos(u64::from(refinement.nanoseconds)); + base.checked_add(extra).or(Some(base)) +} + +/// A DOS timestamp is a wall-clock reading with no zone, so both directions go +/// through the local zone rather than UTC. See [`crate::tzif`] for why, and for +/// what that costs. +fn system_time_to_dos_time(time: SystemTime) -> Option { + let instant = i64::try_from(time.duration_since(UNIX_EPOCH).ok()?.as_secs()).ok()?; + let local = instant.checked_add(i64::from(TimeZone::local().offset_at(instant)))?; + let seconds = u64::try_from(local).ok()?; + let days = i64::try_from(seconds / 86_400).ok()?; + let seconds_of_day = seconds % 86_400; + let (year, month, day) = civil_from_days(days); + if !(1980..=2107).contains(&year) { + return None; + } + let hour = seconds_of_day / 3_600; + let minute = (seconds_of_day % 3_600) / 60; + let second = seconds_of_day % 60; + Some( + ((u32::try_from(year - 1980).ok()?) << 25) + | (month << 21) + | (day << 16) + | ((hour as u32) << 11) + | ((minute as u32) << 5) + | ((second as u32) / 2), + ) +} + +fn dos_time_to_system_time(time: u32) -> Option { + if time == 0 { + return None; + } + let second = (time & 0x1f) * 2; + let minute = (time >> 5) & 0x3f; + let hour = (time >> 11) & 0x1f; + let day = (time >> 16) & 0x1f; + let month = (time >> 21) & 0x0f; + let year = 1980 + i32::try_from((time >> 25) & 0x7f).ok()?; + // The five-bit day field cannot exceed 31. + if month == 0 || month > 12 || day == 0 || hour > 23 || minute > 59 || second > 59 { + return None; + } + let days = days_from_civil(year, month, day); + let local = days + .checked_mul(86_400)? + .checked_add(i64::from(hour) * 3_600 + i64::from(minute) * 60 + i64::from(second))?; + let zone = TimeZone::local(); + let instant = local.checked_sub(i64::from(zone.offset_for_local(local)))?; + Some(UNIX_EPOCH + Duration::from_secs(u64::try_from(instant).ok()?)) +} + +fn filetime_to_system_time(filetime: u64) -> Option { + const FILETIME_UNIX_EPOCH_SECONDS: u64 = 11_644_473_600; + const FILETIME_TICKS_PER_SECOND: u64 = 10_000_000; + + let seconds = filetime / FILETIME_TICKS_PER_SECOND; + let ticks = filetime % FILETIME_TICKS_PER_SECOND; + let unix_seconds = seconds.checked_sub(FILETIME_UNIX_EPOCH_SECONDS)?; + Some(UNIX_EPOCH + Duration::from_secs(unix_seconds) + Duration::from_nanos(ticks * 100)) +} + +fn format_system_time_utc(time: SystemTime) -> Option { + let duration = time.duration_since(UNIX_EPOCH).ok()?; + let days = i64::try_from(duration.as_secs() / 86_400).ok()?; + let seconds_of_day = duration.as_secs() % 86_400; + let (year, month, day) = civil_from_days(days); + let hour = seconds_of_day / 3_600; + let minute = (seconds_of_day % 3_600) / 60; + let second = seconds_of_day % 60; + Some(format!( + "{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}Z" + )) +} + +fn civil_from_days(days_since_unix_epoch: i64) -> (i32, u32, u32) { + // All callers derive days from nonnegative Unix durations. + let z = days_since_unix_epoch + 719_468; + let era = z / 146_097; + let doe = z - era * 146_097; + let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365; + let y = yoe + era * 400; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let day = doy - (153 * mp + 2) / 5 + 1; + let month = mp + if mp < 10 { 3 } else { -9 }; + let year = y + i64::from(month <= 2); + (year as i32, month as u32, day as u32) +} + +fn days_from_civil(year: i32, month: u32, day: u32) -> i64 { + // The sole production caller extracts DOS years in 1980..=2107. + let year = i64::from(year) - i64::from(month <= 2); + let era = year / 400; + let yoe = year - era * 400; + let month = i64::from(month); + let day = i64::from(day); + let doy = (153 * (month + if month > 2 { -3 } else { 9 }) + 2) / 5 + day - 1; + let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; + era * 146_097 + doe - 719_468 +} + +#[cfg(test)] +mod tests { + use super::StoredTimestamp; + + #[test] + fn calendar_conversions_match_every_day_in_the_dos_range() { + // Independent Gregorian reference: count days from the Unix epoch, + // using month lengths rather than the production March-based formula. + let mut days = 0; + for year in 1970..=2107 { + let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0); + let months = [ + 31, + if leap { 29 } else { 28 }, + 31, + 30, + 31, + 30, + 31, + 31, + 30, + 31, + 30, + 31, + ]; + for (index, length) in months.into_iter().enumerate() { + let month = index as u32 + 1; + for day in 1..=length { + assert_eq!(super::civil_from_days(days), (year, month, day)); + if year >= 1980 { + assert_eq!(super::days_from_civil(year, month, day), days); + } + days += 1; + } + } + } + assert_eq!(super::unix_datetime(u32::MAX), (2106, 2, 7, 6, 28, 15)); + } + + #[test] + fn source_dos_conversion_refuses_dates_outside_its_year_range() { + use std::time::{Duration, UNIX_EPOCH}; + assert!(super::system_time_to_dos_time(UNIX_EPOCH - Duration::from_secs(1)).is_none()); + // These dates remain outside the DOS range in every real timezone. + for seconds in [0, 4_386_528_000] { + // 1970-01-01 and 2109-01-02 UTC + assert!( + super::system_time_to_dos_time(UNIX_EPOCH + Duration::from_secs(seconds)).is_none() + ); + } + // Midyear is safely separated from a timezone-dependent year boundary. + for (seconds, year) in [(331_344_000, 1980), (4_339_852_800, 2107)] { + let packed = + super::system_time_to_dos_time(UNIX_EPOCH + Duration::from_secs(seconds)).unwrap(); + assert_eq!(1980 + (packed >> 25), year); + let decoded = super::dos_time_to_system_time(packed).unwrap(); + let original = UNIX_EPOCH + Duration::from_secs(seconds); + assert!(original.duration_since(decoded).unwrap() < Duration::from_secs(2)); + } + } + + #[test] + fn filetime_format_boundaries_keep_epoch_and_far_future_dates() { + let epoch = 116_444_736_000_000_000; + assert_eq!(super::format_filetime_utc(epoch - 1), "0x019db1ded53e7fff"); + assert_eq!(super::format_filetime_utc(epoch), "1970-01-01T00:00:00Z"); + assert_eq!( + super::format_filetime_utc(u64::MAX), + "60056-05-28T05:36:10Z" + ); + } + + #[test] + fn invalid_dos_fields_do_not_become_extracted_instants() { + // Packed DOS fields have independent ranges, with two-second units. + let year = 40u32 << 25; + let valid_date = year | (1 << 21) | (1 << 16); + for raw in [ + year | (1 << 16), // month zero + year | (13 << 21) | (1 << 16), + year | (1 << 21), // day zero + valid_date | (24 << 11), + valid_date | (60 << 5), + valid_date | 30, // second 60 + ] { + for family in [crate::ArchiveFamily::Rar13, crate::ArchiveFamily::Rar15To40] { + assert!(super::extracted_system_time(family, Some(raw), None).is_none()); + } + } + } + + #[test] + fn stored_calendar_fields_keep_wall_clock_separate_from_utc() { + assert_eq!(StoredTimestamp::DosLocal(0).calendar_fields(), None); + assert_eq!( + StoredTimestamp::UnixSeconds(0).calendar_fields(), + Some((1970, 1, 1, 0, 0, 0)) + ); + assert_eq!( + StoredTimestamp::DosLocal(0x5022_1882).calendar_fields(), + Some((2020, 1, 2, 3, 4, 4)) + ); + assert_eq!( + StoredTimestamp::UnixSeconds(1_582_934_400).calendar_fields(), + Some((2020, 2, 29, 0, 0, 0)) + ); + // The display accessor retains historically exposed raw DOS fields, + // rather than silently normalizing malformed dates into another date. + assert_eq!( + StoredTimestamp::DosLocal(u32::MAX).calendar_fields(), + Some((2107, 15, 31, 31, 63, 62)) + ); + } +} diff --git a/arca-rar/vendor/rars/src/tzif.rs b/arca-rar/vendor/rars/src/tzif.rs new file mode 100644 index 00000000..47355354 --- /dev/null +++ b/arca-rar/vendor/rars/src/tzif.rs @@ -0,0 +1,654 @@ +//! The local time zone, read from the system's TZif database. +//! +//! RAR 1.3 through 4.x store a modification time as MS-DOS fields: a wall-clock +//! reading with no zone and no offset. Every reader in the wild resolves that +//! against the *extracting* machine's local zone, so a file archived at 15:00 +//! shows 15:00 wherever it is unpacked. Reading those fields as UTC instead is +//! self-consistent and round-trips, which is how the mistake survives, but it +//! disagrees with every other tool by the local offset. +//! +//! Doing better needs the zone's offset *for the timestamp in question*, since +//! a summer archive extracted in winter still needs summer's rules. That means +//! the zone database. The C library would answer it in two calls, but both are +//! `unsafe`, and this workspace forbids that; a TZif file is a binary format, +//! and parsing those is what the rest of this project does anyway. +//! +//! Only what a timestamp conversion needs is read: transition instants, the +//! offset in force after each, and whether that offset is daylight saving. +//! Designations, leap seconds and the standard/wall indicators are skipped. +//! +//! The trailing POSIX rule string is skipped too, which is the one deliberate +//! gap. It governs dates after the final transition, and the tables run to +//! 2037. Before then the transitions answer everything, including for zones +//! that have none at all: a fixed-offset zone still records its offset in the +//! type table, so `Etc/GMT+5` resolves correctly with an empty transition list. +//! After 2037 a daylight-saving zone freezes at its final offset, which needs a +//! file stamped past 2038 *and* stored in a pre-RAR-5 archive to notice. + +use std::path::{Path, PathBuf}; +use std::sync::OnceLock; + +/// One local time type: an offset from UTC and whether it is daylight saving. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +struct LocalType { + offset: i32, + is_dst: bool, +} + +/// A time zone's transitions, enough to convert in both directions. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct TimeZone { + /// Transition instants in Unix seconds, ascending. + transitions: Vec, + /// The local type in force from the matching transition onward. + types: Vec, + /// Which entry of `types` each transition selects. + indices: Vec, +} + +impl TimeZone { + /// The zone where every offset is zero, used when nothing else resolves. + pub(crate) fn utc() -> Self { + Self { + transitions: Vec::new(), + types: vec![LocalType { + offset: 0, + is_dst: false, + }], + indices: Vec::new(), + } + } + + /// The machine's zone, parsed once and reused. + /// + /// Anything unreadable or unparsable falls back to UTC, which is what this + /// did before the database was consulted at all. A timestamp is not worth + /// failing an extraction over. + pub(crate) fn local() -> &'static Self { + static LOCAL: OnceLock = OnceLock::new(); + LOCAL.get_or_init(|| { + local_zone_path() + .and_then(|path| std::fs::read(path).ok()) + .and_then(|bytes| Self::parse(&bytes)) + .unwrap_or_else(Self::utc) + }) + } + + /// Reads a TZif file, preferring its 64-bit block when there is one. + pub(crate) fn parse(bytes: &[u8]) -> Option { + let header = Header::parse(bytes, 0)?; + // A version 2 or later file repeats everything in a second block with + // 64-bit transition times. That block is the authoritative one; the + // first exists only for readers that predate it. + if header.version >= b'2' { + let second = header.data_end(TimeWidth::Bits32)?; + let header = Header::parse(bytes, second)?; + Self::parse_block(bytes, &header, second + Header::LEN, TimeWidth::Bits64) + } else { + Self::parse_block(bytes, &header, Header::LEN, TimeWidth::Bits32) + } + } + + fn parse_block(bytes: &[u8], header: &Header, start: usize, width: TimeWidth) -> Option { + // Check every declared field, including skipped data, before reserving + // arrays from the header's counts. + bytes.get(start..start.checked_add(header.data_len(width)?)?)?; + let stride = width.bytes(); + let mut pos = start; + + let mut transitions = Vec::with_capacity(header.timecnt); + for _ in 0..header.timecnt { + let raw = bytes.get(pos..pos.checked_add(stride)?)?; + transitions.push(match width { + TimeWidth::Bits32 => i64::from(i32::from_be_bytes(raw.try_into().ok()?)), + TimeWidth::Bits64 => i64::from_be_bytes(raw.try_into().ok()?), + }); + pos += stride; + } + + let indices = bytes.get(pos..pos.checked_add(header.timecnt)?)?.to_vec(); + pos += header.timecnt; + + let mut types = Vec::with_capacity(header.typecnt); + for _ in 0..header.typecnt { + let record = bytes.get(pos..pos.checked_add(6)?)?; + types.push(LocalType { + offset: i32::from_be_bytes(record[..4].try_into().ok()?), + is_dst: record[4] != 0, + }); + pos += 6; + } + + if types.is_empty() || indices.iter().any(|&i| usize::from(i) >= types.len()) { + return None; + } + if transitions.windows(2).any(|pair| pair[0] >= pair[1]) { + return None; + } + Some(Self { + transitions, + types, + indices, + }) + } + + /// The offset in force at an instant. + fn type_at(&self, unix_seconds: i64) -> LocalType { + let after = self + .transitions + .partition_point(|&transition| transition <= unix_seconds); + match after.checked_sub(1) { + Some(index) => self.types[usize::from(self.indices[index])], + // RFC 8536 section 3.2 specifies type 0 before the first transition. + None => self.types[0], + } + } + + /// The offset in force at an instant, in seconds east of UTC. + pub(crate) fn offset_at(&self, unix_seconds: i64) -> i32 { + self.type_at(unix_seconds).offset + } + + /// The offset that turns a wall-clock reading back into an instant. + /// + /// A reading is not always one instant. In the hour a zone repeats when + /// daylight saving ends it names two, and in the hour it skips when + /// daylight saving starts it names none. An offset is accepted here when + /// applying it lands on an instant whose own offset is the same one, so + /// only genuinely reachable readings are accepted; where two qualify the + /// standard-time one wins, and where none do the search still returns the + /// standard-time candidate rather than failing. + /// + /// The reference readers disagree with each other in exactly these hours, + /// so there is nothing to match: RAR 7.12 resolves the repeated hour to + /// standard time under `Europe/London` and to daylight saving under + /// `America/New_York`. Everything outside those two hours a year is + /// unambiguous and agrees. + pub(crate) fn offset_for_local(&self, local_seconds: i64) -> i32 { + let mut best: Option = None; + for candidate in self.candidates(local_seconds) { + if self.type_at(local_seconds - i64::from(candidate.offset)) != candidate { + continue; + } + let better = match best { + None => true, + Some(current) => current.is_dst && !candidate.is_dst, + }; + if better { + best = Some(candidate); + } + } + best.or_else(|| { + // A reading in the skipped hour matches nothing. Resolve it with + // the standard-time offset, which moves it forward into the hour + // that does exist rather than backward into the one that does not. + self.candidates(local_seconds) + .into_iter() + .find(|local| !local.is_dst) + }) + .unwrap_or_else(|| self.type_at(local_seconds)) + .offset + } + + /// The types plausibly in force around a wall-clock reading. + /// + /// A day either side covers every real transition, which never move a + /// clock by anything close to that. + fn candidates(&self, local_seconds: i64) -> Vec { + const DAY: i64 = 86_400; + let mut found: Vec = Vec::new(); + for probe in [local_seconds - DAY, local_seconds, local_seconds + DAY] { + let local = self.type_at(probe); + if !found.contains(&local) { + found.push(local); + } + } + found + } +} + +/// Which file holds the machine's zone. +/// +/// `TZ` names a zone under the database directory; unset, the symlink at +/// `/etc/localtime` is the answer. A `TZ` holding a POSIX rule string rather +/// than a name has no file, and resolves to nothing here. +fn local_zone_path() -> Option { + zone_path( + std::env::var_os("TZ").as_deref(), + std::env::var_os("TZDIR").as_deref(), + ) +} + +fn zone_path( + name: Option<&std::ffi::OsStr>, + directory: Option<&std::ffi::OsStr>, +) -> Option { + const DEFAULT_DIR: &str = "/usr/share/zoneinfo"; + + let Some(name) = name else { + return Some(PathBuf::from("/etc/localtime")); + }; + let name = name.to_str()?; + // A leading colon is allowed and means the rest is a file name. + let name = name.strip_prefix(':').unwrap_or(name); + if name.is_empty() { + return None; + } + if Path::new(name).is_absolute() { + return Some(PathBuf::from(name)); + } + // TZ comes from the environment, so refuse anything that could walk out of + // the database directory. + if name + .split('/') + .any(|part| part.is_empty() || part == "." || part == "..") + { + return None; + } + let dir = directory.map_or_else(|| PathBuf::from(DEFAULT_DIR), PathBuf::from); + Some(dir.join(name)) +} + +#[derive(Clone, Copy)] +enum TimeWidth { + Bits32, + Bits64, +} + +impl TimeWidth { + fn bytes(self) -> usize { + match self { + Self::Bits32 => 4, + Self::Bits64 => 8, + } + } +} + +struct Header { + version: u8, + isutcnt: usize, + isstdcnt: usize, + leapcnt: usize, + timecnt: usize, + typecnt: usize, + charcnt: usize, +} + +impl Header { + const LEN: usize = 44; + + fn parse(bytes: &[u8], at: usize) -> Option { + let header = bytes.get(at..at.checked_add(Self::LEN)?)?; + if &header[..4] != b"TZif" { + return None; + } + let counts: Vec = header[20..44] + .as_chunks::<4>() + .0 + .iter() + .map(|chunk| u32::from_be_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]) as usize) + .collect(); + Some(Self { + version: header[4], + isutcnt: counts[0], + isstdcnt: counts[1], + leapcnt: counts[2], + timecnt: counts[3], + typecnt: counts[4], + charcnt: counts[5], + }) + } + + /// Where this block's data ends, which is where the next header begins. + fn data_end(&self, width: TimeWidth) -> Option { + Self::LEN.checked_add(self.data_len(width)?) + } + + fn data_len(&self, width: TimeWidth) -> Option { + self.timecnt + .checked_mul(width.bytes() + 1)? + .checked_add(self.typecnt.checked_mul(6)?)? + .checked_add(self.charcnt)? + .checked_add(self.leapcnt.checked_mul(width.bytes() + 4)?)? + .checked_add(self.isstdcnt)? + .checked_add(self.isutcnt) + } +} + +#[cfg(test)] +mod tests { + use super::{LocalType, TimeZone}; + + /// Zone files are shipped rather than read from the machine, so these test + /// the parser and not whatever the build box is set to. + const LONDON: &[u8] = include_bytes!("../tests/fixtures/tz/Europe_London"); + const NEW_YORK: &[u8] = include_bytes!("../tests/fixtures/tz/America_New_York"); + const KOLKATA: &[u8] = include_bytes!("../tests/fixtures/tz/Asia_Kolkata"); + const LORD_HOWE: &[u8] = include_bytes!("../tests/fixtures/tz/Australia_Lord_Howe"); + const GMT_MINUS_5: &[u8] = include_bytes!("../tests/fixtures/tz/Etc_GMT_5"); + + fn zone(name: &str) -> TimeZone { + let bytes = match name { + "Europe/London" => LONDON, + "America/New_York" => NEW_YORK, + "Asia/Kolkata" => KOLKATA, + "Australia/Lord_Howe" => LORD_HOWE, + "Etc/GMT+5" => GMT_MINUS_5, + other => panic!("no fixture for {other}"), + }; + TimeZone::parse(bytes).expect("fixture parses") + } + + /// Expected offsets come from Python's `zoneinfo`, so the arithmetic here + /// is checked against another implementation rather than against itself. + #[test] + fn offset_at_matches_the_zone_database() { + let cases = [ + ("Europe/London", 1_768_478_400, 0), // 2026-01-15 GMT + ("Europe/London", 1_784_116_800, 3_600), // 2026-07-15 BST + ("America/New_York", 1_768_478_400, -18_000), // EST + ("America/New_York", 1_784_116_800, -14_400), // EDT + ("Asia/Kolkata", 1_784_116_800, 19_800), // +05:30, no DST + ("Australia/Lord_Howe", 1_768_478_400, 39_600), // +11 in their summer + ("Australia/Lord_Howe", 1_784_116_800, 37_800), // +10:30, a 30-minute step + ("Etc/GMT+5", 1_784_116_800, -18_000), // no transitions at all + ("Europe/London", 486_475_200, 3_600), // 1985, well before the tables end + ("America/New_York", 946_681_200, -18_000), // 1999 + ]; + for (name, instant, expected) in cases { + assert_eq!( + zone(name).offset_at(instant), + expected, + "{name} at {instant}" + ); + } + } + + /// The reverse direction, on readings that name exactly one instant. + #[test] + fn offset_for_local_matches_the_zone_database() { + let cases = [ + ("Europe/London", 1_768_478_400, 0), // 12:00 GMT + ("Europe/London", 1_784_127_600, 3_600), // 15:00 BST + ("America/New_York", 1_784_109_600, -14_400), // 10:00 EDT + ("Asia/Kolkata", 1_784_143_800, 19_800), // 19:30 IST + ("Australia/Lord_Howe", 1_784_154_600, 37_800), // 22:30 +10:30 + ("Etc/GMT+5", 1_784_098_800, -18_000), // 07:00 -05 + ("Europe/London", 2_131_272_000, 3_600), // 2037, the last year the tables cover + ]; + for (name, reading, expected) in cases { + assert_eq!( + zone(name).offset_for_local(reading), + expected, + "{name} reading {reading}" + ); + } + } + + /// Both directions have to agree, or a timestamp written and read back on + /// one machine would drift. + #[test] + fn the_two_directions_round_trip() { + for name in [ + "Europe/London", + "America/New_York", + "Asia/Kolkata", + "Australia/Lord_Howe", + "Etc/GMT+5", + ] { + let zone = zone(name); + // Every six hours across 2026, skipping nothing. + let mut instant = 1_767_225_600; // 2026-01-01 + while instant < 1_798_761_600 { + let reading = instant + i64::from(zone.offset_at(instant)); + let back = reading - i64::from(zone.offset_for_local(reading)); + // The instant itself need not come back. In the hour a zone + // repeats, two instants share one reading and either is a + // correct answer. What must hold is that the answer still + // reads the same on the clock, which is the whole point of + // storing a reading. + let back_reading = back + i64::from(zone.offset_at(back)); + assert_eq!(back_reading, reading, "{name} at {instant}"); + instant += 21_600; + } + } + } + + /// The hour a zone repeats names two instants and the hour it skips names + /// none. Both resolve to standard time here, deterministically. + /// + /// The reference readers are not consistent in these hours, so there is + /// nothing to match: RAR 7.12 resolves London's repeated hour to standard + /// time and New York's to daylight saving. This pins our own choice. + #[test] + fn ambiguous_and_skipped_readings_resolve_to_standard_time() { + // 2026-10-25 01:30 in London happens twice, as BST then as GMT. + assert_eq!(zone("Europe/London").offset_for_local(1_792_891_800), 0); + // 2026-03-29 01:30 in London never happens; the clock jumps 01:00→02:00. + assert_eq!(zone("Europe/London").offset_for_local(1_774_747_800), 0); + // 2026-11-01 01:30 in New York happens twice, as EDT then as EST. + assert_eq!( + zone("America/New_York").offset_for_local(1_793_496_600), + -18_000 + ); + } + + #[test] + fn a_zone_with_no_transitions_still_has_its_offset() { + let zone = zone("Etc/GMT+5"); + assert!(zone.transitions.is_empty()); + assert_eq!(zone.offset_at(0), -18_000); + assert_eq!(zone.offset_at(i64::MAX / 2), -18_000); + } + + #[test] + fn utc_is_the_fallback_and_has_no_offset() { + let zone = TimeZone::utc(); + assert_eq!(zone.offset_at(1_784_116_800), 0); + assert_eq!(zone.offset_for_local(1_784_116_800), 0); + assert_eq!( + zone.types, + vec![LocalType { + offset: 0, + is_dst: false + }] + ); + } + + // RFC 8536 sections 3.1 and 3.2: a version-1 header, signed 32-bit + // transition instants, type indices, six-byte type records and designations. + fn version_one(transitions: &[(i32, u8)], types: &[(i32, bool)]) -> Vec { + let mut bytes = b"TZif\0".to_vec(); + bytes.resize(20, 0); + for count in [0, 0, 0, transitions.len() as u32, types.len() as u32, 4] { + bytes.extend(count.to_be_bytes()); + } + for &(instant, _) in transitions { + bytes.extend(instant.to_be_bytes()); + } + bytes.extend(transitions.iter().map(|&(_, index)| index)); + for &(offset, daylight) in types { + bytes.extend(offset.to_be_bytes()); + bytes.extend([u8::from(daylight), 0]); + } + bytes.extend(b"STD\0"); + bytes + } + + #[test] + fn version_one_signed_transitions_apply_at_the_exact_instant() { + let bytes = version_one(&[(-3600, 1), (3600, 0)], &[(1800, false), (3600, true)]); + let zone = TimeZone::parse(&bytes).unwrap(); + for (instant, offset) in [(-3601, 1800), (-3600, 3600), (3599, 3600), (3600, 1800)] { + assert_eq!(zone.offset_at(instant), offset); + } + } + + #[test] + fn before_first_transition_uses_type_zero_even_when_it_is_daylight_time() { + let bytes = version_one(&[(2_000_000_000, 1)], &[(3600, true), (0, false)]); + let zone = TimeZone::parse(&bytes).unwrap(); + assert_eq!(zone.offset_at(1_000_000_000), 3600); + assert_eq!(zone.offset_at(1_999_999_999), 3600); + assert_eq!(zone.offset_at(2_000_000_000), 0); + assert_eq!(zone.offset_for_local(1_000_000_000), 3600); + } + + #[test] + fn rejects_empty_types_invalid_indices_and_nonascending_transitions() { + for bytes in [ + version_one(&[], &[]), + version_one(&[(0, 1)], &[(0, false)]), + version_one(&[(3600, 0), (0, 0)], &[(0, false)]), + version_one(&[(0, 0), (0, 0)], &[(0, false)]), + ] { + assert!(TimeZone::parse(&bytes).is_none()); + } + let bytes = version_one(&[(0, 0)], &[(0, false)]); + // Every prefix missing transition/type data is incomplete. + for cut in 0..bytes.len() - 4 { + assert!(TimeZone::parse(&bytes[..cut]).is_none(), "cut {cut}"); + } + let mut foreign = bytes; + foreign[..4].copy_from_slice(b"NOPE"); + assert!(TimeZone::parse(&foreign).is_none()); + } + + #[test] + fn rejects_truncated_designations_and_other_declared_block_data() { + let bytes = version_one(&[(0, 0)], &[(0, false)]); + for cut in bytes.len() - 4..bytes.len() { + assert!(TimeZone::parse(&bytes[..cut]).is_none(), "cut {cut}"); + } + // Counts for leap records and standard/UT indicators also contribute + // to the block extent, even though conversion does not interpret them. + for count_at in [20, 24, 28] { + let mut incomplete = bytes.clone(); + incomplete[count_at..count_at + 4].copy_from_slice(&1u32.to_be_bytes()); + assert!( + TimeZone::parse(&incomplete).is_none(), + "count at {count_at}" + ); + } + } + + #[cfg(target_pointer_width = "32")] + #[test] + fn declared_block_sizes_reject_overflow_on_native_32_bit_hosts() { + use super::{Header, TimeWidth}; + let empty = Header { + version: 0, + isutcnt: 0, + isstdcnt: 0, + leapcnt: 0, + timecnt: 0, + typecnt: 0, + charcnt: 0, + }; + let wire_maximum = u32::MAX as usize; + for header in [ + Header { + timecnt: wire_maximum, + ..empty + }, + Header { + typecnt: wire_maximum, + ..empty + }, + Header { + leapcnt: wire_maximum, + ..empty + }, + Header { + isstdcnt: wire_maximum, + isutcnt: 1, + ..empty + }, + ] { + assert!(header.data_len(TimeWidth::Bits32).is_none()); + assert!(header.data_len(TimeWidth::Bits64).is_none()); + } + let header = Header { + charcnt: wire_maximum, + ..empty + }; + assert_eq!(header.data_len(TimeWidth::Bits32), Some(wire_maximum)); + assert!(header.data_end(TimeWidth::Bits32).is_none()); + } + + #[test] + fn zone_paths_honor_colons_and_directories_without_parent_traversal() { + use std::ffi::OsStr; + use std::path::PathBuf; + assert_eq!( + super::zone_path(None, None), + Some(PathBuf::from("/etc/localtime")) + ); + for name in [ + "", + ":", + "Europe//London", + "Europe/../London", + "./Europe/London", + "Europe/./London", + "Europe/", + ] { + assert!( + super::zone_path(Some(OsStr::new(name)), None).is_none(), + "{name}" + ); + } + for name in ["Europe/London", ":Europe/London"] { + assert_eq!( + super::zone_path(Some(OsStr::new(name)), None), + Some(PathBuf::from("/usr/share/zoneinfo/Europe/London")), + ); + assert_eq!( + super::zone_path(Some(OsStr::new(name)), Some(OsStr::new("custom-zones"))), + Some(PathBuf::from("custom-zones/Europe/London")), + ); + } + let absolute = std::env::current_dir().unwrap().join("chosen-zone"); + for name in [ + absolute.as_os_str().to_owned(), + format!(":{}", absolute.display()).into(), + ] { + assert_eq!(super::zone_path(Some(&name), None), Some(absolute.clone())); + } + #[cfg(unix)] + { + use std::os::unix::ffi::OsStrExt; + assert!(super::zone_path(Some(OsStr::from_bytes(&[0xff])), None).is_none()); + } + } + + #[test] + fn daylight_only_gap_uses_the_offset_at_the_reading_when_no_standard_type_exists() { + let bytes = version_one(&[(1_000_000_000, 1)], &[(3600, true), (7200, true)]); + let zone = TimeZone::parse(&bytes).unwrap(); + assert_eq!(zone.offset_for_local(1_000_005_000), 7200); + } + + #[test] + fn repeated_reading_retains_first_candidate_when_daylight_status_is_equal() { + // A political offset change can repeat a reading without changing + // daylight status. Both instants are valid; preserve the first match. + for daylight in [false, true] { + let bytes = version_one(&[(1_000_000_000, 1)], &[(7200, daylight), (3600, daylight)]); + let zone = TimeZone::parse(&bytes).unwrap(); + let reading = 1_000_005_000; + assert_eq!(zone.offset_at(reading - 7200), 7200); + assert_eq!(zone.offset_at(reading - 3600), 3600); + assert_eq!(zone.offset_for_local(reading), 7200); + } + } + + /// A damaged or foreign file must not panic or be believed. + #[test] + fn rejects_files_that_are_not_a_usable_zone() { + assert!(TimeZone::parse(b"").is_none()); + assert!(TimeZone::parse(b"not a tzif file at all").is_none()); + assert!(TimeZone::parse(&LONDON[..20]).is_none(), "truncated header"); + assert!(TimeZone::parse(&LONDON[..200]).is_none(), "truncated body"); + } +} diff --git a/arca-rar/vendor/rars/src/version.rs b/arca-rar/vendor/rars/src/version.rs new file mode 100644 index 00000000..504fbcad --- /dev/null +++ b/arca-rar/vendor/rars/src/version.rs @@ -0,0 +1,139 @@ +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum ArchiveFamily { + Rar13, + Rar15To40, + Rar50Plus, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum ArchiveVersion { + Rar13, + Rar14, + Rar15, + Rar20, + Rar29, + Rar30, + Rar40, + Rar50, + Rar70, +} + +impl ArchiveVersion { + pub const fn family(self) -> ArchiveFamily { + match self { + Self::Rar13 | Self::Rar14 => ArchiveFamily::Rar13, + Self::Rar15 | Self::Rar20 | Self::Rar29 | Self::Rar30 | Self::Rar40 => { + ArchiveFamily::Rar15To40 + } + Self::Rar50 | Self::Rar70 => ArchiveFamily::Rar50Plus, + } + } + + pub const fn is_rar13_family(self) -> bool { + matches!(self, Self::Rar13 | Self::Rar14) + } + + /// Every version, so a caller can ask what each one supports without + /// keeping its own list that drifts. + pub const ALL: [Self; 9] = [ + Self::Rar13, + Self::Rar14, + Self::Rar15, + Self::Rar20, + Self::Rar29, + Self::Rar30, + Self::Rar40, + Self::Rar50, + Self::Rar70, + ]; + + /// The inverse of [`as_str`](Self::as_str), for callers that take a format + /// name from outside the process. Separators and case are ignored, and the + /// short spellings `rar4`, `rar5` and `rar7` name the newest version in + /// their family, so `rar-5.0` and `RAR5` both reach [`Self::Rar50`]. + pub fn from_name(name: &str) -> Option { + match name + .to_ascii_lowercase() + .replace(['_', '-', '.', ' '], "") + .as_str() + { + "rar13" => Some(Self::Rar13), + "rar14" => Some(Self::Rar14), + "rar15" => Some(Self::Rar15), + "rar20" => Some(Self::Rar20), + "rar29" => Some(Self::Rar29), + "rar30" => Some(Self::Rar30), + "rar40" | "rar4" => Some(Self::Rar40), + "rar50" | "rar5" => Some(Self::Rar50), + "rar70" | "rar7" => Some(Self::Rar70), + _ => None, + } + } + + /// The spelling used by the `--format` argument, and by every message a + /// user reads. It is the only spelling they can type back into the tool. + pub const fn as_str(self) -> &'static str { + match self { + Self::Rar13 => "rar13", + Self::Rar14 => "rar14", + Self::Rar15 => "rar15", + Self::Rar20 => "rar20", + Self::Rar29 => "rar29", + Self::Rar30 => "rar30", + Self::Rar40 => "rar40", + Self::Rar50 => "rar50", + Self::Rar70 => "rar70", + } + } +} + +impl std::fmt::Display for ArchiveVersion { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(self.as_str()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn maps_versions_to_archive_families() { + let cases = [ + (ArchiveVersion::Rar13, ArchiveFamily::Rar13), + (ArchiveVersion::Rar14, ArchiveFamily::Rar13), + (ArchiveVersion::Rar15, ArchiveFamily::Rar15To40), + (ArchiveVersion::Rar20, ArchiveFamily::Rar15To40), + (ArchiveVersion::Rar29, ArchiveFamily::Rar15To40), + (ArchiveVersion::Rar30, ArchiveFamily::Rar15To40), + (ArchiveVersion::Rar40, ArchiveFamily::Rar15To40), + (ArchiveVersion::Rar50, ArchiveFamily::Rar50Plus), + (ArchiveVersion::Rar70, ArchiveFamily::Rar50Plus), + ]; + + for (version, family) in cases { + assert_eq!(version.family(), family); + } + } + + #[test] + fn identifies_rar13_family_versions() { + let cases = [ + (ArchiveVersion::Rar13, true), + (ArchiveVersion::Rar14, true), + (ArchiveVersion::Rar15, false), + (ArchiveVersion::Rar20, false), + (ArchiveVersion::Rar29, false), + (ArchiveVersion::Rar30, false), + (ArchiveVersion::Rar40, false), + (ArchiveVersion::Rar50, false), + (ArchiveVersion::Rar70, false), + ]; + + for (version, expected) in cases { + assert_eq!(version.is_rar13_family(), expected); + } + } +} diff --git a/arca-rar/vendor/rars/src/volume_extract.rs b/arca-rar/vendor/rars/src/volume_extract.rs new file mode 100644 index 00000000..cb91f839 --- /dev/null +++ b/arca-rar/vendor/rars/src/volume_extract.rs @@ -0,0 +1,183 @@ +use crate::codec::workspace::{Allowance, Budget, Buffer}; +use std::io::{Read, Result}; + +pub(crate) struct SplitVolumeState

{ + pending: Option

, +} + +impl

SplitVolumeState

{ + pub(crate) fn new() -> Self { + Self { pending: None } + } + + pub(crate) fn advance( + &mut self, + split_before: bool, + split_after: bool, + ) -> SplitVolumeStep<'_, P> { + match (self.pending.is_some(), split_before, split_after) { + (false, false, false) => SplitVolumeStep::Regular, + (false, false, true) => SplitVolumeStep::Start, + // The match arm's first field proves a pending split exists. + (true, true, true) => { + SplitVolumeStep::Continue(self.pending.as_mut().expect("pending split")) + } + // The match arm's first field proves a pending split exists. + (true, true, false) => { + SplitVolumeStep::Finish(self.pending.take().expect("pending split")) + } + // Error states leave pending untouched; callers currently return + // the error immediately rather than attempting recovery. + (false, true, _) => SplitVolumeStep::MissingFirst, + (true, false, _) => SplitVolumeStep::Interrupted, + } + } + + pub(crate) fn begin(&mut self, pending: P) { + debug_assert!(self.pending.is_none()); + self.pending = Some(pending); + } + + pub(crate) fn is_pending(&self) -> bool { + self.pending.is_some() + } +} + +pub(crate) enum SplitVolumeStep<'a, P> { + Regular, + Start, + Continue(&'a mut P), + Finish(P), + MissingFirst, + Interrupted, +} + +pub(crate) struct ChainedReader { + readers: Buffer, + index: usize, +} + +impl ChainedReader { + pub(crate) fn with_readers(readers: Buffer) -> Self { + Self { readers, index: 0 } + } +} +#[cfg(test)] +impl ChainedReader { + pub(crate) fn new(readers: Vec) -> Self { + Self { + readers: Buffer::from_vec(readers), + index: 0, + } + } +} + +impl Read for ChainedReader { + fn read(&mut self, out: &mut [u8]) -> Result { + if out.is_empty() { + return Ok(0); + } + while let Some(reader) = self.readers.get_mut(self.index) { + let read = reader.read(out)?; + if read != 0 { + return Ok(read); + } + self.index += 1; + } + Ok(0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Cursor; + + #[test] + fn split_volume_state_reports_regular_member_without_pending_split() { + let mut state = SplitVolumeState::::new(); + + assert!(matches!( + state.advance(false, false), + SplitVolumeStep::Regular + )); + assert!(!state.is_pending()); + } + + #[test] + fn split_volume_state_tracks_start_continue_and_finish() { + let mut state = SplitVolumeState::new(); + + assert!(matches!(state.advance(false, true), SplitVolumeStep::Start)); + state.begin(vec![1]); + assert!(state.is_pending()); + + match state.advance(true, true) { + SplitVolumeStep::Continue(parts) => parts.push(2), + _ => panic!("expected split continuation"), + } + assert!(state.is_pending()); + + match state.advance(true, false) { + SplitVolumeStep::Finish(parts) => assert_eq!(parts, vec![1, 2]), + _ => panic!("expected split finish"), + } + assert!(!state.is_pending()); + } + + #[test] + fn split_volume_state_reports_orphan_continuation() { + let mut state = SplitVolumeState::::new(); + + assert!(matches!( + state.advance(true, false), + SplitVolumeStep::MissingFirst + )); + assert!(matches!( + state.advance(true, true), + SplitVolumeStep::MissingFirst + )); + assert!(!state.is_pending()); + } + + #[test] + fn split_volume_state_reports_regular_entry_interrupting_pending_split() { + let mut state = SplitVolumeState::new(); + assert!(matches!(state.advance(false, true), SplitVolumeStep::Start)); + state.begin(7u8); + + assert!(matches!( + state.advance(false, false), + SplitVolumeStep::Interrupted + )); + assert!(state.is_pending()); + } + + #[test] + fn chained_reader_empty_reads_do_not_consume_fragments() { + let mut reader = ChainedReader::new(vec![Cursor::new(b"one"), Cursor::new(b"two")]); + assert_eq!(reader.read(&mut []).unwrap(), 0); + let mut byte = [0]; + reader.read_exact(&mut byte).unwrap(); + assert_eq!(&byte, b"o"); + assert_eq!(reader.read(&mut []).unwrap(), 0); + let mut rest = Vec::new(); + reader.read_to_end(&mut rest).unwrap(); + assert_eq!(rest, b"netwo"); + } + + #[test] + fn chained_reader_reads_all_fragments_in_order() { + let readers: Vec> = vec![ + Box::new(Cursor::new(b"one".to_vec())), + Box::new(Cursor::new(Vec::new())), + Box::new(Cursor::new(b"two".to_vec())), + ]; + let mut reader = ChainedReader::new(readers); + let mut out = Vec::new(); + + reader.read_to_end(&mut out).unwrap(); + + assert_eq!(out, b"onetwo"); + } +} diff --git a/arca-rar/vendor/rars/src/write_plan.rs b/arca-rar/vendor/rars/src/write_plan.rs new file mode 100644 index 00000000..6d4bc9ef --- /dev/null +++ b/arca-rar/vendor/rars/src/write_plan.rs @@ -0,0 +1,446 @@ +//! What each format's writer can be asked for, and one place that says no. +//! +//! Every writer used to answer this for itself, in about thirty functions that +//! nearly all ended the same way: build the set of features this shape of +//! archive is allowed, compare it with what the caller asked for, and on a +//! mismatch return a fixed string that never said which option was the problem. +//! A caller who asked for two things and could only have one was told "writer +//! feature is not supported" and left to work out which. +//! +//! So capability is data here, keyed by format and by the shape of the archive +//! being built, and a refusal names the option, the format, and why. + +use crate::error::{Error, Result}; +use crate::features::{Feature, FeatureSet}; +use crate::filter::FilterPolicy; +use crate::version::{ArchiveFamily, ArchiveVersion}; + +/// How the members of an archive are coded. +/// +/// The three arms are the three questions a writer has to answer before it +/// touches a member, and they used to be three entry points per format that +/// differed in a handful of lines each. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +#[non_exhaustive] +pub enum MemberCoding { + /// Store every member as it is. + Stored, + /// Compress, letting the writer decide how. The RAR 2.9 family looks for a + /// filter unless PPMd was asked for; RAR 1.3 to 2.0 have none to look for. + #[default] + Compressed, + /// Compress under a filter policy the caller named. RAR 2.9 and later only. + Filtered(FilterPolicy), +} + +impl MemberCoding { + pub fn compresses(&self) -> bool { + !matches!(self, Self::Stored) + } + + pub fn is_filtered(&self) -> bool { + matches!(self, Self::Filtered(_)) + } + + /// The shape of archive this coding produces, so validation and the + /// capability table are asked the same question the writer will answer. + pub fn shape(&self) -> PlanShape { + PlanShape::new() + .compressed(self.compresses()) + .filtered(self.is_filtered()) + } +} + +/// What kind of archive is being built. Capability answers depend on this as +/// well as on the format: RAR 5 will write a file comment into a stored archive +/// but not a compressed one, for instance. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +#[non_exhaustive] +pub struct PlanShape { + pub compressed: bool, + pub volumes: bool, + pub filtered: bool, +} + +impl PlanShape { + pub const fn new() -> Self { + Self { + compressed: false, + volumes: false, + filtered: false, + } + } + + pub const fn compressed(mut self, compressed: bool) -> Self { + self.compressed = compressed; + self + } + + pub const fn volumes(mut self, volumes: bool) -> Self { + self.volumes = volumes; + self + } + + pub const fn filtered(mut self, filtered: bool) -> Self { + self.filtered = filtered; + self + } + + /// Every combination, for exhaustively checking capability answers. + pub fn all() -> Vec { + let mut shapes = Vec::with_capacity(8); + for compressed in [false, true] { + for volumes in [false, true] { + for filtered in [false, true] { + shapes.push(Self { + compressed, + volumes, + filtered, + }); + } + } + } + shapes + } +} + +pub use crate::writer_option::WriterOption; + +/// The features this format can honour for an archive of this shape. +/// +/// Deliberately blind to what the caller asked for. The check this replaced +/// built its "allowed" set partly out of the request itself, which in several +/// places decayed into assigning a flag to itself, so the flag was accepted +/// whatever it said. +pub fn supported_features(target: ArchiveVersion, shape: PlanShape) -> FeatureSet { + FeatureSet { + solid: supports(target, WriterOption::Feature(Feature::Solid), shape), + header_encryption: supports( + target, + WriterOption::Feature(Feature::HeaderEncryption), + shape, + ), + quick_open: supports(target, WriterOption::Feature(Feature::QuickOpen), shape), + } +} + +/// Whether this format's writer can honour `option` for an archive of this +/// shape. +pub fn supports(target: ArchiveVersion, option: WriterOption, shape: PlanShape) -> bool { + if !cfg!(feature = "encryption") + && matches!( + option, + WriterOption::Password | WriterOption::Feature(Feature::HeaderEncryption) + ) + { + return false; + } + + let family = target.family(); + match option { + // Solid means compressing members against each other, so there has to + // be compression for it to mean anything. + WriterOption::Feature(Feature::Solid) => shape.compressed, + WriterOption::Feature(Feature::HeaderEncryption) => matches!( + target, + ArchiveVersion::Rar30 + | ArchiveVersion::Rar40 + | ArchiveVersion::Rar50 + | ArchiveVersion::Rar70 + ), + // Quick-open indexes headers, so it cannot cover encrypted ones, and + // no volume writer emits the index. + WriterOption::Feature(Feature::QuickOpen) => { + family == ArchiveFamily::Rar50Plus && !shape.volumes + } + WriterOption::CompressionLevel => true, + // PPMd arrived with RAR 2.9 and left again with RAR 5. The legacy + // volume writer takes a packed payload rather than a method, so a + // split set is always LZ. + WriterOption::CompressionMethod => { + matches!( + target, + ArchiveVersion::Rar29 | ArchiveVersion::Rar30 | ArchiveVersion::Rar40 + ) && !shape.volumes + } + WriterOption::DictionarySize => !family_is(family, ArchiveFamily::Rar13), + // RAR 1.3 and 1.5 have no filters at all; RAR 2.0 predates the VM. The + // legacy volume writer takes a payload rather than a policy, so a + // filter cannot be asked for across a split set. + WriterOption::Filter => { + !matches!( + target, + ArchiveVersion::Rar13 + | ArchiveVersion::Rar14 + | ArchiveVersion::Rar15 + | ArchiveVersion::Rar20 + ) && (family == ArchiveFamily::Rar50Plus || !shape.volumes) + } + WriterOption::RecoveryRecord => { + cfg!(feature = "recovery") && family == ArchiveFamily::Rar50Plus + } + WriterOption::VolumeSize => true, + // No volume writer carries a comment: the legacy one emits the split + // member and nothing else, and the RAR 5 one refuses comments outright + // because a volume set has no single place to put one. + WriterOption::ArchiveComment => !shape.volumes, + // Embedded legacy file comments and RAR5 service comments are supported + // for single archives; volume writers cannot retain their association. + WriterOption::FileComment => !shape.volumes, + WriterOption::ArchiveMetadata => family == ArchiveFamily::Rar50Plus && !shape.volumes, + WriterOption::Password => true, + // Every writer compresses to a budget now: RAR 5 sizes its blocks by + // it, and the older ones use it to decide how many members to have in + // flight. A legacy volume set is the exception, still built in memory. + WriterOption::MemoryLimit => family == ArchiveFamily::Rar50Plus || !shape.volumes, + // Only the RAR 5 engine spills to disk. + WriterOption::TempDir => family == ArchiveFamily::Rar50Plus, + } +} + +const fn family_is(family: ArchiveFamily, other: ArchiveFamily) -> bool { + matches!( + (family, other), + (ArchiveFamily::Rar13, ArchiveFamily::Rar13) + | (ArchiveFamily::Rar15To40, ArchiveFamily::Rar15To40) + | (ArchiveFamily::Rar50Plus, ArchiveFamily::Rar50Plus) + ) +} + +/// Every format whose writer can honour `option` for an archive of this shape. +/// +/// Computed rather than stored, so a writer that gains a feature does not leave +/// a stale list behind in an error message. +pub fn formats_supporting(option: WriterOption, shape: PlanShape) -> Vec { + ArchiveVersion::ALL + .into_iter() + .filter(|&target| supports(target, option, shape)) + .collect() +} + +/// Refuses the first feature this format cannot honour. +pub fn validate_features( + target: ArchiveVersion, + asked: FeatureSet, + shape: PlanShape, +) -> Result<()> { + if asked.header_encryption { + crate::crypto::require_encryption()?; + } + + match asked.first_unsupported(supported_features(target, shape)) { + Some(feature) => Err(Error::UnsupportedWriterOption { + target, + option: WriterOption::Feature(feature), + because: None, + }), + None => Ok(()), + } +} + +/// Refuses a compression level outside the range every format shares. +pub fn validate_compression_level(target: ArchiveVersion, level: Option) -> Result<()> { + match level { + None | Some(0..=5) => Ok(()), + Some(_) => Err(Error::UnsupportedWriterOption { + target, + option: WriterOption::CompressionLevel, + because: Some("levels run from 0 to 5"), + }), + } +} + +/// Refuses an option this format cannot honour for this shape of archive. +pub fn validate_option( + target: ArchiveVersion, + option: WriterOption, + shape: PlanShape, +) -> Result<()> { + if !cfg!(feature = "encryption") + && matches!( + option, + WriterOption::Password | WriterOption::Feature(Feature::HeaderEncryption) + ) + { + return Err(Error::FeatureDisabled { + feature: "encryption", + }); + } + if !cfg!(feature = "recovery") && matches!(option, WriterOption::RecoveryRecord) { + return Err(Error::FeatureDisabled { + feature: "recovery", + }); + } + if supports(target, option, shape) { + Ok(()) + } else { + Err(Error::UnsupportedWriterOption { + target, + option, + because: None, + }) + } +} + +/// Whether a compressed member should be written as stored bytes instead. +/// +/// Compression that does not shrink a member costs the reader time for nothing. +/// The formats disagree about when that trade is worth making, so what differs +/// between them is parameters here rather than three separate rules. +#[derive(Debug, Clone, Copy)] +pub(crate) struct StoreFallback { + /// Members below this size stay compressed. Where a stored member costs + /// enough header of its own, swapping a small one can lose more than the + /// compression was wasting. + pub(crate) min_size: usize, + /// Whether a solid member may be swapped. RAR 5 runs one dictionary across + /// every member and cannot go back on what it has already fed in; the + /// RAR 1.5 family rebuilds its encoder at that point instead. + pub(crate) allow_solid: bool, + /// A filter the caller named is not discarded because the result did not + /// shrink. They asked for it. + pub(crate) filter_requested: bool, +} + +impl StoreFallback { + pub(crate) const fn new() -> Self { + Self { + min_size: 0, + allow_solid: false, + filter_requested: false, + } + } + + pub(crate) const fn min_size(mut self, size: usize) -> Self { + self.min_size = size; + self + } + + pub(crate) const fn allow_solid(mut self, allow: bool) -> Self { + self.allow_solid = allow; + self + } + + pub(crate) const fn filter_requested(mut self, requested: bool) -> Self { + self.filter_requested = requested; + self + } + + pub(crate) fn applies(&self, solid: bool, unpacked: usize, packed: usize) -> bool { + if packed < unpacked || self.filter_requested { + return false; + } + if solid && !self.allow_solid { + return false; + } + unpacked >= self.min_size + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// The capability table and the validator have to agree everywhere, or a + /// caller can be told an option is available and then refused it. + #[test] + fn asking_and_validating_agree_for_every_combination() { + for target in ArchiveVersion::ALL { + for option in WriterOption::ALL { + for shape in PlanShape::all() { + let supported = supports(target, option, shape); + let validated = validate_option(target, option, shape); + assert_eq!( + supported, + validated.is_ok(), + "{target} {option:?} {shape:?}: supports={supported} validate={validated:?}" + ); + if let Err(Error::UnsupportedWriterOption { option: named, .. }) = validated { + assert_eq!(named, option, "the refusal named the wrong option"); + } + } + } + } + } + + /// A refusal is only useful if it can point somewhere, so every option has + /// to be available on at least one format. + #[test] + fn every_option_is_supported_by_some_format() { + for option in WriterOption::ALL { + assert!(!option.name().is_empty()); + let disabled = match option { + WriterOption::Password | WriterOption::Feature(Feature::HeaderEncryption) => { + !cfg!(feature = "encryption") + } + WriterOption::RecoveryRecord => !cfg!(feature = "recovery"), + _ => false, + }; + assert_eq!( + PlanShape::all() + .into_iter() + .any(|shape| !formats_supporting(option, shape).is_empty()), + !disabled, + "{option:?} must have a supporting format exactly when its capability is enabled" + ); + } + } + + #[test] + fn feature_capability_matches_the_per_option_answer() { + for target in ArchiveVersion::ALL { + for shape in PlanShape::all() { + let features = supported_features(target, shape); + for feature in Feature::ALL { + assert_eq!( + feature_of(features, feature), + supports(target, WriterOption::Feature(feature), shape), + "{target} {feature:?} {shape:?}" + ); + } + } + } + } + + fn feature_of(set: FeatureSet, feature: Feature) -> bool { + match feature { + Feature::Solid => set.solid, + Feature::HeaderEncryption => set.header_encryption, + Feature::QuickOpen => set.quick_open, + } + } + + #[test] + fn a_member_is_only_stored_when_compressing_it_gained_nothing() { + let plain = StoreFallback::new(); + assert!(plain.applies(false, 100, 100)); + assert!(plain.applies(false, 100, 120)); + assert!(!plain.applies(false, 100, 99)); + + // A named filter survives a result that did not shrink. + assert!(!plain.filter_requested(true).applies(false, 100, 200)); + + // Solid is refused unless the format can rebuild its chain. + assert!(!plain.applies(true, 100, 100)); + assert!(plain.allow_solid(true).applies(true, 100, 100)); + + // The floor keeps small members compressed. + let floored = plain.min_size(1024); + assert!(!floored.applies(false, 1023, 1023)); + assert!(floored.applies(false, 1024, 1024)); + } + + #[test] + fn a_level_above_five_is_refused_by_name() { + let refused = validate_compression_level(ArchiveVersion::Rar50, Some(9)); + assert!(matches!( + refused, + Err(Error::UnsupportedWriterOption { + option: WriterOption::CompressionLevel, + .. + }) + )); + assert!(validate_compression_level(ArchiveVersion::Rar50, Some(5)).is_ok()); + assert!(validate_compression_level(ArchiveVersion::Rar50, None).is_ok()); + } +} diff --git a/arca-rar/vendor/rars/src/write_progress.rs b/arca-rar/vendor/rars/src/write_progress.rs new file mode 100644 index 00000000..8a6169eb --- /dev/null +++ b/arca-rar/vendor/rars/src/write_progress.rs @@ -0,0 +1,304 @@ +pub(crate) use crate::progress::ProgressReporter; +use crate::progress::{WriteOperation, WriteProgress, WriteProgressEvent}; + +pub(crate) struct WorkTracker<'a> { + progress: Option>, + operation: WriteOperation, + total: u64, + state: Mutex, +} + +#[derive(Default)] +struct WorkState { + completed: u64, +} + +impl<'a> WorkTracker<'a> { + pub(crate) fn reporter(&self) -> Option> { + self.progress + } + + pub(crate) fn check(&self) -> crate::Result<()> { + check_cancelled(self.progress) + } + pub(crate) fn new( + progress: Option>, + operation: WriteOperation, + total: u64, + ) -> Self { + Self { + progress, + operation, + total, + state: Mutex::new(WorkState::default()), + } + } + + pub(crate) fn is_cancelled(&self) -> bool { + self.progress.is_some_and(ProgressReporter::is_cancelled) + } + + pub(crate) fn advance(&self, amount: u64) -> bool { + let Some(progress) = self.progress else { + return true; + }; + let mut state = self + .state + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + state.completed = state.completed.saturating_add(amount).min(self.total); + progress.report(WriteProgressEvent::Advanced { + operation: self.operation, + completed_bytes: state.completed, + total_bytes: self.total, + pass: 1, + }); + !progress.is_cancelled() + } + + pub(crate) fn finish(&self) -> bool { + let completed = self + .state + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .completed; + self.advance(self.total.saturating_sub(completed)) + } + + pub(crate) fn entry_started( + &self, + index: usize, + total_entries: usize, + name: &[u8], + input_bytes: u64, + ) { + if let Some(progress) = self.progress { + progress.report(WriteProgressEvent::EntryStarted { + operation: self.operation, + index, + total_entries, + name, + input_bytes, + }); + } + } + + pub(crate) fn entry_finished( + &self, + index: usize, + total_entries: usize, + name: &[u8], + input_bytes: u64, + ) { + if let Some(progress) = self.progress { + progress.report(WriteProgressEvent::EntryFinished { + operation: self.operation, + index, + total_entries, + name, + input_bytes, + }); + } + } +} +use std::sync::Mutex; + +/// Combine cancellation policy with optional presentation for one write. +pub(crate) struct ResourceProgress<'a> { + resources: &'a crate::WriterResources, + inner: Option>, + cancelled: std::sync::atomic::AtomicBool, +} +impl<'a> ResourceProgress<'a> { + pub(crate) fn new( + resources: &'a crate::WriterResources, + inner: Option>, + ) -> Self { + Self { + resources, + inner, + cancelled: std::sync::atomic::AtomicBool::new(false), + } + } +} +impl WriteProgress for ResourceProgress<'_> { + fn report(&self, event: WriteProgressEvent<'_>) { + if let Some(inner) = self.inner { + inner.report(event); + } + } + fn is_cancelled(&self) -> bool { + use std::sync::atomic::Ordering; + if self.cancelled.load(Ordering::Relaxed) + || self.resources.is_cancelled() + || self.inner.is_some_and(ProgressReporter::is_cancelled) + { + self.cancelled.store(true, Ordering::Relaxed); + true + } else { + false + } + } +} + +pub(crate) fn check_cancelled(progress: Option>) -> crate::Result<()> { + if progress.is_some_and(ProgressReporter::is_cancelled) { + Err(crate::Error::Cancelled) + } else { + Ok(()) + } +} + +/// Preserve typed cancellation through APIs which can only return I/O errors. +/// Never use ErrorKind::Interrupted: write_all/read_exact would retry forever. +pub(crate) struct CancellableIo<'a, T> { + pub(crate) inner: T, + pub(crate) progress: Option>, +} +impl CancellableIo<'_, T> { + fn check(&self) -> std::io::Result<()> { + check_cancelled(self.progress).map_err(std::io::Error::other) + } +} +impl std::io::Read for CancellableIo<'_, T> { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + self.check()?; + let len = if self.progress.is_some() { + buffer.len().min(64 * 1024) + } else { + buffer.len() + }; + self.inner.read(&mut buffer[..len]) + } +} +impl std::io::Write for CancellableIo<'_, T> { + fn write(&mut self, buffer: &[u8]) -> std::io::Result { + self.check()?; + let len = if self.progress.is_some() { + buffer.len().min(64 * 1024) + } else { + buffer.len() + }; + self.inner.write(&buffer[..len]) + } + fn flush(&mut self) -> std::io::Result<()> { + self.check()?; + self.inner.flush() + } +} +impl std::io::Seek for CancellableIo<'_, T> { + fn seek(&mut self, from: std::io::SeekFrom) -> std::io::Result { + self.check()?; + self.inner.seek(from) + } +} + +#[cfg(test)] +#[test] +fn callback_panic_keeps_peer_progress_and_completion_usable() { + use std::sync::atomic::{AtomicBool, Ordering}; + let panic_once = AtomicBool::new(true); + let reported = Mutex::new(Vec::new()); + let callback = |event: WriteProgressEvent<'_>| { + if let WriteProgressEvent::Advanced { + completed_bytes, .. + } = event + { + if panic_once.swap(false, Ordering::Relaxed) { + panic!("injected progress callback panic"); + } + reported.lock().unwrap().push(completed_bytes); + } + }; + let work = WorkTracker::new( + Some(ProgressReporter(&callback)), + WriteOperation::Compression, + 10, + ); + std::thread::scope(|scope| { + let worker = scope.spawn(|| work.advance(3)); + assert!(worker.join().is_err()); + let peer = scope.spawn(|| work.advance(2)); + assert!(peer.join().unwrap()); + }); + assert!(work.finish()); + assert_eq!(*reported.lock().unwrap(), [5, 10]); +} + +/// Count accepted output without buffering an archive or guessing its final size. +pub(crate) struct EmissionWriter<'a> { + output: &'a mut dyn std::io::Write, + progress: Option>, + completed: u64, + reported: u64, + started: bool, +} +impl<'a> EmissionWriter<'a> { + pub(crate) fn new( + output: &'a mut dyn std::io::Write, + progress: Option>, + ) -> Self { + Self { + output, + progress, + completed: 0, + reported: 0, + started: false, + } + } + fn start(&mut self) -> crate::Result<()> { + check_cancelled(self.progress)?; + if !self.started { + self.started = true; + if let Some(progress) = self.progress { + progress.report(WriteProgressEvent::OperationStarted { + operation: WriteOperation::Emission, + total_bytes: None, + total_entries: None, + pass: 1, + }); + } + } + check_cancelled(self.progress) + } + fn advance(&mut self) -> crate::Result<()> { + if self.completed != self.reported { + self.reported = self.completed; + if let Some(progress) = self.progress { + progress.report(WriteProgressEvent::BytesWritten { + completed_bytes: self.completed, + }); + } + } + check_cancelled(self.progress) + } + pub(crate) fn finish(&mut self) -> crate::Result<()> { + self.start()?; + self.advance()?; + if let Some(progress) = self.progress { + progress.report(WriteProgressEvent::OperationFinished { + operation: WriteOperation::Emission, + total_bytes: Some(self.completed), + total_entries: None, + pass: 1, + }); + } + check_cancelled(self.progress) + } +} +impl std::io::Write for EmissionWriter<'_> { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.start().map_err(std::io::Error::other)?; + let written = self.output.write(&bytes[..bytes.len().min(64 * 1024)])?; + self.completed += written as u64; + if self.completed - self.reported >= 64 * 1024 { + self.advance().map_err(std::io::Error::other)?; + } + check_cancelled(self.progress).map_err(std::io::Error::other)?; + Ok(written) + } + fn flush(&mut self) -> std::io::Result<()> { + check_cancelled(self.progress).map_err(std::io::Error::other)?; + self.output.flush() + } +} diff --git a/arca-rar/vendor/rars/src/write_stream.rs b/arca-rar/vendor/rars/src/write_stream.rs new file mode 100644 index 00000000..0f77db45 --- /dev/null +++ b/arca-rar/vendor/rars/src/write_stream.rs @@ -0,0 +1,452 @@ +//! Reading and writing archive members one at a time. +//! +//! The RAR 1.3 to 4.x codecs compress a member as a unit, so those writers +//! cannot avoid having a member resident. What they can avoid is having *every* +//! member resident, which is what they used to do: the caller read all the +//! inputs, the writer built the whole archive in a `Vec`, and peak memory was a +//! multiple of the total input rather than of the largest member. + +use crate::error::{Error, Result}; +use crate::streaming::EntrySource; +use std::borrow::Cow; +use std::io::{Read, Write}; + +pub(crate) use crate::entropy::fill_entropy; + +/// Attribute a writer failure without blaming a member for cancellation. +pub(crate) fn member_error(error: Error, name: &[u8], operation: &'static str) -> Error { + if error.kind() == crate::ErrorKind::Cancelled || error.entry_context().is_some() { + error + } else { + error.at_entry(name.to_vec(), operation) + } +} + +/// How much of a member is read at a time when it is walked rather than held. +const WALK_CHUNK: usize = 256 * 1024; + +/// Where one member's bytes come from. +/// +/// A caller who already holds the whole input hands over a slice; one writing +/// from disk hands over a source that is opened when the member is coded and +/// closed again straight after. Everything downstream is the same either way. +pub(crate) enum MemberBytes<'a> { + Borrowed(&'a [u8]), + Source(&'a EntrySource), + /// Builder inputs retain their source-read context even when loading is + /// deferred into a writer's preparation phase. + NamedSource(&'a EntrySource, &'a [u8]), +} + +impl<'a> MemberBytes<'a> { + pub(crate) fn len(&self) -> Result { + let result = match self { + Self::Borrowed(data) => Ok(data.len() as u64), + Self::Source(source) | Self::NamedSource(source, _) => source.len(), + }; + result.map_err(|error| self.source_error(error)) + } + + fn source_error(&self, error: Error) -> Error { + match self { + Self::NamedSource(_, name) => member_error(error, name, "reading source"), + _ => error, + } + } + + /// The whole member, borrowed when the caller already had it. + #[cfg(test)] + pub(crate) fn load(&self) -> Result> { + self.load_with_progress(None) + } + + pub(crate) fn load_with_progress( + &self, + progress: Option>, + ) -> Result> { + crate::write_progress::check_cancelled(progress)?; + self.load_exact_with_progress(self.len()?, progress) + } + + /// Use the source size already captured for the header and workspace. + /// Requerying a changing path here could disagree with that header. Inline + /// bytes remain borrowed and immutable throughout the write. + pub(crate) fn load_exact_with_progress( + &self, + expected: u64, + progress: Option>, + ) -> Result> { + self.load_exact(expected, progress) + .map_err(|error| self.source_error(error)) + } + + fn load_exact( + &self, + expected: u64, + progress: Option>, + ) -> Result> { + crate::write_progress::check_cancelled(progress)?; + match self { + Self::Borrowed(data) => Ok(Cow::Borrowed(data)), + Self::Source(source) | Self::NamedSource(source, _) => { + let capacity = usize::try_from(expected).map_err(|_| { + Error::InvalidArgument("member is larger than this host can hold") + })?; + let mut data = Vec::with_capacity(capacity); + crate::write_progress::check_cancelled(progress)?; + let mut reader = crate::write_progress::CancellableIo { + inner: source.open()?, + progress, + }; + reader.by_ref().take(expected).read_to_end(&mut data)?; + crate::write_progress::check_cancelled(progress)?; + check_source_length( + &mut reader, + data.len() as u64, + expected, + "entry source size changed while compressing", + )?; + crate::write_progress::check_cancelled(progress)?; + Ok(Cow::Owned(data)) + } + } + } + + /// Walks the member in chunks without holding it, which is how a stored + /// one is checksummed on its way through. + #[cfg(test)] + pub(crate) fn walk(&self, visit: impl FnMut(&[u8])) -> Result<()> { + self.walk_with_progress(None, visit) + } + + #[cfg(test)] + fn walk_with_progress( + &self, + progress: Option>, + visit: impl FnMut(&[u8]), + ) -> Result<()> { + crate::write_progress::check_cancelled(progress)?; + self.walk_exact_with_progress(self.len()?, progress, visit) + } + + /// Walk against the same captured source size that the member header uses. + pub(crate) fn walk_exact_with_progress( + &self, + expected: u64, + progress: Option>, + visit: impl FnMut(&[u8]), + ) -> Result<()> { + self.walk_exact(expected, progress, visit) + .map_err(|error| self.source_error(error)) + } + + fn walk_exact( + &self, + expected: u64, + progress: Option>, + mut visit: impl FnMut(&[u8]), + ) -> Result<()> { + crate::write_progress::check_cancelled(progress)?; + match self { + Self::Borrowed(data) => { + for chunk in data.chunks(WALK_CHUNK) { + crate::write_progress::check_cancelled(progress)?; + visit(chunk); + } + } + Self::Source(source) | Self::NamedSource(source, _) => { + crate::write_progress::check_cancelled(progress)?; + let mut reader = crate::write_progress::CancellableIo { + inner: source.open()?, + progress, + }; + let mut limited = reader.by_ref().take(expected); + let mut observed = 0; + let mut buffer = vec![0u8; WALK_CHUNK]; + loop { + let read = limited.read(&mut buffer)?; + if read == 0 { + break; + } + observed += read as u64; + visit(&buffer[..read]); + } + crate::write_progress::check_cancelled(progress)?; + check_source_length( + &mut reader, + observed, + expected, + "entry source size changed while reading", + )?; + } + } + crate::write_progress::check_cancelled(progress)?; + Ok(()) + } + + /// The source behind this member, when there is one to copy from. + pub(crate) fn source(&self) -> Option<&'a EntrySource> { + match self { + Self::Borrowed(_) => None, + Self::Source(source) | Self::NamedSource(source, _) => Some(source), + } + } + + /// The member has been written and verified, so this write will not + /// reopen its session-owned staged payload. Public source factories keep + /// their usual reopenable behavior. + pub(crate) fn release(&self) { + if let Some(source) = self.source() { + source.release(); + } + } +} + +/// A member's bytes as they will appear in the archive. +pub(crate) enum MemberPayload<'a> { + /// Already in memory: everything compressed, and anything encrypted. + Packed(Vec), + /// Copied from the source as the archive is written, which keeps a stored + /// member off the heap however large it is. + Copied(&'a EntrySource), +} + +impl MemberPayload<'_> { + /// How many bytes this payload puts in the archive. A copied member is + /// stored verbatim, so its packed size is the size it came in at. + pub(crate) fn size(&self, unpacked_size: u64) -> u64 { + match self { + Self::Packed(packed) => packed.len() as u64, + Self::Copied(_) => unpacked_size, + } + } + + pub(crate) fn write_to(&self, output: &mut dyn Write, expected: u64) -> Result<()> { + match self { + Self::Packed(packed) => output.write_all(packed)?, + Self::Copied(source) => { + let mut reader = source.open()?; + let copied = std::io::copy(&mut reader.by_ref().take(expected), output)?; + check_source_length( + &mut *reader, + copied, + expected, + "entry source size changed while writing", + )?; + } + } + Ok(()) + } +} + +// Consume at most the advertised length plus one probe byte, including for a +// source that keeps growing. The extra byte is never passed to a codec or sink. +pub(crate) fn check_source_length( + reader: &mut dyn Read, + observed: u64, + expected: u64, + message: &'static str, +) -> Result<()> { + if observed != expected { + return Err(Error::SourceChanged(message)); + } + let mut probe = [0]; + loop { + match reader.read(&mut probe) { + Ok(0) => return Ok(()), + Ok(_) => return Err(Error::SourceChanged(message)), + Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue, + Err(error) => return Err(error.into()), + } + } +} + +#[cfg(test)] +mod tests { + #[test] + fn captured_source_size_controls_loading_and_checksum_walks() { + struct Source; + impl crate::streaming::SourceFactory for Source { + fn len(&self) -> Result { + panic!("must use the size already captured for the member header") + } + fn open(&self) -> Result> { + Ok(Box::new(std::io::Cursor::new(b"abc".as_slice()))) + } + } + for expected in [0, 1, 3, 4] { + let source = EntrySource::from_factory(Source); + let member = MemberBytes::Source(&source); + let loaded = member.load_exact_with_progress(expected, None); + let mut observed = Vec::new(); + let walked = member.walk_exact_with_progress(expected, None, |chunk| { + observed.extend_from_slice(chunk) + }); + if expected == 3 { + assert_eq!(loaded.unwrap().as_ref(), b"abc"); + walked.unwrap(); + assert_eq!(observed, b"abc"); + } else { + assert_eq!(loaded.unwrap_err().kind(), crate::ErrorKind::SourceChanged); + assert_eq!(walked.unwrap_err().kind(), crate::ErrorKind::SourceChanged); + } + } + } + + #[test] + fn source_end_probe_retries_interruptions_and_reports_other_io_errors() { + struct Probe { + calls: usize, + fail: bool, + } + impl std::io::Read for Probe { + fn read(&mut self, _: &mut [u8]) -> std::io::Result { + self.calls += 1; + if self.calls == 1 { + Err(std::io::ErrorKind::Interrupted.into()) + } else if self.fail { + Err(std::io::ErrorKind::PermissionDenied.into()) + } else { + Ok(0) + } + } + } + let mut end = Probe { + calls: 0, + fail: false, + }; + super::check_source_length(&mut end, 7, 7, "changed").unwrap(); + assert_eq!(end.calls, 2); + let mut failed = Probe { + calls: 0, + fail: true, + }; + assert_eq!( + super::check_source_length(&mut failed, 7, 7, "changed") + .unwrap_err() + .kind(), + crate::ErrorKind::Io + ); + } + + #[test] + fn member_error_preserves_cancellation_and_existing_context() { + assert_eq!( + super::member_error(crate::Error::Cancelled, b"file", "writing"), + crate::Error::Cancelled + ); + let existing = + crate::Error::InvalidArgument("source failed").at_entry(b"file".to_vec(), "reading"); + let error = super::member_error(existing, b"file", "writing"); + assert_eq!(error.entry_context(), Some((b"file".as_slice(), "reading"))); + } + + use super::*; + + #[cfg(target_pointer_width = "32")] + #[test] + fn oversized_member_is_refused_before_opening_its_source() { + let length = u64::from(u32::MAX) + 1; + let source = EntrySource::from_opener(length, || { + panic!("an unrepresentable member must not open its source") + }); + let member = MemberBytes::Source(&source); + assert_eq!(member.len().unwrap(), length); + assert_eq!( + member.load().unwrap_err(), + Error::InvalidArgument("member is larger than this host can hold") + ); + } + + #[test] + fn changed_sources_are_bounded_and_rejected() { + use std::io::{Cursor, Seek, SeekFrom}; + use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }; + + struct Counted { + data: Cursor>, + read: Arc, + } + impl Read for Counted { + fn read(&mut self, buffer: &mut [u8]) -> std::io::Result { + let count = self.data.read(buffer)?; + self.read.fetch_add(count, Ordering::Relaxed); + Ok(count) + } + } + impl Seek for Counted { + fn seek(&mut self, position: SeekFrom) -> std::io::Result { + self.data.seek(position) + } + } + + for expected in [0, 8] { + for actual in [0, 3, 8, 1024 * 1024] { + let read = Arc::new(AtomicUsize::new(0)); + let source = EntrySource::from_opener(expected, { + let read = Arc::clone(&read); + move || { + Ok(Box::new(Counted { + data: Cursor::new(vec![42; actual]), + read: Arc::clone(&read), + })) + } + }); + let bytes = MemberBytes::Source(&source); + let valid = actual as u64 == expected; + assert_eq!(bytes.load().is_ok(), valid); + assert!(read.swap(0, Ordering::Relaxed) as u64 <= expected + 1); + let mut visited = 0; + assert_eq!(bytes.walk(|chunk| visited += chunk.len()).is_ok(), valid); + assert!(visited as u64 <= expected); + assert!(read.swap(0, Ordering::Relaxed) as u64 <= expected + 1); + let mut output = Vec::new(); + assert_eq!( + MemberPayload::Copied(&source) + .write_to(&mut output, expected) + .is_ok(), + valid + ); + assert!(output.len() as u64 <= expected); + assert!(read.load(Ordering::Relaxed) as u64 <= expected + 1); + } + } + } + + #[test] + fn a_source_walks_in_chunks_and_loads_whole() { + let data: Vec = (0..WALK_CHUNK * 2 + 7).map(|index| index as u8).collect(); + let source = EntrySource::from_bytes(data.clone()); + let bytes = MemberBytes::Source(&source); + + assert_eq!(bytes.len().unwrap(), data.len() as u64); + assert_eq!(bytes.load().unwrap().as_ref(), data.as_slice()); + + let mut chunks = Vec::new(); + let mut seen = Vec::new(); + bytes + .walk(|chunk| { + chunks.push(chunk.len()); + seen.extend_from_slice(chunk); + }) + .unwrap(); + assert_eq!(seen, data); + assert!(chunks.len() > 1, "a large source should arrive in pieces"); + } + + #[test] + fn borrowed_bytes_are_never_copied() { + let data = b"already in memory".to_vec(); + let bytes = MemberBytes::Borrowed(&data); + assert!(matches!(bytes.load().unwrap(), Cow::Borrowed(_))); + assert!(bytes.source().is_none()); + let mut visited = Vec::new(); + bytes + .walk(|chunk| visited.extend_from_slice(chunk)) + .unwrap(); + assert_eq!(visited, data); + } +} diff --git a/arca-rar/vendor/rars/src/writer_option.rs b/arca-rar/vendor/rars/src/writer_option.rs new file mode 100644 index 00000000..cb226d57 --- /dev/null +++ b/arca-rar/vendor/rars/src/writer_option.rs @@ -0,0 +1,63 @@ +//! Writer option names retained for structured error diagnostics. + +use crate::features::Feature; + +/// Something a caller can ask a writer for, that a format may not be able to do. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[non_exhaustive] +pub enum WriterOption { + Feature(Feature), + CompressionLevel, + /// An engine other than the format's default, which today means PPMd. + CompressionMethod, + DictionarySize, + Filter, + RecoveryRecord, + VolumeSize, + ArchiveComment, + FileComment, + ArchiveMetadata, + Password, + MemoryLimit, + TempDir, +} + +impl WriterOption { + pub const ALL: [Self; 15] = [ + Self::Feature(Feature::Solid), + Self::Feature(Feature::HeaderEncryption), + Self::Feature(Feature::QuickOpen), + Self::CompressionLevel, + Self::CompressionMethod, + Self::DictionarySize, + Self::Filter, + Self::RecoveryRecord, + Self::VolumeSize, + Self::ArchiveComment, + Self::FileComment, + Self::ArchiveMetadata, + Self::Password, + Self::MemoryLimit, + Self::TempDir, + ]; + + /// How this option is named in a library message. The command line + /// substitutes the flag the user actually typed. + pub const fn name(self) -> &'static str { + match self { + Self::Feature(feature) => feature.name(), + Self::CompressionLevel => "a compression level", + Self::CompressionMethod => "an alternative compression method", + Self::DictionarySize => "a dictionary size", + Self::Filter => "a data filter", + Self::RecoveryRecord => "a recovery record", + Self::VolumeSize => "splitting into volumes", + Self::ArchiveComment => "an archive comment", + Self::FileComment => "a per-file comment", + Self::ArchiveMetadata => "archive metadata", + Self::Password => "encryption", + Self::MemoryLimit => "a memory limit", + Self::TempDir => "a temporary directory", + } + } +} diff --git a/arca-rar/vendor/rars/src/x86_filter_scan.rs b/arca-rar/vendor/rars/src/x86_filter_scan.rs new file mode 100644 index 00000000..0075a95a --- /dev/null +++ b/arca-rar/vendor/rars/src/x86_filter_scan.rs @@ -0,0 +1,440 @@ +#[cfg(test)] +use crate::codec::workspace::Allowance; +use crate::codec::workspace::{Budget, Buffer}; +use crate::codec::Result; +use std::ops::Range; + +const AUTO_X86_CLUSTER_GAP: usize = 4096; +const AUTO_X86_TIGHT_CLUSTER_GAP: usize = 512; +const AUTO_X86_SPAN_CLUSTER_GAP: usize = 32768; +const AUTO_X86_RANGE_PADDING: usize = 16; +const AUTO_X86_MAX_RANGES: usize = 8; +const AUTO_X86_MAX_SPAN_RANGES: usize = 4; +const AUTO_X86_MIN_SPAN_OPCODES: usize = 4; + +#[cfg(test)] +pub(crate) fn auto_x86_filter_ranges(data: &[u8], include_e9: bool) -> Vec> { + ranges_with_allowance(data, include_e9, &Allowance::default()) + .expect("unlimited scanner") + .into_vec() +} + +pub(crate) fn ranges_with_allowance( + data: &[u8], + include_e9: bool, + allowance: &B, +) -> Result, B>> { + let mut ranges = + auto_x86_filter_ranges_with_cluster_gap(data, include_e9, AUTO_X86_CLUSTER_GAP, allowance)?; + for range in auto_x86_filter_ranges_with_cluster_gap( + data, + include_e9, + AUTO_X86_TIGHT_CLUSTER_GAP, + allowance, + )? { + if !ranges.contains(&range) { + ranges.try_push(range)?; + } + } + Ok(ranges) +} + +fn auto_x86_filter_ranges_with_cluster_gap( + data: &[u8], + include_e9: bool, + cluster_gap: usize, + allowance: &B, +) -> Result, B>> { + if data.len() <= 5 { + return Ok(Buffer::new(allowance)); + } + + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let mut clusters = Buffer::new(allowance); + let mut current: Option<(usize, usize, usize)> = None; + let mut scan_pos = 0usize; + while let Some(pos) = + crate::codec::fast::next_x86_opcode(data, scan_pos, data.len() - 4, cmp_mask) + { + match current { + Some((start, last, count)) if pos - last <= cluster_gap => { + current = Some((start, pos, count + 1)); + } + Some(cluster) => { + clusters.try_push(cluster)?; + current = Some((pos, pos, 1)); + } + None => current = Some((pos, pos, 1)), + } + scan_pos = pos + 1; + } + if let Some(cluster) = current { + clusters.try_push(cluster)?; + } + + clusters.retain(|&(_, _, count)| count >= 2); + let mut ranges = Buffer::new(allowance); + let mut span_count = 0; + let mut span: Option<(usize, usize, usize)> = None; + for &(start, last, count) in clusters.iter() { + match span { + Some((span_start, span_last, span_opcodes)) + if start.saturating_sub(span_last) <= AUTO_X86_SPAN_CLUSTER_GAP => + { + span = Some((span_start, last, span_opcodes + count)); + } + Some((span_start, span_last, span_opcodes)) => { + if span_opcodes >= AUTO_X86_MIN_SPAN_OPCODES + && span_count < AUTO_X86_MAX_SPAN_RANGES + { + push_range(&mut ranges, data.len(), span_start, span_last)?; + span_count += 1; + } + span = Some((start, last, count)); + } + None => span = Some((start, last, count)), + } + } + if let Some((span_start, span_last, span_opcodes)) = span { + if span_opcodes >= AUTO_X86_MIN_SPAN_OPCODES && span_count < AUTO_X86_MAX_SPAN_RANGES { + push_range(&mut ranges, data.len(), span_start, span_last)?; + } + } + + clusters.sort_unstable_by(|a, b| { + let a_len = a.1 - a.0 + 5; + let b_len = b.1 - b.0 + 5; + b.2.cmp(&a.2) + .then_with(|| a_len.cmp(&b_len)) + .then_with(|| a.0.cmp(&b.0)) + }); + clusters.truncate(AUTO_X86_MAX_RANGES); + + for (start, last, _) in clusters { + push_range(&mut ranges, data.len(), start, last)?; + } + Ok(ranges) +} + +fn push_range( + ranges: &mut Buffer, B>, + data_len: usize, + start: usize, + last: usize, +) -> Result<()> { + let range_start = start.saturating_sub(AUTO_X86_RANGE_PADDING); + let range_end = (last + 5 + AUTO_X86_RANGE_PADDING).min(data_len); + let range = range_start..range_end; + // Scanned clusters satisfy start <= last <= data_len - 5, so padding + // and clamping cannot turn their range into an empty one. + if !ranges.contains(&range) { + ranges.try_push(range)?; + } + Ok(()) +} + +#[cfg(test)] +fn push_x86_filter_range( + ranges: &mut Vec>, + data_len: usize, + start: usize, + last: usize, +) { + let range = start.saturating_sub(AUTO_X86_RANGE_PADDING) + ..(last + 5 + AUTO_X86_RANGE_PADDING).min(data_len); + if range.start < range.end && !ranges.contains(&range) { + ranges.push(range); + } +} +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn span_limit_keeps_first_four_disjoint_spans_and_best_clusters() { + let mut data = vec![0x90; 300_000]; + for span in 0..6 { + let start = span * 50_000; + for offset in [0, 1, 5_000, 5_001] { + data[start + offset] = 0xe8; + } + } + let mut expected = Vec::new(); + for span in 0..4usize { + let start = span * 50_000; + expected.push(start.saturating_sub(16)..start + 5_022); + } + for span in 0..4usize { + for offset in [0, 5_000] { + let start = span * 50_000 + offset; + expected.push(start.saturating_sub(16)..start + 22); + } + } + assert_eq!(auto_x86_filter_ranges(&data, true), expected); + assert_eq!(scalar_auto_x86_filter_ranges(&data, true), expected); + } + + #[test] + fn scanner_retains_sparse_clusters_without_emitting_a_sparse_span() { + let mut data = vec![0x90; 40_030]; + for pos in [0, 1, 40_000, 40_001, 40_002, 40_003] { + data[pos] = 0xe8; + } + let expected = vec![39_984..40_024, 0..22]; + assert_eq!(auto_x86_filter_ranges(&data, true), expected); + assert_eq!(scalar_auto_x86_filter_ranges(&data, true), expected); + assert!(auto_x86_filter_ranges(&vec![0x90; 40_030], true).is_empty()); + } + + #[test] + fn scanned_regions_in_members_large_enough_to_screen_are_never_short_samples() { + for len in 12..=64 { + for start in 0..len - 5 { + let mut data = vec![0; len]; + data[start] = 0xe8; + data[start + 1] = 0xe8; + for region in auto_x86_filter_ranges(&data, true) { + assert!(region.len() >= 12, "{len}, {start}, {region:?}"); + } + } + } + } + + fn scalar_auto_x86_filter_ranges(data: &[u8], include_e9: bool) -> Vec> { + let mut ranges = + scalar_auto_x86_filter_ranges_with_cluster_gap(data, include_e9, AUTO_X86_CLUSTER_GAP); + for range in scalar_auto_x86_filter_ranges_with_cluster_gap( + data, + include_e9, + AUTO_X86_TIGHT_CLUSTER_GAP, + ) { + if !ranges.contains(&range) { + ranges.push(range); + } + } + ranges + } + + fn scalar_auto_x86_filter_ranges_with_cluster_gap( + data: &[u8], + include_e9: bool, + cluster_gap: usize, + ) -> Vec> { + if data.len() <= 5 { + return Vec::new(); + } + + let cmp_mask = if include_e9 { 0xfe } else { 0xff }; + let mut clusters = Vec::new(); + let mut current: Option<(usize, usize, usize)> = None; + for (pos, &byte) in data.iter().take(data.len() - 4).enumerate() { + if byte & cmp_mask != 0xe8 { + continue; + } + + match current { + Some((start, last, count)) if pos - last <= cluster_gap => { + current = Some((start, pos, count + 1)); + } + Some(cluster) => { + clusters.push(cluster); + current = Some((pos, pos, 1)); + } + None => current = Some((pos, pos, 1)), + } + } + if let Some(cluster) = current { + clusters.push(cluster); + } + + clusters.retain(|&(_, _, count)| count >= 2); + let mut ranges = Vec::new(); + let mut span_count = 0; + let mut span: Option<(usize, usize, usize)> = None; + for &(start, last, count) in &clusters { + match span { + Some((span_start, span_last, span_opcodes)) + if start.saturating_sub(span_last) <= AUTO_X86_SPAN_CLUSTER_GAP => + { + span = Some((span_start, last, span_opcodes + count)); + } + Some((span_start, span_last, span_opcodes)) => { + if span_opcodes >= AUTO_X86_MIN_SPAN_OPCODES + && span_count < AUTO_X86_MAX_SPAN_RANGES + { + push_x86_filter_range(&mut ranges, data.len(), span_start, span_last); + span_count += 1; + } + span = Some((start, last, count)); + } + None => span = Some((start, last, count)), + } + } + if let Some((span_start, span_last, span_opcodes)) = span { + if span_opcodes >= AUTO_X86_MIN_SPAN_OPCODES && span_count < AUTO_X86_MAX_SPAN_RANGES { + push_x86_filter_range(&mut ranges, data.len(), span_start, span_last); + } + } + + clusters.sort_by(|a, b| { + let a_len = a.1 - a.0 + 5; + let b_len = b.1 - b.0 + 5; + b.2.cmp(&a.2).then_with(|| a_len.cmp(&b_len)) + }); + clusters.truncate(AUTO_X86_MAX_RANGES); + + for (start, last, _) in clusters { + push_x86_filter_range(&mut ranges, data.len(), start, last); + } + ranges + } + + #[test] + fn bounded_scanner_preserves_tied_clusters_and_releases_refused_growth() { + let mut data = vec![0x41; 500_000]; + for section in 0..40 { + let start = 1024 + section * 10_000; + for offset in [0, 32, 64, 96] { + data[start + offset] = 0xe8; + } + } + let expected = scalar_auto_x86_filter_ranges(&data, true); + let mut successes = 0; + let mut refusals = 0; + // Close limits distinguish tight-pass refusal while broad-pass ranges + // remain charged from refusal during the initial scan. + for limit in [0, 95, 128, 256, 512, 1024, 2048, 8192] + .into_iter() + .chain((2048..=3072).step_by(32)) + { + let allowance = Allowance::limited(limit); + match ranges_with_allowance(&data, true, &allowance) { + Ok(ranges) => { + successes += 1; + assert_eq!(&*ranges, expected); + assert!( + allowance.used() + >= (ranges.len() * std::mem::size_of::>()) as u64 + ); + drop(ranges); + } + Err(crate::codec::Error::WorkspaceLimitExceeded(_)) => refusals += 1, + Err(error) => panic!("{error}"), + } + assert_eq!(allowance.used(), 0); + } + assert!(successes > 0 && refusals >= 3); + } + + #[test] + fn returns_no_ranges_for_inputs_too_short_to_contain_a_call() { + for len in 0..=5 { + let data = vec![0xe8; len]; + assert!(auto_x86_filter_ranges(&data, false).is_empty()); + assert!(auto_x86_filter_ranges(&data, true).is_empty()); + } + } + + #[test] + fn auto_x86_filter_ranges_match_reference_scanner_at_chunk_boundaries() { + let mut data = vec![0x41u8; 150_000]; + for pos in [ + 31usize, 32, 33, 1024, 1088, 4096, 4160, 80_000, 80_032, 80_064, + ] { + data[pos] = 0xe8; + } + data[80_096] = 0xe9; + + assert_eq!( + auto_x86_filter_ranges(&data, false), + scalar_auto_x86_filter_ranges(&data, false) + ); + assert_eq!( + auto_x86_filter_ranges(&data, true), + scalar_auto_x86_filter_ranges(&data, true) + ); + } + + #[test] + fn drops_isolated_opcodes_that_never_form_a_cluster() { + let mut data = vec![0x41; 20_000]; + data[100] = 0xe8; + data[10_000] = 0xe8; + assert!(auto_x86_filter_ranges(&data, false).is_empty()); + } + + #[test] + fn clamps_padded_range_to_buffer_bounds_at_both_ends() { + let mut data = vec![0x41u8; 30]; + for pos in [0, 4, 8, 12] { + data[pos] = 0xe8; + } + + let ranges = auto_x86_filter_ranges(&data, false); + + assert_eq!(ranges, vec![0..30]); + } + + #[test] + fn does_not_duplicate_a_span_range_already_emitted_for_a_cluster() { + let mut data = vec![0x41u8; 20_000]; + for pos in [1024, 1050, 1090, 1130] { + data[pos] = 0xe8; + } + + let ranges = auto_x86_filter_ranges(&data, false); + + assert_eq!(ranges.len(), 1); + assert_eq!(ranges[0], 1008..1151); + } + + #[test] + fn includes_tighter_ranges_inside_sparse_code_spans() { + let mut data = vec![0x41u8; 8_000]; + for pos in [1024, 1088, 3600, 3664] { + data[pos] = 0xe8; + } + + let ranges = auto_x86_filter_ranges(&data, false); + + assert!( + ranges + .iter() + .any(|range| range.start <= 1024 && range.end > 3664 && range.len() > 2000), + "missing broad sparse-code span: {ranges:?}" + ); + assert!( + ranges.iter().any(|range| range.contains(&1024) + && range.contains(&1088) + && !range.contains(&3600)), + "missing first tight code cluster: {ranges:?}" + ); + assert!( + ranges.iter().any(|range| range.contains(&3600) + && range.contains(&3664) + && !range.contains(&1088)), + "missing second tight code cluster: {ranges:?}" + ); + } + + #[test] + fn keeps_more_disjoint_code_section_candidates() { + let mut data = vec![0x41u8; 700_000]; + for section in 0..8 { + let start = 16_384 + section * 80_000; + for index in 0..6 { + data[start + index * 64] = 0xe8; + } + } + + let ranges = auto_x86_filter_ranges(&data, false); + + for section in 0..8 { + let start = 16_384 + section * 80_000; + assert!( + ranges.iter().any(|range| range.contains(&start)), + "missing x86 section at {start}" + ); + } + } +} diff --git a/arca-rar/vendor/rars/tests/builder_directories.rs b/arca-rar/vendor/rars/tests/builder_directories.rs new file mode 100644 index 00000000..709074c8 --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_directories.rs @@ -0,0 +1,83 @@ +#![cfg(feature = "write")] + +use rars::{ArchiveReader, ArchiveVersion, Builder}; + +#[path = "support/scratch.rs"] +mod scratch; + +#[test] +fn explicit_directories_survive_all_rar5_writer_paths() { + let root = scratch::case("builder-directories"); + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for solid in [false, true] { + let mut builder = Builder::new(format).solid(solid); + builder + .add_directory(b"empty".to_vec(), Some(123), None) + .unwrap(); + builder + .add_directory(b"nested".to_vec(), Some(456), Some(0o750)) + .unwrap(); + builder + .set_mtime_nanoseconds(b"nested", 704_088_300) + .unwrap(); + builder + .add_bytes(b"nested/file".to_vec(), b"payload".repeat(20), None, None) + .unwrap(); + let path = root.join(format!("{format}-{solid}.rar")); + builder.write_to_path(&path, None).unwrap(); + let mut outputs = vec![builder.to_bytes().unwrap(), std::fs::read(path).unwrap()]; + outputs.extend(builder.volume_size(Some(4096)).build_volumes(None).unwrap()); + for bytes in outputs { + let archive = ArchiveReader::read_owned(bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members.len(), 3); + assert!(members[0].meta.is_directory); + assert_eq!(members[0].meta.file_attr, 0x10); + assert_eq!(members[0].meta.file_time, Some(123)); + assert!(members[1].meta.is_directory); + assert_eq!(members[1].meta.file_attr, 0o040750); + assert_eq!( + members[1].meta.mtime_refinement.unwrap().nanoseconds, + 704_088_300 + ); + assert!(!members[2].meta.is_directory); + assert_eq!( + archive.read_member(b"nested/file", None).unwrap().unwrap(), + b"payload".repeat(20) + ); + } + } + } +} + +#[test] +fn directory_validation_does_not_change_entry_kind_or_queued_names() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_directory(b"empty".to_vec(), None, None) + .unwrap(); + let before = builder.to_bytes().unwrap(); + assert!(builder.set_dos_attributes(b"empty", 0x20).is_err()); + assert!(builder + .add_directory(b"empty".to_vec(), None, None) + .is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + let mut legacy = Builder::new(ArchiveVersion::Rar15); + assert!(legacy + .add_directory(b"empty".to_vec(), None, Some(0o750)) + .is_err()); + assert!(legacy.is_empty()); +} + +#[test] +fn rar15_directory_uses_legacy_directory_attributes() { + let mut builder = Builder::new(ArchiveVersion::Rar15).store(true); + builder + .add_directory(b"empty".to_vec(), Some(123), None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let member = archive.members().next().unwrap(); + assert!(member.meta.is_directory); + assert_eq!(member.meta.file_attr, 0x10); + assert_eq!(member.meta.file_time, Some(123)); +} diff --git a/arca-rar/vendor/rars/tests/builder_file_comments.rs b/arca-rar/vendor/rars/tests/builder_file_comments.rs new file mode 100644 index 00000000..96ad06f4 --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_file_comments.rs @@ -0,0 +1,285 @@ +#![cfg(feature = "write")] + +use rars::{Archive, ArchiveReader, ArchiveVersion, Builder, ErrorKind}; + +#[test] +fn recovery_service_does_not_change_rar5_member_comments() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .recovery_percent(Some(5)); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"note".to_vec())) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let Archive::Rar50Plus(ref rar50) = archive else { + unreachable!() + }; + assert!(rar50.blocks.iter().any( + |block| matches!(block, rars::rar50::Block::Service(service) if service.name == b"RR") + )); + assert_eq!( + archive.member_comments(None).unwrap(), + vec![Some(b"note".to_vec())] + ); + assert_eq!(archive.member_comment_encryption(), [false]); +} + +#[test] +fn rar5_comment_before_first_file_belongs_to_archive() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"note".to_vec())) + .unwrap(); + let mut archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let Archive::Rar50Plus(ref mut rar50) = archive else { + unreachable!() + }; + assert!(matches!(rar50.blocks[0], rars::rar50::Block::File(_))); + assert!(matches!(rar50.blocks[1], rars::rar50::Block::Service(_))); + rar50.blocks.swap(0, 1); + + assert_eq!(archive.comment(None).unwrap(), Some(b"note".to_vec())); + assert_eq!(archive.member_comments(None).unwrap(), vec![None]); + assert_eq!(archive.member_comment_encryption(), [false]); + assert!(archive.rewrite_preservation_issues().is_empty()); +} + +#[test] +fn comments_follow_renames_and_round_trip_through_supported_writers() { + for version in [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, + ] { + for stored in [true, false] { + let mut builder = Builder::new(version).store(stored); + builder + .add_bytes(b"first".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .add_bytes(b"second".to_vec(), vec![], None, None) + .unwrap(); + builder + .set_file_comment(b"first", Some(b"note\xff".to_vec())) + .unwrap(); + builder.set_file_comment(b"second", Some(vec![])).unwrap(); + builder.rename(b"first", b"renamed".to_vec()).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.member_comments(None).unwrap(), + vec![Some(b"note\xff".to_vec()), Some(vec![])], + "{version:?}" + ); + assert_eq!( + archive.member_comment_at(0, None).unwrap(), + Some(b"note\xff".to_vec()) + ); + assert_eq!( + archive.read_member(b"renamed", None).unwrap().unwrap(), + b"payload" + ); + assert_eq!( + archive.member_comment_at(2, None).unwrap_err().kind(), + ErrorKind::EntryNotFound + ); + } + } +} + +#[test] +fn encrypted_headers_reject_incompatible_embedded_comments() { + for version in [ArchiveVersion::Rar30, ArchiveVersion::Rar40] { + let mut builder = Builder::new(version) + .password(Some(b"secret".to_vec())) + .header_encryption(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"note".to_vec())) + .unwrap(); + assert!(matches!( + builder.to_bytes(), + Err(rars::Error::UnsupportedWriterOption { + option: rars::write_plan::WriterOption::FileComment, + .. + }) + )); + builder.set_file_comment(b"file", None).unwrap(); + let builder = builder.header_encryption(false).password(None); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!(archive.member_comments(None).unwrap(), vec![None]); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } +} + +#[test] +fn volume_output_refuses_comments_even_when_configured_after_the_comment() { + for version in [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"note".to_vec())) + .unwrap(); + let mut builder = builder.volume_size(Some(4096)); + assert!(matches!( + builder.build_volumes(None), + Err(rars::Error::UnsupportedWriterOption { + option: rars::write_plan::WriterOption::FileComment, + .. + }) + )); + assert!(builder.set_file_comment(b"file", Some(vec![])).is_err()); + builder.set_file_comment(b"file", None).unwrap(); + assert!(!builder.build_volumes(None).unwrap().is_empty()); + } +} + +#[test] +fn rar5_file_comments_follow_output_encryption_and_can_be_removed() { + let mut builder = Builder::new(ArchiveVersion::Rar50).password(Some(b"secret".to_vec())); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"private note".to_vec())) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.member_comment_at(0, None).unwrap_err().kind(), + ErrorKind::PasswordRequired + ); + assert_eq!( + archive.member_comment_at(0, Some(b"secret")).unwrap(), + Some(b"private note".to_vec()) + ); + builder.set_file_comment(b"file", Some(vec![])).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.member_comment_at(0, Some(b"secret")).unwrap(), + Some(vec![]) + ); + builder.set_file_comment(b"file", None).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!(archive.member_comments(None).unwrap(), vec![None]); +} + +#[test] +fn preflight_accepts_attached_comments_but_rejects_duplicates_and_read_checks_integrity() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .comment(Some(b"archive".to_vec())); + builder.add_directory(b"dir".to_vec(), None, None).unwrap(); + builder + .set_file_comment(b"dir", Some(b"directory".to_vec())) + .unwrap(); + builder + .add_bytes(b"file".to_vec(), vec![], None, None) + .unwrap(); + builder + .set_file_comment(b"file", Some(b"file note".to_vec())) + .unwrap(); + let mut archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + assert_eq!( + archive.member_comments(None).unwrap(), + [Some(b"directory".to_vec()), Some(b"file note".to_vec())] + ); + let Archive::Rar50Plus(a) = &mut archive else { + unreachable!() + }; + let at = a + .blocks + .iter() + .rposition(|b| matches!(b, rars::rar50::Block::Service(_))) + .unwrap(); + let original = a.blocks[at].clone(); + if let rars::rar50::Block::Service(file) = &mut a.blocks[at] { + file.hash = None; + file.data_crc32 = Some(0); + } + assert_eq!( + archive.member_comment_at(1, None).unwrap_err().kind(), + ErrorKind::ChecksumMismatch + ); + let Archive::Rar50Plus(a) = &mut archive else { + unreachable!() + }; + a.blocks[at] = original.clone(); + a.blocks.insert(at, original); + assert!(!archive.rewrite_preservation_issues().is_empty()); + assert!(archive.member_comments(None).is_err()); + assert!(archive.member_comment_at(1, None).is_err()); +} + +#[test] +fn legacy_archive_comment_encryption_is_independent_of_member_passwords() { + for encrypted_headers in [false, true] { + let password = b"secret"; + let mut builder = Builder::new(ArchiveVersion::Rar40) + .password(Some(password.to_vec())) + .header_encryption(encrypted_headers) + .comment(Some(b"private comment".to_vec())) + .archive_comment_password(Some(password.to_vec())); + builder + .add_bytes(b"plain".to_vec(), b"public".to_vec(), None, None) + .unwrap(); + builder.set_entry_encryption(b"plain", None, None).unwrap(); + let source = ArchiveReader::read_owned_with_options( + builder.to_bytes().unwrap(), + rars::ArchiveReadOptions::with_password(password), + ) + .unwrap(); + assert_eq!( + source.comment(Some(password)).unwrap(), + Some(b"private comment".to_vec()) + ); + assert!(!source.members().next().unwrap().meta.is_encrypted); + assert!(source.rewrite_preservation_issues().is_empty()); + let mut editor = source + .preserving_builder(Some(password)) + .unwrap() + .comment(source.comment(Some(password)).unwrap()); + editor + .add_bytes(b"renamed".to_vec(), b"public".to_vec(), None, None) + .unwrap(); + editor.set_entry_encryption(b"renamed", None, None).unwrap(); + let output = ArchiveReader::read_owned_with_options( + editor.to_bytes().unwrap(), + rars::ArchiveReadOptions::with_password(password), + ) + .unwrap(); + assert_eq!( + output.comment(Some(password)).unwrap(), + Some(b"private comment".to_vec()) + ); + assert!(output.comment(None).is_err()); + assert!(!output.members().next().unwrap().meta.is_encrypted); + if let Archive::Rar15To40(archive) = output { + assert_eq!(archive.main.has_encrypted_headers(), encrypted_headers); + assert!(archive.new_subs().next().unwrap().file.is_encrypted()); + } else { + panic!("legacy output expected"); + } + } +} diff --git a/arca-rar/vendor/rars/tests/builder_identity.rs b/arca-rar/vendor/rars/tests/builder_identity.rs new file mode 100644 index 00000000..222aa79a --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_identity.rs @@ -0,0 +1,246 @@ +#![cfg(feature = "write")] + +use rars::{ArchiveReader, ArchiveVersion, Builder, EntrySource}; + +fn file_copy_member(name: &[u8], target: &[u8]) -> rars::ArchiveMember { + let mut seed = Builder::new(ArchiveVersion::Rar50).store(true); + seed.add_unix_symlink(name.to_vec(), target.to_vec(), false, None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(seed.to_bytes().unwrap()).unwrap(); + let mut copy = archive.members().next().unwrap(); + copy.meta.host_os = Some(0); + copy.meta.file_attr = 0x20; + copy.meta.unpacked_size = 7; + if let rars::ArchiveMemberDetail::Rar50Plus { + redirection: Some(link), + .. + } = &mut copy.detail + { + link.redirection_type = 5; + link.flags = 0; + } + copy +} + +#[test] +fn duplicate_payloads_and_metadata_follow_ids_in_every_family() { + for format in [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, + ] { + let mut builder = Builder::new(format).store(true).allow_duplicate_names(true); + builder + .add_bytes(b"same".to_vec(), b"first".to_vec(), None, None) + .unwrap(); + builder.add_directory(b"same".to_vec(), None, None).unwrap(); + builder + .add_bytes(b"same".to_vec(), b"second".to_vec(), None, None) + .unwrap(); + assert!(builder.remove(b"same").is_err()); + assert_eq!(builder.len(), 3); + builder.rename_by_id(2, b"second".to_vec()).unwrap(); + builder.remove_by_id(1).unwrap(); + builder.rename_by_id(0, b"first".to_vec()).unwrap(); + assert_eq!(builder.member_ids().collect::>(), [0, 2]); + assert!(builder.remove_by_id(1).is_err()); + let bytes = builder.to_bytes().unwrap(); + let archive = ArchiveReader::read_owned(bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members[0].meta.name, b"first"); + assert_eq!(members[1].meta.name, b"second"); + assert_eq!(archive.read_member_at(0, None).unwrap().unwrap(), b"first"); + assert_eq!(archive.read_member_at(1, None).unwrap().unwrap(), b"second"); + assert_eq!(members[0].meta.unpacked_size, 5); + assert_eq!(members[1].meta.unpacked_size, 6); + } +} + +#[test] +fn removing_a_duplicate_cannot_retarget_a_file_copy() { + let copy = file_copy_member(b"copy", b"same"); + + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .allow_duplicate_names(true); + builder + .add_source( + b"same".to_vec(), + EntrySource::from_bytes(b"payload".as_slice()), + None, + None, + ) + .unwrap(); + builder.add_archive_redirection(©).unwrap(); + builder + .add_bytes(b"same".to_vec(), b"another".to_vec(), None, None) + .unwrap(); + assert!(matches!( + builder.remove_by_id(0), + Err(rars::Error::InvalidArgument( + "removing this duplicate would retarget a hard link or file copy" + )) + )); + assert_eq!(builder.member_ids().collect::>(), [0, 1, 2]); + builder.remove_by_id(2).unwrap(); + let output = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(output.rewrite_preservation_issues().is_empty()); + assert_eq!(output.read_member_at(0, None).unwrap().unwrap(), b"payload"); + + let mut shadowed = Builder::new(ArchiveVersion::Rar50) + .store(true) + .allow_duplicate_names(true); + for data in [b"payload".as_slice(), b"another".as_slice()] { + shadowed + .add_bytes(b"same".to_vec(), data.to_vec(), None, None) + .unwrap(); + } + shadowed.add_archive_redirection(©).unwrap(); + shadowed.remove_by_id(0).unwrap(); + let output = ArchiveReader::read_owned(shadowed.to_bytes().unwrap()).unwrap(); + assert!(output.rewrite_preservation_issues().is_empty()); + assert_eq!(output.read_member_at(0, None).unwrap().unwrap(), b"another"); +} + +#[test] +fn removing_a_duplicate_ignores_directories_and_unrelated_copies() { + let copy = file_copy_member(b"copy", b"other"); + + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .allow_duplicate_names(true); + builder + .add_bytes(b"same".to_vec(), b"first".to_vec(), None, None) + .unwrap(); + builder.add_directory(b"same".to_vec(), None, None).unwrap(); + builder + .add_bytes(b"other".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.add_archive_redirection(©).unwrap(); + builder + .add_bytes(b"same".to_vec(), b"second".to_vec(), None, None) + .unwrap(); + + builder.remove_by_id(0).unwrap(); + let output = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let copy = output + .members() + .find(|member| member.meta.name == b"copy") + .unwrap(); + assert_eq!(copy.supported_redirection().unwrap().target_name, b"other"); + assert_eq!( + output.read_member(b"other", None).unwrap().unwrap(), + b"payload" + ); + assert_eq!( + output.read_member(b"same", None).unwrap().unwrap(), + b"second" + ); +} + +#[test] +fn renaming_a_duplicate_updates_only_copies_of_that_identity() { + let mut copy = file_copy_member(b"copy", b"same"); + + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .allow_duplicate_names(true); + builder + .add_bytes(b"same".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.add_archive_redirection(©).unwrap(); + builder + .add_bytes(b"same".to_vec(), b"another".to_vec(), None, None) + .unwrap(); + copy.meta.name = b"later-copy".to_vec(); + builder.add_archive_redirection(©).unwrap(); + builder + .add_bytes(b"other".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + copy.meta.name = b"other-copy".to_vec(); + if let rars::ArchiveMemberDetail::Rar50Plus { + redirection: Some(link), + .. + } = &mut copy.detail + { + link.target_name = b"other".to_vec(); + } + builder.add_archive_redirection(©).unwrap(); + + builder.rename_by_id(0, b"first".to_vec()).unwrap(); + let output = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + for (name, target) in [ + (b"copy".as_slice(), b"first".as_slice()), + (b"later-copy".as_slice(), b"same".as_slice()), + (b"other-copy".as_slice(), b"other".as_slice()), + ] { + let member = output + .members() + .find(|member| member.meta.name == name) + .unwrap(); + assert_eq!(member.supported_redirection().unwrap().target_name, target); + } +} + +#[test] +fn file_copy_validation_ignores_interleaved_unix_symlink() { + let copy = file_copy_member(b"copy", b"other"); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"other".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .add_unix_symlink(b"link".to_vec(), b"other".to_vec(), false, None, None) + .unwrap(); + builder.add_archive_redirection(©).unwrap(); + + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"other", None).unwrap().unwrap(), + b"payload" + ); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members[1].unix_symlink().unwrap().target_name, b"other"); + assert_eq!( + members[2].supported_redirection().unwrap().target_name, + b"other" + ); +} + +#[test] +fn removing_duplicate_does_not_treat_unix_symlink_as_file_copy() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .allow_duplicate_names(true); + builder + .add_bytes(b"same".to_vec(), b"first".to_vec(), None, None) + .unwrap(); + builder + .add_unix_symlink(b"link".to_vec(), b"same".to_vec(), false, None, None) + .unwrap(); + builder + .add_bytes(b"same".to_vec(), b"second".to_vec(), None, None) + .unwrap(); + + builder.remove_by_id(0).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive + .members() + .next() + .unwrap() + .unix_symlink() + .unwrap() + .target_name, + b"same" + ); + assert_eq!( + archive.read_member(b"same", None).unwrap().unwrap(), + b"second" + ); +} diff --git a/arca-rar/vendor/rars/tests/builder_metadata.rs b/arca-rar/vendor/rars/tests/builder_metadata.rs new file mode 100644 index 00000000..880520e3 --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_metadata.rs @@ -0,0 +1,263 @@ +#![cfg(feature = "write")] + +#[path = "support/scratch.rs"] +mod scratch; + +use rars::{ArchiveFamily, ArchiveReader, ArchiveVersion, Builder}; + +const MODES: [Option; 4] = [None, Some(0o640), Some(0o100750), Some(0)]; + +#[test] +fn rar5_archive_metadata_settings_refuse_volume_output() { + for (locked, quick_open) in [(true, false), (false, true)] { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .archive_metadata(None, locked, quick_open) + .unwrap() + .volume_size(Some(4096)); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert!(builder.to_bytes().is_err()); + assert!(builder.build_volumes(None).is_err()); + } +} + +#[test] +fn builder_preserves_explicit_dos_attributes_in_all_writer_paths() { + let flags = [0, 1, 2, 4, 0x20, 0x27, 0x80]; + let root = scratch::case("builder-dos-attributes"); + for format in ArchiveVersion::ALL { + for store in [false, true] { + let mut builder = Builder::new(format).store(store); + for (index, attr) in flags.iter().enumerate() { + let name = format!("file{index}").into_bytes(); + builder + .add_source( + name.clone(), + rars::EntrySource::from_bytes(b"DOS payload".to_vec()), + None, + Some(0o640), + ) + .unwrap(); + builder.set_dos_attributes(&name, *attr).unwrap(); + } + let path = root.join(format!("{format}-{store}.rar")); + builder.write_to_path(&path, None).unwrap(); + let mut outputs = vec![builder.to_bytes().unwrap(), std::fs::read(path).unwrap()]; + if format.family() == ArchiveFamily::Rar50Plus { + outputs.extend(builder.volume_size(Some(4096)).build_volumes(None).unwrap()); + } + for bytes in outputs { + let archive = ArchiveReader::read_owned(bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members.len(), flags.len()); + for (member, attr) in members.iter().zip(flags) { + assert_eq!(member.meta.attr_source(), rars::AttrSource::Dos); + assert_eq!(member.meta.file_attr, attr, "{format}, store={store}"); + assert!(!member.meta.is_directory); + assert_eq!( + archive + .read_member(&member.meta.name, None) + .unwrap() + .unwrap(), + b"DOS payload" + ); + } + } + } + } +} + +#[test] +fn invalid_dos_attributes_leave_builder_metadata_unchanged() { + for (format, oversized) in [ + (ArchiveVersion::Rar14, Some(256)), + (ArchiveVersion::Rar29, Some(u64::from(u32::MAX) + 1)), + (ArchiveVersion::Rar50, None), + ] { + let mut builder = builder(format, true); + let before = builder.to_bytes().unwrap(); + assert!(builder.set_dos_attributes(b"missing", 0x20).is_err()); + assert!(builder.set_dos_attributes(b"file1", 0x10).is_err()); + if let Some(oversized) = oversized { + assert!(builder.set_dos_attributes(b"file1", oversized).is_err()); + } + assert_eq!(builder.to_bytes().unwrap(), before); + } +} + +#[test] +fn dos_attribute_field_width_is_not_truncated() { + for (format, attr) in [ + (ArchiveVersion::Rar14, 0xef), + (ArchiveVersion::Rar29, u64::from(u32::MAX) & !0x10), + (ArchiveVersion::Rar50, !0x10u64), + ] { + let mut builder = builder(format, true); + builder.set_dos_attributes(b"file1", attr).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!(archive.members().nth(1).unwrap().meta.file_attr, attr); + } +} + +#[test] +fn member_attribute_source_uses_family_specific_host_rules() { + use rars::AttrSource::{Dos, Unix, Unknown}; + + let archive = + ArchiveReader::read_owned(builder(ArchiveVersion::Rar50, true).to_bytes().unwrap()) + .unwrap(); + let mut meta = archive.members().next().unwrap().meta; + for (family, host, expected) in [ + (ArchiveFamily::Rar13, None, Dos), + (ArchiveFamily::Rar15To40, Some(0), Dos), + (ArchiveFamily::Rar15To40, Some(1), Dos), + (ArchiveFamily::Rar15To40, Some(2), Dos), + (ArchiveFamily::Rar15To40, Some(3), Unix), + (ArchiveFamily::Rar15To40, Some(4), Dos), + (ArchiveFamily::Rar15To40, Some(5), Unix), + (ArchiveFamily::Rar15To40, Some(6), Unknown), + (ArchiveFamily::Rar15To40, Some(259), Unknown), + (ArchiveFamily::Rar15To40, None, Unknown), + (ArchiveFamily::Rar50Plus, Some(0), Dos), + (ArchiveFamily::Rar50Plus, Some(1), Unix), + (ArchiveFamily::Rar50Plus, Some(2), Unknown), + (ArchiveFamily::Rar50Plus, None, Unknown), + ] { + meta.family = family; + meta.host_os = host; + assert_eq!(meta.attr_source(), expected, "{family:?}, {host:?}"); + } +} + +fn builder(format: ArchiveVersion, store: bool) -> Builder { + let mut builder = Builder::new(format).store(store); + for (index, mode) in MODES.into_iter().enumerate() { + builder + .add_bytes( + format!("file{index}").into_bytes(), + b"payload".repeat(64), + None, + mode, + ) + .unwrap(); + } + builder +} + +fn check_metadata(bytes: Vec, format: ArchiveVersion) { + let archive = ArchiveReader::read_owned(bytes).unwrap(); + let members: Vec<_> = archive.members().collect(); + assert_eq!(members.len(), MODES.len()); + for (member, mode) in members.iter().zip(MODES) { + // RAR 1.5 deliberately converts Unix metadata to DOS for compatibility. + let mode = if format == ArchiveVersion::Rar15 { + None + } else { + mode + }; + let (host, attr) = match mode { + None => (0, 0x20), + Some(mode) => ( + if format.family() == ArchiveFamily::Rar50Plus { + 1 + } else { + 3 + }, + u64::from(mode | 0o100000), + ), + }; + assert_eq!(member.meta.host_os, Some(host)); + assert_eq!(member.meta.file_attr, attr); + assert_eq!( + archive + .read_member(&member.meta.name, None) + .unwrap() + .unwrap(), + b"payload".repeat(64) + ); + } +} + +#[test] +fn builder_pairs_host_ids_with_dos_or_unix_attributes() { + for format in ArchiveVersion::ALL { + if format.family() == ArchiveFamily::Rar13 { + continue; // This family has no host field or Unix modes. + } + for store in [true, false] { + check_metadata(builder(format, store).to_bytes().unwrap(), format); + } + } +} + +#[test] +fn builder_volume_metadata_matches_single_archive_metadata() { + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for store in [true, false] { + let volumes = builder(format, store) + .volume_size(Some(4096)) + .build_volumes(None) + .unwrap(); + assert_eq!(volumes.len(), 1); + check_metadata(volumes.into_iter().next().unwrap(), format); + } + } +} + +#[cfg(unix)] +#[test] +#[ignore = "requires the external unrar executable"] +fn reference_unrar_restores_builder_permissions() { + use std::fs; + use std::os::unix::fs::PermissionsExt; + use std::process::Command; + + let root = scratch::case("builder-host-attributes"); + let control = root.join("default-permissions"); + fs::write(&control, b"control").unwrap(); + let default_mode = fs::metadata(control).unwrap().permissions().mode() & 0o777; + for format in [ + ArchiveVersion::Rar15, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, + ] { + for store in [true, false] { + let archive = root.join(format!("{format}-{store}.rar")); + let output = root.join(format!("{format}-{store}")); + fs::create_dir(&output).unwrap(); + builder(format, store) + .write_to_path(&archive, None) + .unwrap(); + let result = Command::new("unrar") + .args(["x", "-idq", "-o+"]) + .arg(&archive) + .arg(format!("{}/", output.display())) + .output() + .unwrap(); + assert!( + result.status.success(), + "{format}: {} {}", + String::from_utf8_lossy(&result.stdout), + String::from_utf8_lossy(&result.stderr) + ); + for (index, expected) in [default_mode, 0o640, 0o750, 0].into_iter().enumerate() { + let expected = if format == ArchiveVersion::Rar15 { + default_mode + } else { + expected + }; + let path = output.join(format!("file{index}")); + assert_eq!( + fs::metadata(&path).unwrap().permissions().mode() & 0o777, + expected, + "{format}, store={store}, file{index}" + ); + fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).unwrap(); + assert_eq!(fs::read(&path).unwrap(), b"payload".repeat(64)); + } + } + } +} diff --git a/arca-rar/vendor/rars/tests/builder_output.rs b/arca-rar/vendor/rars/tests/builder_output.rs new file mode 100644 index 00000000..a04498fc --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_output.rs @@ -0,0 +1,511 @@ +#![cfg(feature = "write")] + +#[path = "support/scratch.rs"] +mod scratch; + +use rars::{entry_relative_path, ArchiveReader, ArchiveVersion, Builder, EntrySource}; +use std::fs; + +#[test] +fn empty_rar50_builder_writes_a_readable_archive() { + let archive = + ArchiveReader::read_owned(Builder::new(ArchiveVersion::Rar50).to_bytes().unwrap()).unwrap(); + assert_eq!(archive.members().count(), 0); +} + +#[test] +fn empty_legacy_builder_refuses_single_archive_output() { + assert_eq!( + Builder::new(ArchiveVersion::Rar29).to_bytes().unwrap_err(), + rars::Error::InvalidArgument("archive builder has no entries") + ); +} + +#[test] +fn legacy_volume_builder_refuses_existing_directories_and_symlinks() { + let mut directory = Builder::new(ArchiveVersion::Rar29); + directory + .add_directory(b"dir".to_vec(), None, None) + .unwrap(); + assert_eq!( + directory + .volume_size(Some(64)) + .build_volumes(None) + .unwrap_err(), + rars::Error::InvalidArgument( + "legacy directories and symbolic links are unsupported in volume output" + ) + ); + + let mut symlink = Builder::new(ArchiveVersion::Rar29); + symlink + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + assert_eq!( + symlink + .volume_size(Some(64)) + .build_volumes(None) + .unwrap_err(), + rars::Error::InvalidArgument( + "legacy directories and symbolic links are unsupported in volume output" + ) + ); +} + +#[test] +fn legacy_volumes_accept_regular_unix_mode_files() { + for version in [ + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar40, + ] { + let mut builder = Builder::new(version).store(true).volume_size(Some(64)); + builder + .add_bytes(b"file".to_vec(), vec![42; 128], None, Some(0o100640)) + .unwrap(); + let volumes = builder.build_volumes(None).unwrap(); + assert!(volumes.len() > 1, "{version:?}"); + let first = ArchiveReader::read_owned(volumes[0].clone()).unwrap(); + let member = first.members().next().unwrap(); + assert_eq!(member.meta.attr_source(), rars::AttrSource::Unix); + assert_eq!(member.meta.file_attr & 0o170777, 0o100640); + } +} + +#[test] +fn single_output_rejects_volume_metadata_before_opening_a_source() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .archive_metadata(None, true, false) + .unwrap() + .volume_size(Some(64)); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(1, || panic!("single-output refusal opened source")), + None, + None, + ) + .unwrap(); + assert_eq!( + builder.to_bytes().unwrap_err(), + rars::Error::InvalidArgument( + "archive metadata settings require the RAR5/7 streaming writer" + ) + ); +} + +#[test] +fn path_output_reports_missing_parent_without_creating_an_archive() { + let root = scratch::case("builder-missing-parent"); + let destination = root.join("missing").join("archive.rar"); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert_eq!( + builder + .write_to_path(&destination, None) + .unwrap_err() + .kind(), + rars::ErrorKind::Io + ); + assert!(!destination.exists()); + assert_eq!(fs::read_dir(&root).unwrap().count(), 0); +} + +#[test] +fn volume_builder_refuses_quick_open_before_source_io() { + let source = || EntrySource::from_opener(1, || panic!("volume setting opened source")); + let mut builder = Builder::new(ArchiveVersion::Rar50) + .archive_metadata(None, false, true) + .unwrap() + .volume_size(Some(64)); + builder + .add_source(b"file".to_vec(), source(), None, None) + .unwrap(); + assert_eq!( + builder.build_volumes(None).unwrap_err(), + rars::Error::InvalidArgument( + "archive metadata settings are not supported in volume output" + ) + ); +} + +#[test] +fn legacy_entry_paths_keep_relative_components_and_reject_escape() { + assert_eq!( + entry_relative_path(b"folder\\subdir/file.txt").unwrap(), + std::path::Path::new("folder/subdir/file.txt") + ); + assert_eq!( + entry_relative_path(b"./file.txt").unwrap(), + std::path::Path::new("file.txt") + ); + for name in [ + b"../escape".as_slice(), + b"/absolute", + b"folder/../../escape", + b"", + b".", + ] { + assert!(entry_relative_path(name).is_err(), "{name:?}"); + } +} + +#[cfg(unix)] +#[test] +fn legacy_entry_paths_preserve_non_utf8_bytes_on_unix() { + use std::os::unix::ffi::OsStrExt; + + let path = entry_relative_path(b"folder/\xff.bin").unwrap(); + assert_eq!(path.as_os_str().as_bytes(), b"folder/\xff.bin"); +} + +#[test] +fn resource_aware_byte_output_matches_the_standard_builder_path() { + for version in [ArchiveVersion::Rar29, ArchiveVersion::Rar50] { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let expected = builder.to_bytes().unwrap(); + let actual = builder + .to_bytes_with_resources(&rars::WriterResources::default(), None) + .unwrap(); + assert_eq!(actual, expected, "{version:?}"); + let archive = ArchiveReader::read_owned(actual).unwrap(); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } +} + +#[test] +fn header_encryption_uses_a_shared_entry_password_without_a_builder_default() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .header_encryption(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .set_entry_encryption(b"file", Some(b"secret".to_vec()), None) + .unwrap(); + let archive = ArchiveReader::read_owned_with_options( + builder.to_bytes().unwrap(), + rars::ArchiveReadOptions::with_password(b"secret"), + ) + .unwrap(); + assert_eq!( + archive + .read_member(b"file", Some(b"secret")) + .unwrap() + .unwrap(), + b"payload" + ); +} + +#[test] +fn missing_header_password_fails_before_reading_a_source() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .header_encryption(true); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(7, || panic!("password error must precede source I/O")), + None, + None, + ) + .unwrap(); + assert_eq!(builder.to_bytes().unwrap_err(), rars::Error::NeedPassword); + let mut output = Vec::new(); + assert_eq!( + builder + .write_to(&mut output, &rars::WriterResources::default(), None) + .unwrap_err(), + rars::Error::NeedPassword + ); + assert!(output.is_empty()); +} + +#[test] +fn failed_builder_writes_preserve_the_destination_and_remove_staging_files() { + for existing in [false, true] { + let root = scratch::case("builder-failed-write"); + let destination = root.join("archive.rar"); + if existing { + fs::write(&destination, b"previous archive").unwrap(); + } + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(10, || { + Err(std::io::Error::other("injected source failure").into()) + }), + None, + None, + ) + .unwrap(); + assert!(builder.write_to_path(&destination, None).is_err()); + if existing { + assert_eq!(fs::read(&destination).unwrap(), b"previous archive"); + } else { + assert!(!destination.exists()); + } + assert_eq!(fs::read_dir(&root).unwrap().count(), usize::from(existing)); + } +} + +#[test] +fn builder_publishes_successful_writes_and_cleans_up_failed_renames() { + let root = scratch::case("builder-publish"); + let destination = root.join("archive.rar"); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + fs::write(&destination, b"previous archive").unwrap(); + builder.write_to_path(&destination, None).unwrap(); + let archive = ArchiveReader::read_owned(fs::read(&destination).unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + assert_eq!(fs::read_dir(&root).unwrap().count(), 1); + + fs::remove_file(&destination).unwrap(); + fs::create_dir(&destination).unwrap(); + assert!(builder.write_to_path(&destination, None).is_err()); + assert!(destination.is_dir()); + assert_eq!(fs::read_dir(&root).unwrap().count(), 1); +} + +#[test] +fn legacy_recovery_requests_fail_before_reading_sources_or_writing_output() { + for version in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar14, + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ] { + for percent in [0, 10] { + let mut builder = Builder::new(version).recovery_percent(Some(percent)); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(7, || { + panic!("unsupported recovery request must be rejected before opening input") + }), + None, + None, + ) + .unwrap(); + assert_eq!( + builder.to_bytes().unwrap_err().kind(), + rars::ErrorKind::UnsupportedFeature + ); + let mut output = Vec::new(); + assert_eq!( + builder + .write_to(&mut output, &rars::WriterResources::default(), None) + .unwrap_err() + .kind(), + rars::ErrorKind::UnsupportedFeature + ); + assert!(output.is_empty()); + assert_eq!( + builder + .volume_size(Some(1024)) + .build_volumes(None) + .unwrap_err() + .kind(), + rars::ErrorKind::UnsupportedFeature + ); + } + } +} + +#[test] +fn volume_builder_rejects_unsupported_settings_before_opening_sources() { + let source = || { + EntrySource::from_opener(7, || { + panic!("volume preflight must not open the member source") + }) + }; + + let mut commented = Builder::new(ArchiveVersion::Rar50) + .comment(Some(b"comment".to_vec())) + .volume_size(Some(1024)); + commented + .add_source(b"file".to_vec(), source(), None, None) + .unwrap(); + assert!(matches!( + commented.build_volumes(None), + Err(rars::Error::InvalidArgument( + "RAR 5 volume comments are not supported" + )) + )); + + let mut locked = Builder::new(ArchiveVersion::Rar50) + .archive_metadata(None, true, false) + .unwrap() + .volume_size(Some(1024)); + locked + .add_source(b"file".to_vec(), source(), None, None) + .unwrap(); + assert!(matches!( + locked.build_volumes(None), + Err(rars::Error::InvalidArgument( + "archive metadata settings are not supported in volume output" + )) + )); + + let mut directory = Builder::new(ArchiveVersion::Rar20); + directory + .add_directory(b"directory".to_vec(), None, None) + .unwrap(); + directory + .add_source(b"file".to_vec(), source(), None, None) + .unwrap(); + assert!(matches!( + directory.volume_size(Some(1024)).build_volumes(None), + Err(rars::Error::InvalidArgument( + "legacy directories and symbolic links are unsupported in volume output" + )) + )); + + let empty = Builder::new(ArchiveVersion::Rar20).volume_size(Some(1024)); + assert!(matches!( + empty.build_volumes(None), + Err(rars::Error::InvalidArgument( + "archive builder has no entries" + )) + )); + + let mut multiple = Builder::new(ArchiveVersion::Rar20) + .store(true) + .volume_size(Some(1024)); + for name in [b"first".as_slice(), b"second".as_slice()] { + multiple + .add_bytes(name.to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + } + assert!(matches!( + multiple.build_volumes(None), + Err(rars::Error::InvalidArgument( + "legacy volumes support one input" + )) + )); +} + +#[test] +fn legacy_builder_rejects_modern_streaming_outputs_before_creating_files() { + let mut builder = Builder::new(ArchiveVersion::Rar20).store(true); + builder + .add_source( + b"file".to_vec(), + EntrySource::from_opener(7, || panic!("unsupported output must not open the source")), + None, + None, + ) + .unwrap(); + let resources = rars::WriterResources::default(); + assert!(matches!( + builder.to_volume_output(&resources, None), + Err(rars::Error::UnsupportedFamilyFeature { + feature: "streaming managed volume output", + .. + }) + )); + let mut sink = rars::rar50::CollectedVolumes::new(); + assert!(matches!( + builder.write_volumes_to(&mut sink, &resources, None), + Err(rars::Error::UnsupportedFamilyFeature { + feature: "streaming managed volume output", + .. + }) + )); + assert!(sink.take().is_empty()); + + let root = scratch::case("builder-legacy-memory-quota"); + let destination = root.join("archive.rar"); + let limited = resources.with_max_memory_bytes(1024); + assert!(matches!( + builder.write_to_path_with_resources(&destination, &limited, None), + Err(rars::Error::UnsupportedFamilyFeature { + feature: "aggregate managed memory quota", + .. + }) + )); + assert!(!destination.exists()); +} + +#[test] +fn legacy_builder_materializes_reopenable_sources_once() { + use std::sync::atomic::{AtomicUsize, Ordering}; + use std::sync::Arc; + + let payload = b"legacy source materialization ".repeat(32); + for version in [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ] { + let opens = Arc::new(AtomicUsize::new(0)); + let opened = opens.clone(); + let data = payload.clone(); + let mut builder = Builder::new(version).store(false); + builder + .add_source( + b"source".to_vec(), + EntrySource::from_opener(payload.len() as u64, move || { + opened.fetch_add(1, Ordering::SeqCst); + Ok(Box::new(std::io::Cursor::new(data.clone()))) + }), + None, + None, + ) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.read_member(b"source", None).unwrap().unwrap(), + payload + ); + assert_eq!(opens.load(Ordering::SeqCst), 1, "{version:?}"); + } +} + +#[cfg(unix)] +#[test] +fn add_path_refuses_symlinks_without_following_them() { + use std::os::unix::fs::symlink; + + let root = scratch::case("builder-input-symlink"); + let target = root.join("target"); + let link = root.join("link"); + fs::write(&target, b"private payload").unwrap(); + symlink(&target, &link).unwrap(); + let mut builder = Builder::new(ArchiveVersion::Rar50); + let error = builder.add_path(&link, b"member").unwrap_err(); + assert_eq!(error.entry_context(), Some((&b"member"[..], "adding"))); + assert_eq!(error.kind(), rars::ErrorKind::InvalidArgument); + assert!(builder.is_empty()); +} + +#[cfg(unix)] +#[test] +fn add_path_refuses_special_files_instead_of_silently_omitting_them() { + let mut builder = Builder::new(ArchiveVersion::Rar50); + let error = builder + .add_path(std::path::Path::new("/dev/null"), b"member") + .unwrap_err(); + assert_eq!(error.entry_context(), Some((&b"member"[..], "adding"))); + assert_eq!(error.kind(), rars::ErrorKind::InvalidArgument); + assert!(builder.is_empty()); +} diff --git a/arca-rar/vendor/rars/tests/builder_symlinks.rs b/arca-rar/vendor/rars/tests/builder_symlinks.rs new file mode 100644 index 00000000..2bb078a8 --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_symlinks.rs @@ -0,0 +1,460 @@ +#![cfg(feature = "write")] + +use rars::{ArchiveReader, ArchiveVersion, Builder}; + +#[test] +fn unix_symlinks_round_trip_without_resolving_targets() { + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for stored in [false, true] { + let mut builder = Builder::new(format).store(stored); + builder + .add_unix_symlink( + b"link".to_vec(), + b"../missing".to_vec(), + false, + Some(123), + Some(0o750), + ) + .unwrap(); + builder + .set_file_comment(b"link", Some(b"note".to_vec())) + .unwrap(); + builder + .add_unix_symlink( + b"directory-link".to_vec(), + b"missing-dir".to_vec(), + true, + None, + None, + ) + .unwrap(); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.rename(b"link", b"renamed".to_vec()).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.rewrite_preservation_issues().is_empty()); + let members: Vec<_> = archive.members().collect(); + assert_eq!( + members[0].unix_symlink().unwrap().target_name, + b"../missing" + ); + assert_eq!(members[0].meta.file_attr, 0o120750); + assert_eq!(members[0].meta.file_time, Some(123)); + assert_eq!(members[1].unix_symlink().unwrap().flags, 1); + assert!(!members[1].meta.is_directory); + assert_eq!(archive.read_member_at(0, None).unwrap(), None); + assert_eq!( + archive.read_member_at(2, None).unwrap().unwrap(), + b"payload" + ); + assert_eq!( + archive.member_comment_at(0, None).unwrap(), + Some(b"note".to_vec()) + ); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } + } +} + +#[test] +fn archive_redirection_retains_unix_symlink_attributes() { + let mut seed = Builder::new(ArchiveVersion::Rar50).store(true); + seed.add_unix_symlink( + b"link".to_vec(), + b"missing".to_vec(), + false, + Some(123), + Some(0o750), + ) + .unwrap(); + let source = ArchiveReader::read_owned(seed.to_bytes().unwrap()).unwrap(); + let member = source.members().next().unwrap(); + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder.add_archive_redirection(&member).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let link = archive.members().next().unwrap(); + assert_eq!(link.unix_symlink().unwrap().target_name, b"missing"); + assert_eq!(link.meta.host_os, Some(1)); + assert_eq!(link.meta.file_attr, 0o120750); + assert_eq!(link.meta.file_time, Some(123)); +} + +#[test] +fn unsupported_link_options_leave_entries_unchanged() { + let mut builder = Builder::new(ArchiveVersion::Rar50); + for target in [b"".as_slice(), b"bad\0target", b"\xff"] { + assert!(builder + .add_unix_symlink(b"link".to_vec(), target.to_vec(), false, None, None) + .is_err()); + assert!(builder.is_empty()); + } + builder + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + assert!(builder.set_dos_attributes(b"link", 0x20).is_err()); + assert!(builder.volume_size(Some(4096)).build_volumes(None).is_err()); + let mut volume = Builder::new(ArchiveVersion::Rar50).volume_size(Some(4096)); + assert!(volume + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .is_err()); + assert!(volume.is_empty()); + let mut legacy = Builder::new(ArchiveVersion::Rar15); + assert!(legacy + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .is_err()); + assert!(legacy.is_empty()); +} + +#[test] +fn preflight_rejects_unsupported_redirections_and_inconsistent_link_headers() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + let original = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + for damage in 0..6 { + let mut archive = original.clone(); + let rars::Archive::Rar50Plus(a) = &mut archive else { + unreachable!() + }; + let file = a + .blocks + .iter_mut() + .find_map(|block| match block { + rars::rar50::Block::File(file) => Some(file), + _ => None, + }) + .unwrap(); + match damage { + 0 => file.redirection.as_mut().unwrap().redirection_type = 4, + 1 => file.redirection.as_mut().unwrap().flags = 2, + 2 => file.host_os = 0, + 3 => file.attributes = 0o100644, + 4 => file.unpacked_size = 1, + _ => file.file_flags |= 1, + } + assert!(archive.members().next().unwrap().unix_symlink().is_none()); + assert!(!archive.rewrite_preservation_issues().is_empty()); + } +} + +#[test] +fn zero_size_rar5_unix_link_header_preserves_its_target() { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + let mut source = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let rars::Archive::Rar50Plus(archive) = &mut source else { + unreachable!() + }; + let file = archive + .blocks + .iter_mut() + .find_map(|block| match block { + rars::rar50::Block::File(file) => Some(file), + _ => None, + }) + .unwrap(); + file.unpacked_size = 0; + + let member = source.members().next().unwrap(); + assert_eq!(member.unix_symlink().unwrap().target_name, b"target"); + assert!(source.rewrite_preservation_issues().is_empty()); + let mut rewritten = source.preserving_builder(None).unwrap(); + rewritten.add_archive_redirection(&member).unwrap(); + let output = ArchiveReader::read_owned(rewritten.to_bytes().unwrap()).unwrap(); + assert_eq!( + output + .members() + .next() + .unwrap() + .unix_symlink() + .unwrap() + .target_name, + b"target" + ); +} + +#[test] +fn links_survive_solid_and_encrypted_output_and_unix_byte_mapping() { + for solid in [false, true] { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .solid(solid) + .password(Some(b"secret".to_vec())); + let target = rars::filename::encode_rar50(b"native-\xff").into_owned(); + builder + .add_unix_symlink(b"link".to_vec(), target.clone(), false, None, None) + .unwrap(); + builder + .add_bytes(b"file".to_vec(), b"payload".repeat(100), None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let member = archive.members().next().unwrap(); + assert_eq!(member.unix_symlink().unwrap().target_name, target); + assert_eq!(member.meta.unpacked_size, 8); + assert_eq!( + archive.read_member_at(1, Some(b"secret")).unwrap().unwrap(), + b"payload".repeat(100) + ); + } +} + +#[test] +fn retains_windows_links_and_file_copy_records() { + let mut seed = Builder::new(ArchiveVersion::Rar50).store(true); + seed.add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + let seed = ArchiveReader::read_owned(seed.to_bytes().unwrap()) + .unwrap() + .members() + .next() + .unwrap(); + for kind in [2, 3, 4, 5] { + let mut member = seed.clone(); + member.meta.host_os = Some(0); + member.meta.is_directory = kind == 3; + member.meta.file_attr = match kind { + 2 => 0x400, + 3 => 0x410, + _ => 0x20, + }; + member.meta.unpacked_size = if kind >= 4 { 7 } else { 0 }; + if let rars::ArchiveMemberDetail::Rar50Plus { + redirection: Some(link), + .. + } = &mut member.detail + { + link.redirection_type = kind; + link.flags = u64::from(kind == 3); + } + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"target".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.add_archive_redirection(&member).unwrap(); + let output = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!( + output.rewrite_preservation_issues().is_empty(), + "{kind}: {:?}", + output.rewrite_preservation_issues() + ); + let actual = output.members().nth(1).unwrap(); + assert_eq!( + actual.supported_redirection(), + member.supported_redirection() + ); + assert_eq!(actual.meta.unpacked_size, member.meta.unpacked_size); + assert_eq!(actual.meta.file_attr, member.meta.file_attr); + if kind >= 4 { + let mut broken = output.clone(); + if let rars::Archive::Rar50Plus(archive) = &mut broken { + if let rars::rar50::Block::File(file) = &mut archive.blocks[1] { + file.redirection.as_mut().unwrap().target_name = b"missing".to_vec(); + } + } + assert!( + broken + .rewrite_preservation_issues() + .iter() + .any(|issue| issue + .contains("missing, forward or inconsistent redirection target")) + ); + builder.rename(b"target", b"renamed".to_vec()).unwrap(); + let output = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + output + .members() + .nth(1) + .unwrap() + .supported_redirection() + .unwrap() + .target_name, + b"renamed" + ); + builder.remove(b"renamed").unwrap(); + assert!(builder.to_bytes().is_err()); + } + } +} + +#[test] +fn link_setters_refuse_shapes_the_target_format_cannot_write() { + for (volume, directory_target, target) in [ + (true, false, b"target".as_slice()), + (false, true, b"target".as_slice()), + (false, false, b"".as_slice()), + (false, false, b"bad\0target".as_slice()), + ] { + let mut builder = Builder::new(ArchiveVersion::Rar20).volume_size(volume.then_some(1024)); + assert!(builder + .add_unix_symlink( + b"link".to_vec(), + target.to_vec(), + directory_target, + None, + None, + ) + .is_err()); + assert!(builder.is_empty()); + } + + let mut seed = Builder::new(ArchiveVersion::Rar50).store(true); + seed.add_unix_symlink(b"link".to_vec(), b"target".to_vec(), false, None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(seed.to_bytes().unwrap()).unwrap(); + let member = archive.members().next().unwrap(); + for format in [ArchiveVersion::Rar20, ArchiveVersion::Rar50] { + let mut builder = + Builder::new(format).volume_size((format == ArchiveVersion::Rar50).then_some(1024)); + assert!(builder.add_archive_redirection(&member).is_err()); + assert!(builder.is_empty()); + } +} + +#[test] +fn legacy_link_payloads_are_decoded_with_integrity_and_password_checks() { + for format in [ArchiveVersion::Rar29, ArchiveVersion::Rar40] { + let mut builder = Builder::new(format).password(Some(b"secret".to_vec())); + builder + .add_bytes( + b"link".to_vec(), + b"missing-\xff".to_vec(), + None, + Some(0o120750), + ) + .unwrap(); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, Some(0o100644)) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive.legacy_symlink_targets(None).is_err()); + assert_eq!( + archive.legacy_symlink_targets(Some(b"secret")).unwrap(), + vec![Some(b"missing-\xff".to_vec()), None] + ); + assert!(archive.legacy_symlink_target_at(0, None).is_err()); + assert_eq!( + archive + .legacy_symlink_target_at(0, Some(b"secret")) + .unwrap(), + Some(b"missing-\xff".to_vec()) + ); + assert_eq!( + archive + .legacy_symlink_target_at(1, Some(b"secret")) + .unwrap(), + None + ); + assert!(archive + .legacy_symlink_target_at(2, Some(b"secret")) + .is_err()); + } +} + +#[test] +fn batch_link_targets_keep_member_order_and_raw_bytes() { + for format in [ + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar40, + ] { + for solid in [false, true] { + let mut builder = Builder::new(format).solid(solid); + builder + .add_directory(b"directory".to_vec(), None, None) + .unwrap(); + builder + .add_unix_symlink( + b"link1".to_vec(), + b"../raw-\xff".to_vec(), + false, + None, + None, + ) + .unwrap(); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder + .add_unix_symlink(b"link2".to_vec(), b"/absolute".to_vec(), false, None, None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.legacy_symlink_targets(None).unwrap(), + vec![ + None, + Some(b"../raw-\xff".to_vec()), + None, + Some(b"/absolute".to_vec()) + ] + ); + } + } +} + +#[test] +fn batch_link_targets_reject_invalid_targets_and_corrupt_dependencies() { + use rars::ErrorKind; + for target in [b"".as_slice(), b"bad\0target"] { + let mut builder = Builder::new(ArchiveVersion::Rar29).store(true); + builder + .add_bytes(b"link".to_vec(), target.to_vec(), None, Some(0o120777)) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let error = archive.legacy_symlink_targets(None).unwrap_err(); + assert_eq!(error.kind(), ErrorKind::InvalidArgument); + assert_eq!(error.entry_context().unwrap().0, b"link"); + } + // These ordinary data entries intentionally carry native Unix link modes, + // exercising compressed solid links from existing archives too. + for solid in [false, true] { + let mut builder = Builder::new(ArchiveVersion::Rar29).solid(solid); + builder + .add_bytes(b"first".to_vec(), b"prefix".repeat(100), None, None) + .unwrap(); + builder + .add_bytes( + b"link1".to_vec(), + b"target one".to_vec(), + None, + Some(0o120777), + ) + .unwrap(); + builder + .add_bytes( + b"link2".to_vec(), + b"target two".to_vec(), + None, + Some(0o120777), + ) + .unwrap(); + let data = builder.to_bytes().unwrap(); + let mut archive = ArchiveReader::read_owned(data).unwrap(); + // Alter the parsed expected CRC to isolate integrity failure from decoding. + if let rars::Archive::Rar15To40(legacy) = &mut archive { + if let rars::rar15_40::Block::File(file) = &mut legacy.blocks[0] { + file.file_crc ^= 1; + } else { + panic!("expected first file"); + } + } + let result = archive.legacy_symlink_targets(None); + if solid { + assert_eq!(result.unwrap_err().kind(), ErrorKind::ChecksumMismatch); + } else { + assert_eq!( + result.unwrap(), + vec![ + None, + Some(b"target one".to_vec()), + Some(b"target two".to_vec()) + ] + ); + } + } +} diff --git a/arca-rar/vendor/rars/tests/builder_timestamps.rs b/arca-rar/vendor/rars/tests/builder_timestamps.rs new file mode 100644 index 00000000..7be07445 --- /dev/null +++ b/arca-rar/vendor/rars/tests/builder_timestamps.rs @@ -0,0 +1,441 @@ +#![cfg(feature = "write")] + +use rars::{ArchiveReader, ArchiveVersion, Builder}; +use std::time::{Duration, UNIX_EPOCH}; + +#[path = "support/scratch.rs"] +mod scratch; + +#[test] +fn source_metadata_preserves_unix_epoch_and_refuses_unrepresentable_seconds() { + let root = scratch::case("source-timestamp-boundaries"); + let file = std::fs::File::create(root.join("source")).unwrap(); + for (instant, expected_unix, expected_dos_year) in [ + (UNIX_EPOCH - Duration::from_secs(1), None, None), + (UNIX_EPOCH, Some(0), None), + ( + UNIX_EPOCH + Duration::from_secs(1_594_771_200), + Some(1_594_771_200), + Some(2020), + ), + ( + UNIX_EPOCH + Duration::from_secs(u64::from(u32::MAX)), + Some(u32::MAX), + Some(2106), + ), + ( + UNIX_EPOCH + Duration::from_secs(u64::from(u32::MAX) + 1), + None, + Some(2106), + ), + ] { + file.set_modified(instant).unwrap(); + let metadata = file.metadata().unwrap(); + assert_eq!(metadata.modified().unwrap(), instant); + assert_eq!(rars::timestamp::source_unix_mtime(&metadata), expected_unix); + let packed = rars::timestamp::source_dos_mtime(&metadata); + assert_eq!( + (packed != 0).then_some(1980 + (packed >> 25)), + expected_dos_year + ); + } + let current = rars::timestamp::current_filetime(); + assert!(current >= 116_444_736_000_000_000); + assert!(!rars::timestamp::format_filetime_utc(current).starts_with("0x")); +} + +#[test] +fn stored_timestamp_view_retains_family_presence_and_refinements() { + use rars::{ArchiveFamily, StoredTimestamp, TimeRefinement}; + for format in ArchiveVersion::ALL { + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"time".to_vec(), vec![], Some(0), None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let mut meta = archive.members().next().unwrap().meta; + for raw in [0, 0x5022_1882] { + meta.file_time = Some(raw); + meta.mtime_refinement = Some(TimeRefinement { + add_second: true, + nanoseconds: 123, + }); + let before = meta.clone(); + let expected = match archive.family() { + ArchiveFamily::Rar50Plus => StoredTimestamp::UnixSeconds(raw), + _ => StoredTimestamp::DosLocal(raw), + }; + assert_eq!(meta.stored_modification_time(), Some(expected), "{format}"); + assert_eq!(meta, before); + } + meta.file_time = None; + assert_eq!(meta.stored_modification_time(), None); + } +} + +#[test] +fn fractional_mtime_survives_all_rar5_output_paths() { + let root = scratch::case("fractional-mtime"); + for (format, encrypted) in [ + (ArchiveVersion::Rar50, false), + (ArchiveVersion::Rar70, true), + ] { + let password = encrypted.then_some(b"secret".to_vec()); + let mut builder = Builder::new(format) + .password(password.clone()) + .header_encryption(encrypted); + builder + .add_bytes( + b"file".to_vec(), + b"timestamp payload".repeat(100), + Some(1_700_000_002), + None, + ) + .unwrap(); + builder.set_mtime_nanoseconds(b"file", 704_088_300).unwrap(); + let path = root.join(format!("{format}.rar")); + builder.write_to_path(&path, None).unwrap(); + let mut outputs = vec![builder.to_bytes().unwrap(), std::fs::read(path).unwrap()]; + outputs.extend(builder.volume_size(Some(4096)).build_volumes(None).unwrap()); + for bytes in outputs { + let archive = ArchiveReader::read_with_options( + &bytes, + password.as_deref().map_or_else( + rars::ArchiveReadOptions::default, + rars::ArchiveReadOptions::with_password, + ), + ) + .unwrap(); + let meta = archive.members().next().unwrap().meta; + assert_eq!( + meta.modification_time(), + Some(UNIX_EPOCH + Duration::new(1_700_000_002, 704_088_300)) + ); + archive + .extract_to(password.as_deref(), |meta| { + assert_eq!(meta.mtime_refinement.unwrap().nanoseconds, 704_088_300); + Ok(Box::new(std::io::sink())) + }) + .unwrap(); + } + } +} + +#[test] +fn split_volume_extraction_retains_fractional_mtime() { + let mut builder = Builder::new(ArchiveVersion::Rar50) + .store(true) + .volume_size(Some(512)); + builder + .add_bytes(b"file".to_vec(), vec![42; 2048], Some(123), None) + .unwrap(); + builder.set_mtime_nanoseconds(b"file", 987_654_321).unwrap(); + let volumes: Vec<_> = builder + .build_volumes(None) + .unwrap() + .into_iter() + .map(|bytes| ArchiveReader::read_owned(bytes).unwrap()) + .collect(); + assert!(volumes.len() > 1); + let mut opened = 0; + rars::extract_volumes_to(&volumes, None, |meta| { + opened += 1; + assert_eq!(meta.file_time, Some(123)); + assert_eq!(meta.mtime_refinement.unwrap().nanoseconds, 987_654_321); + Ok(Box::new(std::io::sink())) + }) + .unwrap(); + assert_eq!(opened, 1); +} + +#[test] +fn an_epoch_fraction_is_not_treated_as_missing_time() { + let detail = rars::TimeRefinement { + add_second: false, + nanoseconds: 123, + }; + assert_eq!( + rars::timestamp::extracted_system_time( + rars::ArchiveFamily::Rar50Plus, + Some(0), + Some(detail) + ), + Some(UNIX_EPOCH + Duration::from_nanos(123)) + ); + assert_eq!( + rars::timestamp::extracted_system_time(rars::ArchiveFamily::Rar50Plus, Some(0), None), + Some(UNIX_EPOCH) + ); + assert_eq!( + rars::timestamp::extracted_system_time(rars::ArchiveFamily::Rar50Plus, None, Some(detail)), + None + ); +} + +#[test] +fn invalid_fractional_mtime_leaves_queued_metadata_unchanged() { + for (format, seconds) in [ + (ArchiveVersion::Rar29, Some(123)), + (ArchiveVersion::Rar50, None), + (ArchiveVersion::Rar50, Some(123)), + ] { + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"file".to_vec(), vec![], seconds, None) + .unwrap(); + let before = builder.to_bytes().unwrap(); + assert!(builder + .set_mtime_nanoseconds(b"file", 1_000_000_000) + .is_err()); + assert!(builder.set_mtime_nanoseconds(b"missing", 100).is_err()); + if seconds.is_none() || format == ArchiveVersion::Rar29 { + assert!(builder.set_mtime_nanoseconds(b"file", 100).is_err()); + } + assert_eq!(builder.to_bytes().unwrap(), before); + } +} + +#[test] +fn extraction_retains_missing_and_epoch_times_in_single_and_split_archives() { + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for time in [None, Some(0)] { + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"file".to_vec(), vec![42; 2048], time, None) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let check = |meta: &rars::ExtractedEntryMeta| { + assert_eq!(meta.file_time, time); + assert_eq!(meta.mtime_refinement, None); + assert_eq!( + rars::timestamp::extracted_system_time( + rars::ArchiveFamily::Rar50Plus, + meta.file_time, + meta.mtime_refinement, + ), + time.map(|_| UNIX_EPOCH), + ); + }; + archive + .extract_to(None, |meta| { + check(meta); + Ok(Box::new(std::io::sink())) + }) + .unwrap(); + let volumes: Vec<_> = builder + .volume_size(Some(512)) + .build_volumes(None) + .unwrap() + .into_iter() + .map(|bytes| ArchiveReader::read_owned(bytes).unwrap()) + .collect(); + assert!(volumes.len() > 1); + let mut opened = 0; + rars::extract_volumes_to(&volumes, None, |meta| { + opened += 1; + check(meta); + Ok(Box::new(std::io::sink())) + }) + .unwrap(); + assert_eq!(opened, 1); + } + } +} + +#[test] +fn complete_file_times_survive_streaming_and_volume_paths() { + use rars::{FileTimes, FileTimestamp}; + for times in [ + FileTimes { + modified: Some(FileTimestamp::WindowsFiletime(0)), + created: Some(FileTimestamp::WindowsFiletime(u64::MAX)), + accessed: Some(FileTimestamp::WindowsFiletime(116_444_736_000_000_001)), + }, + FileTimes { + modified: None, + created: Some(FileTimestamp::Unix { + seconds: 0, + nanoseconds: 123, + }), + accessed: Some(FileTimestamp::Unix { + seconds: u32::MAX, + nanoseconds: 999_999_999, + }), + }, + ] { + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(123), None) + .unwrap(); + builder.set_file_times(b"file", Some(times)).unwrap(); + let mut outputs = vec![builder.to_bytes().unwrap()]; + outputs.extend(builder.volume_size(Some(4096)).build_volumes(None).unwrap()); + for bytes in outputs { + let archive = ArchiveReader::read_owned(bytes).unwrap(); + assert_eq!( + archive.members().next().unwrap().file_times().unwrap(), + Some(times) + ); + assert_eq!( + archive.read_member(b"file", None).unwrap().unwrap(), + b"payload" + ); + } + } +} + +#[test] +fn adding_creation_time_preserves_an_existing_fractional_modification_time() { + use rars::{FileTimes, FileTimestamp}; + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(123), None) + .unwrap(); + builder.set_mtime_nanoseconds(b"file", 456_789_123).unwrap(); + let before = builder.to_bytes().unwrap(); + let mixed = FileTimes { + modified: None, + created: Some(FileTimestamp::WindowsFiletime(116_444_736_000_000_001)), + accessed: None, + }; + assert!(builder.set_file_times(b"file", Some(mixed)).is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + let times = FileTimes { + modified: None, + created: Some(FileTimestamp::Unix { + seconds: 456, + nanoseconds: 0, + }), + accessed: None, + }; + builder.set_file_times(b"file", Some(times)).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.members().next().unwrap().file_times().unwrap(), + Some(FileTimes { + modified: Some(FileTimestamp::Unix { + seconds: 123, + nanoseconds: 456_789_123, + }), + ..times + }) + ); +} + +#[test] +fn invalid_complete_times_leave_builder_output_unchanged() { + use rars::{FileTimes, FileTimestamp}; + for format in [ArchiveVersion::Rar29, ArchiveVersion::Rar50] { + let mut builder = Builder::new(format).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(123), None) + .unwrap(); + let before = builder.to_bytes().unwrap(); + let invalid = FileTimes { + modified: Some(FileTimestamp::Unix { + seconds: 123, + nanoseconds: 1_000_000_000, + }), + created: None, + accessed: None, + }; + assert!(builder.set_file_times(b"file", Some(invalid)).is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + if format == ArchiveVersion::Rar29 { + assert!(builder + .set_file_times(b"file", Some(FileTimes::default())) + .is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + } + } +} + +#[test] +fn clearing_complete_times_removes_the_rar5_time_record() { + use rars::{FileTimes, FileTimestamp}; + + let mut builder = Builder::new(ArchiveVersion::Rar50).store(true); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), Some(123), None) + .unwrap(); + builder + .set_file_times( + b"file", + Some(FileTimes { + modified: Some(FileTimestamp::Unix { + seconds: 456, + nanoseconds: 789, + }), + created: None, + accessed: None, + }), + ) + .unwrap(); + builder.set_file_times(b"file", None).unwrap(); + + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert_eq!( + archive.members().next().unwrap().file_times().unwrap(), + None + ); +} + +#[test] +fn legacy_extended_times_are_validated_before_the_archive_is_written() { + let mut builder = Builder::new(ArchiveVersion::Rar29).store(true); + builder + .add_bytes( + b"file".to_vec(), + b"payload".to_vec(), + Some(0x5a21_0000), + None, + ) + .unwrap(); + let before = builder.to_bytes().unwrap(); + // No odd-second or fraction control bits may be present without the + // corresponding timestamp-present bit, in any of the four legacy slots. + for index in 0..4 { + for mode in 1..8u16 { + let flags = mode << (12 - index * 4); + assert_eq!( + builder.set_legacy_extended_times(b"file", Some(flags.to_le_bytes().to_vec())), + Err(rars::Error::InvalidArgument( + "legacy extended timestamps are incomplete or invalid" + )) + ); + assert_eq!(builder.to_bytes().unwrap(), before); + } + } + assert!(builder + .set_legacy_extended_times(b"file", Some(vec![0x00, 0x90])) + .is_err()); + assert_eq!(builder.to_bytes().unwrap(), before); + builder + .set_legacy_extended_times(b"file", Some(vec![0x00, 0x90, 0x01])) + .unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + assert!(archive + .members() + .next() + .unwrap() + .file_times() + .unwrap() + .is_some()); + + let mut old = Builder::new(ArchiveVersion::Rar20).store(true); + old.add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert!(old + .set_legacy_extended_times(b"file", Some(vec![0x00, 0x90, 0x01])) + .is_err()); + + let mut volume = Builder::new(ArchiveVersion::Rar29) + .store(true) + .volume_size(Some(512)); + volume + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + assert!(volume + .set_legacy_extended_times(b"file", Some(vec![0x00, 0x90, 0x01])) + .is_err()); +} diff --git a/arca-rar/vendor/rars/tests/comment_options.rs b/arca-rar/vendor/rars/tests/comment_options.rs new file mode 100644 index 00000000..b112fbdf --- /dev/null +++ b/arca-rar/vendor/rars/tests/comment_options.rs @@ -0,0 +1,403 @@ +#![cfg(feature = "write")] + +use rars::{ + Archive, ArchiveReadOptions, ArchiveReader, ArchiveVersion, Builder, ErrorKind, + ReadCancellation, +}; +use std::io::{self, Cursor, Read, Seek, SeekFrom}; +use std::sync::{ + atomic::{AtomicBool, AtomicUsize, Ordering}, + Arc, +}; + +const FORMATS: [ArchiveVersion; 9] = [ + ArchiveVersion::Rar13, + ArchiveVersion::Rar14, + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, +]; + +#[test] +fn legacy_encrypted_archive_comment_requires_comment_password_and_rar3_or_rar4() { + for (format, comment, password) in [ + (ArchiveVersion::Rar30, None, b"secret".as_slice()), + ( + ArchiveVersion::Rar30, + Some(b"comment".as_slice()), + b"".as_slice(), + ), + ( + ArchiveVersion::Rar20, + Some(b"comment".as_slice()), + b"secret".as_slice(), + ), + ( + ArchiveVersion::Rar29, + Some(b"comment".as_slice()), + b"secret".as_slice(), + ), + ] { + let mut builder = Builder::new(format) + .store(true) + .comment(comment.map(Vec::from)) + .archive_comment_password(Some(password.to_vec())); + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + let error = builder.to_bytes().unwrap_err(); + assert_eq!( + error.kind(), + ErrorKind::InvalidArgument, + "{format:?}: {error}" + ); + } +} + +fn bytes(format: ArchiveVersion, comment: Option<&[u8]>, encrypted: bool) -> Vec { + let mut builder = Builder::new(format).comment(comment.map(Vec::from)); + if encrypted { + builder = builder.archive_comment_password(Some(b"secret".to_vec())); + } + builder + .add_bytes(b"file".to_vec(), b"payload".to_vec(), None, None) + .unwrap(); + builder.to_bytes().unwrap() +} + +fn assert_limits(archive: &Archive, expected: &[u8], password: Option<&[u8]>) { + let defaults = ArchiveReadOptions::with_optional_password(password); + assert_eq!( + archive.comment(password).unwrap().as_deref(), + Some(expected) + ); + for total in [false, true] { + let mut options = defaults; + if total { + options.max_total_output_bytes = Some(expected.len() as u64); + } else { + options.max_member_output_bytes = Some(expected.len() as u64); + } + for _ in 0..2 { + assert_eq!( + archive.comment_with_options(options).unwrap().as_deref(), + Some(expected) + ); + } + if !expected.is_empty() { + if total { + options.max_total_output_bytes = Some(expected.len() as u64 - 1); + } else { + options.max_member_output_bytes = Some(expected.len() as u64 - 1); + } + assert_eq!( + archive.comment_with_options(options).unwrap_err().kind(), + ErrorKind::ResourceLimit + ); + } + } + let token = ReadCancellation::new(); + token.cancel(); + assert_eq!( + archive + .comment_with_options(defaults.with_cancellation(&token)) + .unwrap_err() + .kind(), + ErrorKind::Cancelled + ); + assert_eq!( + archive.comment(password).unwrap().as_deref(), + Some(expected) + ); +} + +#[test] +fn comment_limits_cover_all_versions_empty_comments_and_fresh_budgets() { + for format in FORMATS { + for comment in [b"archive comment\n".as_slice(), b""] { + let archive = ArchiveReader::read_owned(bytes(format, Some(comment), false)).unwrap(); + assert_limits(&archive, comment, None); + } + let archive = ArchiveReader::read_owned(bytes(format, None, false)).unwrap(); + let options = ArchiveReadOptions::new().with_max_member_output_bytes(0); + assert_eq!(archive.comment_with_options(options).unwrap(), None); + let token = ReadCancellation::new(); + token.cancel(); + assert_eq!( + archive + .comment_with_options(options.with_cancellation(&token)) + .unwrap_err() + .kind(), + ErrorKind::Cancelled + ); + } +} + +#[test] +fn encrypted_comment_admission_precedes_password_work() { + for format in [ + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, + ] { + let archive = + ArchiveReader::read_owned(bytes(format, Some(b"encrypted comment"), true)).unwrap(); + assert_eq!( + archive.comment(None).unwrap_err().kind(), + ErrorKind::PasswordRequired + ); + assert_eq!( + archive + .comment_with_options(ArchiveReadOptions::new().with_max_member_output_bytes(0)) + .unwrap_err() + .kind(), + ErrorKind::ResourceLimit + ); + assert_limits(&archive, b"encrypted comment", Some(b"secret")); + } +} + +#[test] +fn historical_comment_fixtures_keep_their_contents_under_limits() { + for data in [ + include_bytes!("fixtures/rar13/COMMENT.RAR").as_slice(), + include_bytes!("fixtures/rar15_40/rar202/comment_nopsw.rar"), + include_bytes!("fixtures/rar15_40/rar300/with_comment_rar300.rar"), + include_bytes!("fixtures/rar50/with_comment.rar"), + ] { + let archive = ArchiveReader::read(data).unwrap(); + let expected = archive + .comment(None) + .unwrap() + .expect("fixture has archive comment"); + assert!(!expected.is_empty()); + assert_limits(&archive, &expected, None); + } +} + +#[test] +fn modern_comments_apply_dictionary_and_buffering_policy() { + for format in [ArchiveVersion::Rar50, ArchiveVersion::Rar70] { + for encrypted in [false, true] { + let comment = b"repeatable text\n".repeat(100); + let stored = + ArchiveReader::read_owned(bytes(format, Some(&comment), encrypted)).unwrap(); + let password = encrypted.then_some(b"secret".as_slice()); + let defaults = ArchiveReadOptions::with_optional_password(password); + assert_eq!( + stored + .comment_with_options(defaults.with_rar50_dictionary_size_limit(0)) + .unwrap(), + Some(comment.clone()) + ); + // The writer emits stored comments. Exercise the shared compressed + // service payload representation using a normally encoded member. + let mut builder = Builder::new(format).password(password.map(Vec::from)); + builder + .add_bytes(b"CMT".to_vec(), comment.clone(), None, None) + .unwrap(); + let mut archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + if let Archive::Rar50Plus(raw) = &mut archive { + for block in &mut raw.blocks { + if let rars::rar50::Block::File(file) = block { + assert!(!file.is_stored()); + *block = rars::rar50::Block::Service(file.clone()); + } + } + } + assert_limits(&archive, &comment, password); + assert_eq!( + archive + .comment_with_options(defaults.with_rar50_dictionary_size_limit(0)) + .unwrap_err() + .kind(), + ErrorKind::ResourceLimit + ); + assert_eq!( + archive + .comment_with_options(defaults.with_rar50_dictionary_size_limit(u64::MAX)) + .unwrap(), + Some(comment.clone()) + ); + let options = defaults + .with_rar50_buffered_decode_limit(0) + .with_max_member_output_bytes(comment.len() as u64); + assert_eq!( + archive.comment_with_options(options).unwrap(), + Some(comment) + ); + } + } +} + +#[test] +fn unknown_size_modern_comments_reject_limits_before_decoding() { + let mut archive = ArchiveReader::read_owned(bytes( + ArchiveVersion::Rar50, + Some(b"unknown-size comment"), + false, + )) + .unwrap(); + let Archive::Rar50Plus(raw) = &mut archive else { + unreachable!() + }; + for block in &mut raw.blocks { + if let rars::rar50::Block::Service(file) = block { + if file.name == b"CMT" { + file.file_flags |= 0x8; + assert_eq!(file.known_unpacked_size(), None); + } + } + } + assert_eq!( + archive.comment(None).unwrap().unwrap(), + b"unknown-size comment" + ); + let error = archive + .comment_with_options(ArchiveReadOptions::new().with_max_member_output_bytes(100)) + .unwrap_err(); + assert!(matches!( + error.root_cause(), + rars::Error::UnsupportedFeature { + feature: "output-limited decoding of an unknown-size comment", + .. + } + )); +} + +struct ObservedReader { + data: Cursor>, + armed: Arc, + reads: Arc, + cancellation: Option, +} +impl Read for ObservedReader { + fn read(&mut self, output: &mut [u8]) -> io::Result { + if self.armed.load(Ordering::Relaxed) { + self.reads.fetch_add(1, Ordering::Relaxed); + if let Some(token) = &self.cancellation { + token.cancel(); + } + } + self.data.read(output) + } +} +impl Seek for ObservedReader { + fn seek(&mut self, from: SeekFrom) -> io::Result { + self.data.seek(from) + } +} + +#[test] +fn admission_precedes_source_reads_and_cancellation_survives_decoder_adapters() { + for format in [ + ArchiveVersion::Rar20, + ArchiveVersion::Rar30, + ArchiveVersion::Rar50, + ] { + let token = ReadCancellation::new(); + let armed = Arc::new(AtomicBool::new(false)); + let reads = Arc::new(AtomicUsize::new(0)); + let archive = ArchiveReader::read_reader(ObservedReader { + data: Cursor::new(bytes(format, Some(b"comment"), false)), + armed: armed.clone(), + reads: reads.clone(), + cancellation: Some(token.clone()), + }) + .unwrap(); + armed.store(true, Ordering::Relaxed); + assert_eq!( + archive + .comment_with_options(ArchiveReadOptions::new().with_max_total_output_bytes(0)) + .unwrap_err() + .kind(), + ErrorKind::ResourceLimit + ); + assert_eq!(reads.load(Ordering::Relaxed), 0); + assert_eq!( + archive + .comment_with_options(ArchiveReadOptions::new().with_cancellation(&token)) + .unwrap_err() + .kind(), + ErrorKind::Cancelled + ); + assert!(reads.load(Ordering::Relaxed) > 0); + } +} + +#[test] +fn unpacked_rar13_comment_uses_the_same_output_policy() { + let comment = b"plain legacy comment"; + let mut archive = + ArchiveReader::read_owned(bytes(ArchiveVersion::Rar13, Some(comment), false)).unwrap(); + if let Archive::Rar13(raw) = &mut archive { + // The writer chooses packed comments; construct the alternate plain + // comment representation in the parsed main header. + raw.main.flags &= !0x10; + raw.main.extra = (comment.len() as u16).to_le_bytes().to_vec(); + raw.main.extra.extend_from_slice(comment); + assert!(!raw.main.has_packed_comment()); + } + assert_limits(&archive, comment, None); +} + +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +#[path = "support/scratch.rs"] +mod scratch; + +#[test] +#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] +fn filtered_comment_uses_bounded_scratch_and_cleans_up() { + use rars::rar50::{ArchiveEntry, Rar50Writer, WriterOptions}; + use rars::{EntrySource, FeatureSet, FilterKind, FilterPolicy, Rar50Scratch}; + let comment: Vec = [0xe8, 1, 0, 0, 0, 0xe9, 3, 0, 0, 0].repeat(1000); + let data = Rar50Writer::new(WriterOptions::new( + ArchiveVersion::Rar50, + FeatureSet::store_only(), + )) + .entries([ArchiveEntry::new( + b"CMT".to_vec(), + EntrySource::from_bytes(Arc::<[u8]>::from(comment.clone())), + )]) + .filter_policy(FilterPolicy::explicit(FilterKind::E8E9)) + .finish() + .unwrap(); + let mut archive = ArchiveReader::read_owned(data).unwrap(); + if let Archive::Rar50Plus(raw) = &mut archive { + for block in &mut raw.blocks { + if let rars::rar50::Block::File(file) = block { + *block = rars::rar50::Block::Service(file.clone()); + } + } + } + let options = ArchiveReadOptions::new() + .with_rar50_buffered_decode_limit(0) + .with_max_total_output_bytes(comment.len() as u64); + assert_eq!( + archive.comment_with_options(options).unwrap_err().kind(), + ErrorKind::ResourceLimit + ); + let dir = scratch::case("comment-scratch"); + let policy = Rar50Scratch::new(&*dir, 100_000).with_filter_memory_limit(64 * 1024); + assert_eq!( + archive + .comment_with_options(options.with_rar50_scratch(&policy)) + .unwrap(), + Some(comment) + ); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); + let refused = Rar50Scratch::new(&*dir, 1); + assert_eq!( + archive + .comment_with_options(options.with_rar50_scratch(&refused)) + .unwrap_err() + .kind(), + ErrorKind::ResourceLimit + ); + assert_eq!(std::fs::read_dir(&*dir).unwrap().count(), 0); +} diff --git a/arca-rar/vendor/rars/tests/crypto_api.rs b/arca-rar/vendor/rars/tests/crypto_api.rs new file mode 100644 index 00000000..8bfd847d --- /dev/null +++ b/arca-rar/vendor/rars/tests/crypto_api.rs @@ -0,0 +1,79 @@ +#![cfg(feature = "encryption")] + +use rars::crypto::{rar30, rar50}; + +#[test] +fn key_equality_checks_every_byte_and_debug_keeps_material_private() { + let keys = rar50::Rar50Keys::derive(b"secret", [7; 16], 0).unwrap(); + assert_eq!(keys, keys.clone()); + assert_eq!(format!("{keys:?}"), "Rar50Keys { .. }"); + for index in 0..72 { + let mut changed = keys.clone(); + match index { + 0..32 => changed.key[index] ^= 1, + 32..64 => changed.hash_key[index - 32] ^= 1, + _ => changed.password_check[index - 64] ^= 1, + } + assert_ne!(keys, changed, "changed byte {index}"); + assert_ne!(changed, keys, "changed byte {index}"); + } +} + +#[test] +fn password_check_rejects_each_corrupted_byte_and_retains_old_zero_record_policy() { + let keys = rar50::Rar50Keys::derive(b"secret", [7; 16], 0).unwrap(); + let record = keys.password_check_record(); + assert_eq!(keys.check_password(&record), Ok(())); + assert_ne!(record[..8], [0; 8]); + for index in 0..12 { + let mut changed = record; + changed[index] ^= 1; + let error = keys.check_password(&changed).unwrap_err(); + assert_eq!(error, rar50::Error::BadPassword); + assert_eq!( + error.to_string(), + "wrong password or corrupt encrypted data" + ); + } + let mut absent = [0; 12]; + absent[8..].fill(0xa5); + assert_eq!(keys.check_password(&absent), Ok(())); +} + +#[test] +fn excessive_kdf_exponents_are_refused_before_derivation() { + for exponent in [25, u8::MAX] { + let error = rar50::Rar50Keys::derive(b"secret", [0; 16], exponent) + .err() + .unwrap(); + assert_eq!(error, rar50::Error::KdfCountTooLarge); + assert_eq!(error.to_string(), "RAR 5 KDF count is too large"); + } +} + +#[test] +fn legacy_non_utf8_password_error_has_a_useful_diagnostic() { + let error = rar30::Rar30Cipher::new(b"\xffpassword", None) + .err() + .unwrap(); + assert_eq!(error, rar30::Error::NonUtf8Password); + assert_eq!(error.to_string(), "RAR 3.x password is not UTF-8"); +} + +#[test] +fn partial_aes_blocks_are_refused_without_mutating_the_input() { + let mut data = [0x55; 15]; + let error = rar30::Rar30Cipher::new(b"secret", None) + .unwrap() + .decrypt_in_place(&mut data) + .unwrap_err(); + assert_eq!(error, rar30::Error::UnalignedInput); + assert_eq!(error.to_string(), "RAR 3.x AES input is not block aligned"); + assert_eq!(data, [0x55; 15]); + let error = rar50::Rar50Cipher::new([7; 32], [3; 16]) + .decrypt_in_place(&mut data) + .unwrap_err(); + assert_eq!(error, rar50::Error::UnalignedInput); + assert_eq!(error.to_string(), "RAR 5 AES input is not block aligned"); + assert_eq!(data, [0x55; 15]); +} diff --git a/arca-rar/vendor/rars/tests/extraction_control.rs b/arca-rar/vendor/rars/tests/extraction_control.rs new file mode 100644 index 00000000..37f18c5d --- /dev/null +++ b/arca-rar/vendor/rars/tests/extraction_control.rs @@ -0,0 +1,451 @@ +#![cfg(feature = "write")] + +use rars::{ + Archive, ArchiveReadOptions, ArchiveReader, ArchiveVersion, Builder, Error, + ExtractionDecision as Decision, ExtractionOutcome as Outcome, +}; +use std::{cell::RefCell, io, io::Write, rc::Rc}; + +const VERSIONS: [ArchiveVersion; 8] = [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar15, + ArchiveVersion::Rar20, + ArchiveVersion::Rar29, + ArchiveVersion::Rar30, + ArchiveVersion::Rar40, + ArchiveVersion::Rar50, + ArchiveVersion::Rar70, +]; + +struct Capture(Rc>>); +impl Write for Capture { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.0.borrow_mut().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} +fn archive(version: ArchiveVersion, solid: bool, encrypted: bool) -> Archive { + let mut builder = Builder::new(version) + .solid(solid) + .password(encrypted.then(|| b"secret".to_vec())); + for (name, len) in [(b"first".as_slice(), 4096), (b"second", 32), (b"third", 64)] { + builder + .add_bytes(name.to_vec(), vec![42; len], None, None) + .unwrap(); + } + ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap() +} + +#[test] +fn skip_precedes_limits_and_stop_precedes_later_members() { + for version in VERSIONS { + let archive = archive(version, false, false); + let output = Rc::new(RefCell::new(Vec::new())); + let mut visited = Vec::new(); + let outcome = archive + .extract_with_control( + ArchiveReadOptions::new() + .with_max_member_output_bytes(32) + .with_max_total_output_bytes(32), + |member| { + visited.push(member.meta.name.clone()); + Ok(match member.meta.name.as_slice() { + b"first" => { + assert_eq!(member.meta.unpacked_size, 4096); + Decision::Skip + } + b"second" => Decision::Extract(Box::new(Capture(output.clone()))), + _ => Decision::Stop, + }) + }, + ) + .unwrap(); + assert_eq!(outcome, Outcome::Stopped); + assert_eq!(*output.borrow(), vec![42; 32]); + assert_eq!( + visited, + [b"first".to_vec(), b"second".to_vec(), b"third".to_vec()] + ); + let mut calls = 0; + assert_eq!( + archive + .extract_with_control(ArchiveReadOptions::new(), |_| { + calls += 1; + Ok(Decision::Stop) + }) + .unwrap(), + Outcome::Stopped + ); + assert_eq!(calls, 1); + } +} + +#[test] +fn encrypted_members_can_be_skipped_without_a_password() { + for version in VERSIONS.into_iter().filter(|v| *v != ArchiveVersion::Rar14) { + let archive = archive(version, false, true); + let mut calls = 0; + let outcome = archive + .extract_with_control(ArchiveReadOptions::new(), |member| { + assert!(member.meta.is_encrypted); + calls += 1; + Ok(Decision::Skip) + }) + .unwrap(); + assert_eq!(outcome, Outcome::Complete); + assert_eq!(calls, 3); + } +} + +#[test] +fn solid_skipping_is_refused_but_discarding_preserves_history_and_accounting() { + for version in VERSIONS { + let archive = archive(version, true, false); + let error = archive + .extract_with_control(ArchiveReadOptions::new(), |_| Ok(Decision::Skip)) + .unwrap_err(); + assert!(matches!(error.root_cause(), Error::CannotSkipSolidMember)); + assert_eq!(error.entry_context().unwrap().0, b"first"); + let output = Rc::new(RefCell::new(Vec::new())); + assert_eq!( + archive + .extract_with_control(ArchiveReadOptions::new(), |member| { + Ok(Decision::Extract(if member.meta.name == b"first" { + Box::new(io::sink()) as Box + } else { + Box::new(Capture(output.clone())) + })) + }) + .unwrap(), + Outcome::Complete + ); + assert_eq!(*output.borrow(), vec![42; 96]); + let error = archive + .extract_with_control( + ArchiveReadOptions::new().with_max_total_output_bytes(4096), + |_| Ok(Decision::Extract(Box::new(io::sink()))), + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::ResourceLimit); + assert_eq!(error.entry_context().unwrap().0, b"second"); + } +} + +#[test] +fn callback_cancellation_and_errors_do_not_become_successful_stops() { + let archive = archive(ArchiveVersion::Rar50, false, false); + let token = rars::ReadCancellation::new(); + let error = archive + .extract_with_control(ArchiveReadOptions::new().with_cancellation(&token), |_| { + token.cancel(); + Ok(Decision::Stop) + }) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::Cancelled); + let mut calls = 0; + let error = archive + .extract_with_control(ArchiveReadOptions::new(), |_| { + calls += 1; + Err(io::Error::from(io::ErrorKind::PermissionDenied).into()) + }) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::Io); + assert_eq!(calls, 1); +} + +#[test] +fn skipping_a_bad_checksum_continues_but_extracting_it_stops() { + for version in [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut archive = archive(version, false, false); + match &mut archive { + Archive::Rar13(a) => a.entries[0].header.file_crc ^= 1, + Archive::Rar15To40(a) => { + for block in &mut a.blocks { + if let rars::rar15_40::Block::File(file) = block { + if file.name == b"first" { + file.file_crc ^= 1; + } + } + } + } + Archive::Rar50Plus(a) => { + for block in &mut a.blocks { + if let rars::rar50::Block::File(file) = block { + if file.name == b"first" { + file.hash = None; + file.data_crc32 = Some(file.data_crc32.unwrap() ^ 1); + } + } + } + } + _ => unreachable!(), + } + let token = rars::ReadCancellation::new(); + let mut selected = 0; + let mut failures = 0; + let error = archive + .extract_with_control_and_errors( + ArchiveReadOptions::new().with_cancellation(&token), + |_| { + selected += 1; + Ok(Decision::Extract(Box::new(io::sink()))) + }, + |_, error| { + assert_eq!(error.kind(), rars::ErrorKind::ChecksumMismatch); + failures += 1; + token.cancel(); + Ok(rars::ExtractionErrorAction::Continue) + }, + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::Cancelled); + assert_eq!((selected, failures), (1, 1)); + let mut selected = 0; + let mut failures = 0; + let error = archive + .extract_with_control_and_errors( + ArchiveReadOptions::new(), + |_| { + selected += 1; + Ok(Decision::Extract(Box::new(io::sink()))) + }, + |member, error| { + assert_eq!(member.meta.name, b"first"); + assert_eq!(error.kind(), rars::ErrorKind::ChecksumMismatch); + failures += 1; + Ok(rars::ExtractionErrorAction::Abort) + }, + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::ChecksumMismatch); + assert_eq!(error.entry_context().unwrap().0, b"first"); + assert_eq!((selected, failures), (1, 1)); + let output = Rc::new(RefCell::new(Vec::new())); + assert_eq!( + archive + .extract_with_control(ArchiveReadOptions::new(), |member| { + Ok(if member.meta.name == b"first" { + Decision::Skip + } else { + Decision::Extract(Box::new(Capture(output.clone()))) + }) + }) + .unwrap(), + Outcome::Complete + ); + assert_eq!(*output.borrow(), vec![42; 96]); + let mut calls = 0; + let error = archive + .extract_with_control(ArchiveReadOptions::new(), |_| { + calls += 1; + Ok(Decision::Extract(Box::new(io::sink()))) + }) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::ChecksumMismatch); + assert_eq!(calls, 1); + + for limit in [4096, 4192] { + let output = Rc::new(RefCell::new(Vec::new())); + let mut failures = 0; + let result = archive.extract_with_control_and_errors( + ArchiveReadOptions::new() + .with_max_total_output_bytes(limit) + .with_rar50_buffered_decode_limit(0), + |member| { + Ok(Decision::Extract(if member.meta.name == b"first" { + Box::new(io::sink()) as Box + } else { + Box::new(Capture(output.clone())) + })) + }, + |member, error| { + assert_eq!(member.meta.name, b"first"); + assert_eq!(error.kind(), rars::ErrorKind::ChecksumMismatch); + failures += 1; + Ok(rars::ExtractionErrorAction::Continue) + }, + ); + assert_eq!(failures, 1); + if limit == 4096 { + let error = result.unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::ResourceLimit); + assert_eq!(error.entry_context().unwrap().0, b"second"); + assert!(output.borrow().is_empty()); + } else { + assert_eq!(result.unwrap(), Outcome::Complete); + assert_eq!(*output.borrow(), vec![42; 96]); + } + } + } +} + +#[test] +fn solid_failures_and_callback_errors_cannot_be_continued() { + struct Broken; + impl Write for Broken { + fn write(&mut self, _: &[u8]) -> io::Result { + Err(io::ErrorKind::PermissionDenied.into()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + for version in VERSIONS { + let archive = archive(version, true, false); + let error = archive + .extract_with_control_and_errors( + ArchiveReadOptions::new(), + |_| Ok(Decision::Extract(Box::new(Broken))), + |_, _| panic!("solid failure must not offer recovery"), + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::Io); + } + let archive = archive(ArchiveVersion::Rar50, false, false); + let error = archive + .extract_with_control_and_errors( + ArchiveReadOptions::new(), + |_| Err(io::Error::other("callback failed").into()), + |_, _| panic!("decision callback errors are fatal"), + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::Io); +} + +#[test] +fn split_members_never_offer_independent_error_recovery() { + // These flags are exposed in the parsed archive model. A split payload + // requires the multivolume reader, even if an error callback asks to continue. + for flags in [0x0001, 0x0002, 0x0003] { + let mut archive = archive(ArchiveVersion::Rar29, false, false); + let Archive::Rar15To40(legacy) = &mut archive else { + unreachable!() + }; + let file = legacy + .blocks + .iter_mut() + .find_map(|block| match block { + rars::rar15_40::Block::File(file) => Some(file), + _ => None, + }) + .unwrap(); + file.block.flags |= flags; + let mut selected = 0; + let error = archive + .extract_with_control_and_errors( + ArchiveReadOptions::new(), + |_| { + selected += 1; + Ok(Decision::Extract(Box::new(io::sink()))) + }, + |_, _| panic!("split payloads cannot be recovered independently"), + ) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::InvalidArchive); + assert_eq!(selected, 1); + } +} + +#[test] +fn selector_errors_preserve_existing_entry_context() { + for version in VERSIONS { + let archive = archive(version, false, false); + let mut calls = 0; + let error = archive + .extract_with_control(ArchiveReadOptions::new(), |_| { + calls += 1; + Err(Error::InvalidHeader("selection failed") + .at_entry(b"external entry".to_vec(), "external operation")) + }) + .unwrap_err(); + assert_eq!(error.kind(), rars::ErrorKind::InvalidArchive); + assert_eq!( + error.entry_context(), + Some((b"external entry".as_slice(), "external operation")) + ); + assert_eq!(calls, 1); + } +} + +#[test] +fn skip_and_stop_do_not_read_payloads_from_a_caller_source() { + use std::io::{Cursor, Read, Seek, SeekFrom}; + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }; + struct Source(Cursor>, Arc); + impl Read for Source { + fn read(&mut self, bytes: &mut [u8]) -> io::Result { + if self.1.load(Ordering::Relaxed) { + return Err(io::ErrorKind::PermissionDenied.into()); + } + self.0.read(bytes) + } + } + impl Seek for Source { + fn seek(&mut self, from: SeekFrom) -> io::Result { + self.0.seek(from) + } + } + for version in [ + ArchiveVersion::Rar14, + ArchiveVersion::Rar29, + ArchiveVersion::Rar50, + ] { + let mut builder = Builder::new(version).store(true); + builder + .add_bytes(b"file".to_vec(), vec![42; 1024], None, None) + .unwrap(); + let fail = Arc::new(AtomicBool::new(false)); + let archive = ArchiveReader::read_reader(Source( + Cursor::new(builder.to_bytes().unwrap()), + fail.clone(), + )) + .unwrap(); + fail.store(true, Ordering::Relaxed); + assert_eq!( + archive + .extract_with_control(ArchiveReadOptions::new(), |_| Ok(Decision::Skip)) + .unwrap(), + Outcome::Complete + ); + assert_eq!( + archive + .extract_with_control(ArchiveReadOptions::new(), |_| Ok(Decision::Stop)) + .unwrap(), + Outcome::Stopped + ); + } +} + +#[test] +fn controlled_directory_extraction_selects_a_writer_without_spending_output_quota() { + for version in VERSIONS { + let mut builder = Builder::new(version); + builder.add_directory(b"dir".to_vec(), None, None).unwrap(); + let archive = ArchiveReader::read_owned(builder.to_bytes().unwrap()).unwrap(); + let output = Rc::new(RefCell::new(Vec::new())); + let mut visits = 0; + let outcome = archive + .extract_with_control( + ArchiveReadOptions::new().with_max_total_output_bytes(0), + |member| { + assert!(member.meta.is_directory); + visits += 1; + Ok(Decision::Extract(Box::new(Capture(output.clone())))) + }, + ) + .unwrap(); + assert_eq!(outcome, Outcome::Complete); + assert_eq!(visits, 1); + assert!(output.borrow().is_empty()); + } +} diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_comment.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_comment.rar new file mode 100644 index 0000000000000000000000000000000000000000..9ad9c750b485153841579ca20e008d467ae80191 GIT binary patch literal 1165 zcmV;81akXQVR9iF2LS-Z8Z$Bj0RR9)CyLt>0|NpU1Qr01&GVxG00To!Q~?KPZ){{` zZXjWDV`yo1Wgug3ZEa<4bgF|CoI(NvBY+47fCwM}002bNvfzs^&~w3qDjv29C&1#6&uP03pK^OKf8dz}_2Dc4!W= z*God*I<^~=1xa~l08O6DP^A5VChSyKt-(U~u!%=Vd|4xEkxo8k4O`qrRWmH>_enKH zpWKDK&|Uj9J zYmys3MM&ze0PCDgER9Z`hcr`JaJW|>m_xNS@8aPpN;XWfn*oqf$2{`=z7|1)GP#__ z`bhKgK9V5lPkn|4B=aCvbaGOj868IXmB5_?O-+qA2w#7BRJ&;eV5|Z}Nxfx~-cd{1 zKdrl6> z{4Q0O#E9k+?nSy#f};GjObKHb{RJ0OMj2tU$H+rSe7GZ7jY=@F7A^w&t3`~{HXXiw4A8A1U)R`pu0Zf;ygeAVFomKx};Y$VpA1x3=ezVXVvT;fb-YoxZwNZFH zHM6l2K`chr6hQk(Hv;{9M}AKyGC3rtdR8?PS4%#5M&Cws8E05c7&gm1f@D(Y`NNR%joBsJvWz*<(HBDBYsON5DH%4vt@^DojO~wYWCL!8X zNvidoTa!edybjx7$V%S3--0 z9Jg{u^5o>mli*IzfLWj4tW}o0je!GoMZKgX8rl;~f%!d-iAYm?>X3&IX+t7maW#q$ zN;-D2Vq0uc_SYXorkO!<;`CT$k4Rl>&3y}QPd!h* f9^ct5RDoXTy?%p4TM5^P5SB{`8L~Px0|fv8jJ^hx literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_comment_metadata.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_comment_metadata.rar new file mode 100644 index 0000000000000000000000000000000000000000..b6fd420d178c8f4b35ab09b4fa3460522766b228 GIT binary patch literal 1192 zcmV;Z1Xue~VR9iF2LS-^*bo;U0Rb8S0|5a56#@eaXK!p|Wo|BVVR8Tf00000*#Sc* zirW(d0|FKV766gW^P>O&14B(z0S9MqY-D9_AYpQ2XlZt3AY*TBZDnqBs)H1qLIMLL zfCvVF2p|9e08reKkwyRj3vgk1Y;R#?E@EkJA_4$x3k@k$mP*#jvlAUn=WxNxxE7bj zW6g+pOwCZ;RoJmX7F+UX(I`mjxHM7ZO;6tR0P0uSR@+JmML8En*Oz6jA|Oqw=1g1* zK2$~qj>t~LL^^-~A;T0)Y-0?--WyVOXb!U1OG4i|wi}ZLNqJ`gO`gk8r2T;=>{M5+ z!9w@2iAP9$StDwZPCjJ~TiiueGc4=(Ni{{E+?mD%Kuoh}R}TtnQ?K={AV|7H>6jJl z!zqt1jZU41G*ek{xK|*U zL$x*U;^8SuHcYXb0gzG0Jo5d%7D0nDxtzxONb~YOk|5|$eTD`k^B`7qa#Efd9Y*<; zz?}n4O^r7QUw?U2yJ-YqtO7(yy=9W#QA^t8?W_XcQn*>keu_sz@Ay@`pj1h4JT2~_ z`%twT3Iq$_S06IUdCC+=4R#|cZ-GvGP7cWYE>)Mrh~^URMY>ReqWrZ?31b)i1s79B z8DX-=$U{hcxFcDON-uStFc_Ip3&hP{zOzB>E*9AI*GQQB1(4%tPtnyGLIFKi^;)iO zZd^uu+L0uv$4&AAO7@#RRHC{-XY~L?YMoz3L*h$(?hhU()>4>ufKXP#LhONaV;KEO z`J8H0{whPeorSdIV7ig zRy7k>OFnr<-$ry9XIM=bHp@JMWK{pK0-cw|M4}2<<*<)S-Dp0hNZ(SN24PMiV?qbG z_AwYyN$6T;Dj=XxgsO1dY?oKaoz9_Saz`PVRnD%_;DQL7|}!I8eAqYJ&Hh{`pU3 z)97|JO;(<$=Wb&+Ms4=;a8(~o#s;t^A=*?)s`Z^)lSH1p4%=YJOVEw2^tP%}K--)a zPk2JEfMRu98A)3~HN3vBP>aum(mAkKLW_kQw{l1F+7nEH`8|$_NK<_3kcSUxLn2{uHHr^PI(D&QTWnGG*B?ZtnL%>m^jKw&NL_2q zeG6_+Jx{`!dp=gTDOJXbhepDOqGvRQO_SXo-`OoxfnMmneuG3?3D<`ZmP-j4vN|;b G1poj=RSaYR literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_quick_open.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_quick_open.rar new file mode 100644 index 0000000000000000000000000000000000000000..ec8609f2774a29ecd330cdd21e704befdf5a7ab2 GIT binary patch literal 3056 zcmeI!`9IVN1Hkcd-`8M8awS&IbtK9$-?@+P+=naUh>S(iAsu1}wP++n$(gV@LJ}g{ zW?VxV+u=-!B2f|9jNNBn&;AGd+w=SjpV#MyH#IQESWiv@0$sIRR*;a8fk;b8Olwy_ zb{lz0O6^QgmrYPNf<2t*+;;z(GaO%Nx_L=xgUv6buC(yrIi69vqMR-W!k z?}(^=GH&>J-E$7?U2}kmNq#AW6^t`y6eI2agGMhE!M3#M z_fQ7iJx(UwTZBld^45Kzi%*C8sQY$PeP$1N9y0{|JMsIL-(a_jk57{o$xP;3e?8?ha~T zb*B7FN-f>PT3#)E6~V7O8PfF#KX_f(=$L~asKRfs14(mp1hBmQU?a*3hBPmEl*-Rwf2D{A>p9~ftg6C$VxEEFJ`arS$|c>8w_DQHW{Mb!=><_Jm3)Fv zcN+Mh%Xa&6Go6>BqOwmG;dVjJo8gF`n|Ib+_)bkbd#Wej0k9=zSaYqhJjO_6AxQqf zaetixV+|p;IE7MZKDOW`wuV@CJbZXc$e1eO1MC(gHu6H!gLuLfjn|KaFKA~(S3n0t zc-V@KO~De*2w>T=i@4jjE%<}!90TRhx}Qb;DR zwTpec@3B6W<}!cbqg(W@4!7A8cUd%hGujzXgFX917D(+KH86hyL3P`Sbap)Lk5ARt z)#TxW#y1ICI=F_%veemNis@#N%|;TelCuwbgN8}u>m<4DBCT4N;m5j}fhvY(D%PkG z7<6Di5fp4)juYn7Q^V0}Y9xd#RqIW3Eq-9`Xza6ZRIiNt;7TQMH7j7CVG#@5dq}nu zkdKu-t(0J}ZpYiUPrXHRjYH}jjuQ8X?P6x^UH{oS@+bNmYMN z+d{QcmHXfoD4U+U?{J4#hcB8?DbCO~uaQ4srP8RxN zc+g7Ct?CT7!)Fuv4Q3*6pF2aNuFO(63&CU7hA`W5?HQ2(V>AabsI4Mt*y-yS++mhN zu33I8MQJuR?yR*0yDcm?TnO~X9rhoU{1AT423P5|`1p$aw%}2!pUkVPLu|lmiQ?O; ziOn{+Bd)0+FXs$OOZl+2rdd+6r_$zhmQ$#>oe3lg9*eNHH5 znmyX6*sX-}sv5k%-wjmH5qEt@(*rhuK3NPxji^5O27y0Rd}FdDjhef%yHJ`3RI(3# zIkJd7tb9}57edzH?q{Vnu|8`|j?QPG@kb0IpG*<+$K+|xV;LvpZ$#U0kd2(!v4t&y zsSzjen?5buoHz&dflHrN-BxLd8xb{_J6ThXshiY}e}#FU3bj${!f5HscmDw;S=Ufy ze4UsNcRx@kK13-dBz8Pb0`ne-ysE?L*Nx8nzb3Gs~y1N5=yr@d6UBq4m53kVu1&n%Rw5N+`ICbr$W?@C<$?BVrW$)CleNtoo9PR z6S#|6eX%c9-+lTgYFF_3bn2F3}4q$;8?nXYG*qZ&x} zq;B*OnwSB?xSXH}6weP~x*iK&x^}T;Q=h&w$;xb}0z%22hZ#}AFC%Bb4^XO}!c3gZ zYvAPTv1g`g*xS;xj9Ul@Ij=E46$4w-V z_~dK21%aCu5M1X$YdCir(Y^>LOG=a6Q*n8%K_-63Df-IqME0F9t5c6F$EGm65?a*#ib67@QR{&^%|FM0mk?ut3Gmyk08h9ZO6~pk{GWssT29+2M zu=sgEs_$CeSQU1vaVU_mLT0Bq-=b8pd=(`Qp3+DAhnQ($e<#kqKN!E!!l<%dpX8&E z;3<-Yy3S&hv&eU71QsXRAL7oQ-MO>;DxZo&XG4YE2D&2W9CsZTo-fxjQ4DwuDg z#)q;Ot)c<8?$JAT5?95`AqluES^5!$) zetY+)ro)NKRJn?}I|u=<cPn(5rmRXA1+#ltKI(_xCKli$Fne@PDC#ZiB0nlney&C+aMC7XSbN literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_rar50.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_rar50.rar new file mode 100644 index 0000000000000000000000000000000000000000..247429a444c3239fd5a203a53b37e1890d0519fc GIT binary patch literal 4294 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_rar70.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_rar70.rar new file mode 100644 index 0000000000000000000000000000000000000000..247429a444c3239fd5a203a53b37e1890d0519fc GIT binary patch literal 4294 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_1.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_1.rar new file mode 100644 index 0000000000000000000000000000000000000000..bc4251112b1a78636d4b9c353cc8ea2d1aa5de14 GIT binary patch literal 9387 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_10.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_10.rar new file mode 100644 index 0000000000000000000000000000000000000000..f5666a41cf21c7626f46bb0601bf701ecb380bfc GIT binary patch literal 9387 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_5.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_5.rar new file mode 100644 index 0000000000000000000000000000000000000000..4b946253063af89db3de111a8f665c13b8ba8f01 GIT binary patch literal 9387 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_50.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_recovery_50.rar new file mode 100644 index 0000000000000000000000000000000000000000..bafa0801beaf426374c653f58d6a2d84d6aa6943 GIT binary patch literal 12585 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_1.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_1.rar new file mode 100644 index 0000000000000000000000000000000000000000..0c96917b11c1bf7b5ba9fd24bf383f3a24795226 GIT binary patch literal 1594 zcmV-A2F3YOVR9iF2LS->RW#QG0RRI5(5fYvKmr>h+zSSXCm;X-08pAa)dv6o33G64 zX>=}PX>K9{02@PP55FScd$m=VLq&UlwHO8xKr1ne@GmGlL7S)_Jz-_I00VKz`1U_|2;EmtcxfY5hXM}JaK<9i56_a7G^927%zr2i5Kz)Ikmk%FHbQ33O_1RzpDCf)H| zpn6DcXtE5k?N6PgcMVT+R_~a^c3OT$v9ZqcW=u^@`rh;{2~>+s;GZrdM1~~AdT5AC zyNRHNmts<#ZTf4mbwUZE4$&yhN%67|U`IhvHRUL~_IOsc_6Ap~YprSV`-?LR{DR^sPX(Mj5P-8KQ7P~ZbQ^C5#*G53Bo7}iHpsTWxG zFiy|H`LY2*Rnnj{VhS2L%~ouN9tZmje3&*QYTTR z$z#|A-$6k5KjW6cNbx~(sw7uWp>De$?yOd%90Kgxx<IEQJRjflGdI7P1TiQo(e;Ts0s<#twdl3lB-k^qyKoYEXtvVNX0JSKxB2sMOOl0 zro0yMCZ&dAM;vEwT6fLTR{w0Yeym)6FFWvP8MN>$%W8WPHB$$E6znfdOgw`O-xECspIHGQ@MN`?hlPa zG(LdS3++nQU^sUUn^DKg?Dl8eLC+-Tti;1e3`Qt=R(Vg0QTBzQ23BlbS_qUxMv}`P zd;@h&D_nOUdQnt@(rZRz+C+b@76G*1ORqp>s-F>31Gw}FM+QPCLW7RrY=c{^2pi3CaE zaK)e?C{R9%=vA*)$_)qu3^6FJ9SVC17;6;VQ?1-0< zOe8_H^+%0U%soXlWR64l1I01T+)9*(7`HjdQB=rZjf z2>~0@R?SwEwUo0)l58|!&>~GDkBu$xWK_L3P*z~*L>^YkkMlB17kTZ?2?|oy2Nxb@ sghD`hsk&X0N%h#KfRtcRIHD84RX10*^4iaHmPhcC^pAo)LIVW=0iV{;RR910 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_2.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_2.rar new file mode 100644 index 0000000000000000000000000000000000000000..b49595ad8cfcd9e49bafe05c5f26f0bc389f00b3 GIT binary patch literal 1594 zcmV-A2F3YOVR9iF2LS+A1U*g!0RRI6ErKRXKmr>h+zSSXCm;X-08m)f7n=Y833G64 zX>=}PX>K9{08-_f&33?{DxL1Q6!91mP8BW;$lNGZ z&ZrHx&=p0(vIYUDg-jda)9Nx4Q|GO&k6)NW$to4y%O^?z9Zt~3fl(}aOGS^aLEwUR zjZ5iBS{OP8BtTE|Y+xIqx>o-dEYMJ;Mkn4(j>$AlY6PmWo5583A;=ZzH$L54vrd&m z$`}KBRX^T#;H}d|lI}vC$hJ)7RU~ln-%|;OQnW+jLxW7xl+5u;P>S8KP^wYDHf&%K z2tfo3CikEVNQgvipQB1o=Uf#0fIwDqA#)Qs|3){a@YgFHcy-!zEl6esBXw*xPn_R&i{~*`ztEXJDS$?cVC^|@7EN{>C|d5fRJ0|k zQqEOGDh%K2DY;ADH)wcU=u+b)qZHs7LU-YZ3K^nFN36VW>!MIgZf+)oW>*K#fTFg@ zM~IbcrrLf^U3&lw+d5U{D`K!a`$e4q*=n!uOn)ojh^p38f;&4B=Ji8|832gF9ZK1K zP!{6BQ9F90eCTaK#2MPL&QnM+hUE=np-;wx#t<7eR{nS2y)EQMpX^*gDmP7T>Eh}% zaa1-Pr{tu^L`2)~yqyzE7{lP~Q5;fBzbeTVMncPIG5j_iNv2U%ekpQLHg}=AjK^2U z5KY;YO9oK1_v#s`?}bQv>(H_y(p!TfR~e z6#Gh5$^}FYFj00;*B|&zLHL6?jVx$LwI?$I?axnru1x(qz*aM>>OM7}M*RdTH4E@f z`@!3Aw2f5Isy#@qi9~X(G#$sAOC$)}m7Kv+?kr5q6qrJBB6OTIKS@g)clX4KP;&5Z z{bHI|k)!+MQyWKa!irAae@;y6>`?P!RZRjIC~?t6*;ocBdqGTkGg%_b1XC1!q5<)g zL(g18`8+a8CcMBwB&$*TvM86AGeIQ#?m=g|NOBmpZDCSRRjo@=ocC6h@kJ^;CPo%? z%$_KKP0uZ+F897vroLEs1mGm+|$)Ma{Vp6n(!;Ly&;kNljC_ z^y_$Er9)`u>u;AGeKSFJNjtmEkVq-Ne00ziPs}SI5yUB0D%Qn7 zkw!*J6eMlG15HAC_M9YSRF7U1jWB>jPyP@k_Y+I)tl?k(cv5_f7nk0qLZcrIN|nk< zkli^zz86p_{AHc=(O353?l~P7M+M&CL_0=Kz1oB+R^3&MS=C9M>_wX`k(e_}Ozooq zD*VV(6VN#1D>XxGq53aOGD;@H&$FLUQRG##Ko3+w%7s+kc@Rhk#Q_`I22Xf&ZDTcn zR*X0O4k1cL%28`y2Cq%+IqyLiPE=Rq@smJaM9@B8EjDFK(J{6pz9>=$;f*|>Y(m;f z9rB?bNqX+b0USF}Tg;x}KX_NwgwA(yaz_rffvH5dPGRXmBv;>62OeA9->5~%%;5*x zSWKid;=yf{Q@vwc(%98QWXoj#$+SwuXKqQFf>F3&N=B(dK~We%sO64GN=Crj88}Zp z(!Rx8?^f$*|5JFpMqq^cat8lRH)oKpFdtNR)5tB?yhL$e&5ZRbOTuqr?b#+$O9w|> zq|HLfzgvAr@=4c!Il}`sP0OyPJ#!iR0uEO0(Rg|ycc72>h s^z9}gfaXkwf}D{Suv1^4scipSLr_()6NB7Jjfn^yMUR3#LIVW=0W;~_a{vGU literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_3.rar b/arca-rar/vendor/rars/tests/fixtures/golden/stored_volume_3.rar new file mode 100644 index 0000000000000000000000000000000000000000..8dfd530c2fd824c1003910198ad339e6527cc148 GIT binary patch literal 594 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 i2F(K|vFn+C0(V%x&>iSW4h;7o3=X%R6*#nXn81 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R01 b/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R01 new file mode 100644 index 0000000000000000000000000000000000000000..bcf79e740302f5e889077a3e763f6b7bbc73cbbf GIT binary patch literal 2000 zcmV;>2QTPFoLnFS0ty2|O;t=(NiI}aR2>I@uwXPN zH+h3VZwOkLeoS6s2Q6u$ek#n7la77u|oMSxw{kUR=%44Jz@!{({}MnIui z;8^}*mC1J?U|qZx_jrE-;psx{6z@ILMLimu4HH+L7~z3$7mf$?1Hm^ zLE^jKY_sZj#>%5$0q+2h0L#ttAKdaK0iHqU(K{9l+6>19t&5X_0m(l- zYSifma1PrA&ndxm$A6IyLBwfzG7BODK*f@%^I2xZSnV8eco5(KJE=?>GFO{i0%Jfs&@DWHi0}2vHs@r&Io<(Av1`>@^O~ZsNg-tIw?=0-Sh&6 z0oEy?Q5NU*>+U(lByK=0@7*tj&G~OI`eb29}-|0LtomE=5z3+_{oqKH4Bn}l~GG z3+}OOKO)HL3u52Ij@(8d1Vji1bseJRoz%0vnwtR|={b-;)~Tse$41(S=|$1ZJ| z?vrR6ksr8>9tKe-Kz;36R6Gg$-7lw+U~bVpATcjyrON^DPxm4V#}4k&Nn z$o-G7L1>rz+zBr=9l$QIdE$p%%EA!PHFGq-65W6i=5YcK;OJ5=L}%EgJe%*ikNCM) znG*Ss)Epy^piSgv_|E&0khq_ZiOVz>AaM#lA)CenmPX1G4Tx31*4&ZQKVq%7H&o|7b~_ zgCCIU3)X$`3As90xDw}!_>hK{;9zW&NELEb|u0eB~WYBcg$O%7dV`B99svvqx#K3!LfNgPh>GUF+YmJ!QEsx60MOd z*rc7MK;%-sD4F7VKu{3&KLbKZazX9@OS-9>4Ppvlv3KG{z5x-;w0b6!VhnIrKNE+I z+YPR3RN^@Oh)&qmfYe(ESHr?OQW-O6EHK3l={Bp&-G)IXSy@T;7emC4tdv z{7+|rSK@D8r(yFC-bs4pI`DEP-w>Z78O0ua%4fvTyCIt-5C=wP@PQXIk7zakPPi~< zf#@%Y|JwT}K1Na426ikAumELxD`U zWFInw?){F0j^q{ONp-HDV$ iFdb*P;8_kv&Fm_+hUDPR<|e%3_zo=>=<8M|Bo256+P6Od literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R02 b/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R02 new file mode 100644 index 0000000000000000000000000000000000000000..1f275211622bf27c6c7bcd745e10926d88baa2e9 GIT binary patch literal 2000 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R05 b/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.R05 new file mode 100644 index 0000000000000000000000000000000000000000..76c079ee3d93cbb290aa7567a0fecc313ebb1b20 GIT binary patch literal 2000 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 Js7e82$N+WY1S9|e literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/CMULTIV.RAR new file mode 100644 index 0000000000000000000000000000000000000000..b6706cf75008c733e28c934c04831404bdfe4de9 GIT binary patch literal 2000 zcmV;>2QTPFoLnFR0ty2|O;t=(NiI}aR1c!`zSGdi zKUwT6JwR}k?EOgNdi#;9!Yw_|mDvk$W)I(&@ZkP%H225QW8^`JR>;Qu898LfLIIR3us3lYYK&E)_oq-f&km@G_lcB88Om_~yLF)jP zG&USKC%mTpg*Hc@vrA2>2{=RSAZR#nbV3W6Egc451<*jiAiyaQUC#ePNJ%4nRG!*BXEr88MsO|F{g8+Ju7x`dH-kCjNCO~5rx#II5D5ymHei_On60q1bM)^X z#tRM&S0{J_*n?`@_9l81dI$XHLzS(AgRkfc_$+QSiN!8)ivmbE%tD?tP02=f>5Mca zH8*)rNcq<02J{ko9ZUnAm){I}Nv;#YcOc?gsaka5>dSO~iI_?Z*Q^;2QdMACcwI%RoERHrz%#M%s-ZG6ab;hI(oXI{MK9-DAwuEkUS!7(AMCna8;anD(pb8 zPj%{`990i3%JpPPjV?zAZoWVi)!4j1E01{o7nUM;ZC8sO;oR~NIC<1g>?>or#bI-e z@1pOx>T|iZ9(aQ4wr|Xk4ZbZw%Y~LXx-Jfnr;Fe2L)Rtm%Ep0V8;aZLN3;wanb&No zu}#OYAa(OS%N3mapxA(QC{70hqSWWG0C6sSC?dwM6)Zvb8*uP!^H~K*J~7R|lXvBS zTN3<}?)eJ__>kuIIJHjB$oS)zMp?&J9Wxx4$W>K`fKVdp%vhdsL%A!V;7PlyCx=1W zg4xtc3+T->5nyv_&y&j7{E8MqmZSE>PZ7ngbQcavwpM>;RZqVqTgH$(jg z0W#o242*!gi^6(96GJb4_lY6cF>@Jk27ya~zp`Eq4`~2Fk#E>W!JwD%HD6=Gy33o? zgI-IV<~+QJ#!wtZ6LzoYFkD|9p(XeYFW z^#aEdsPzRe1dQ=)IDqR4z9d#a_oz(~XXaEeaxecxGYfq~NyT}U_F z{GD-?pl#y?PAUQhjmqdS9kB`OJIw(v1EBFihgxodlE`2axRLLnRkQ&>4*X$fz~*5G z5N6Q6oCtf#Lp($8iwyZZl4-GUIt7ngm3c0&{68}U3%I27AkR@)*d~Wz0m*Djcu80N z4_i~XC@-88y2)4A`62i-#>f-EIry=EnzMM*M|9GMsW`{Ci?g{O_oM{(JjWLKcV6`O zqB#5IbQ=Xf%6AD^3kF^V_SihQ#J+_CjUPKr0YIKmh#))=(BOA2Ax6OOLt=x2b4aD} zcfS=_Fg)POqAz?;SO_iL4AbJK6RhgY1-P3NsNYx%P;M|9+Ju2Vgc0H& zAb{J&Ay^OYMJU*@T#INyw}D`R!13JzOSC3B9M4oMc0E5pB;tIgy{gURNIomm$w2yA z*YpfP!OSoD!($<_prLXvP5}>*vTRNPz5!}bqgf4$4pxE>?E<3_#9DG$z+)rNs_W(i=a0`x4RqGxdPe_61 zgCY7mPeG6qVVLV3P2#97i(cSC?ud9>*5>_&OQeE0D39|Ur?=vTP-r&1*w@%J85F&N z0tn{--QvE0P^R}$@1e^1q!*a)Xg|FOU(tcU(Ar#I_CR;CA9x(%AzlS3@{nQ3f>0=Q zFt;M_a7WP)Zu36_^S<%ZInoPOkZdP>VlA-_ITgXTb_qPpLJqQ!eN)oki3=9k) zoS7xZpl&xOMuCBelflE)$H!kUBqGEkH76%uMsH#aq}L?JD+qNKDaRgaeo03&oB A;s5{u literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/EMPTY.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/EMPTY.RAR new file mode 100644 index 0000000000000000000000000000000000000000..057b8cd79d03cc856d11bb556bf17071cc832fc6 GIT binary patch literal 37 kcmWG?t&3x4XkdT?IR*vG*)a+XOq>j^z5yYTdQP5x0BV>9DgXcg literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/FCOMM.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/FCOMM.RAR new file mode 100644 index 0000000000000000000000000000000000000000..1f608f3d33a35fbaf594c071f7dd2195d35a01a1 GIT binary patch literal 75 zcmWG?t&3x4Xpm!IU;ts}Of?20k2x_4988=H9kFBbq>`x3DL literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIFIL.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIFIL.RAR new file mode 100644 index 0000000000000000000000000000000000000000..6b97f66b5501e9e2751b073687895945273ab2d3 GIT binary patch literal 106 zcmWG?t&3x4Xi#KeU;yE~DmexP%h@ps3{0F19V&cPhw=@$voz2@l!1_qbM0O_9@I{*Lx literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R00 b/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R00 new file mode 100644 index 0000000000000000000000000000000000000000..f7354245390ce200efa15062cd444d8a3b9ac3ae GIT binary patch literal 20000 zcmV(rK<>X%MSflf0D<~V000000RTr)9{?aZn_M6R0tx_9K~6+ZO)f%7PE4UH4&uNZ zmBLKCM{1ej4fIfC^gV8DML!;zGaW~l78~i|LGgUq)_Fg*y@%*0bKo= zRv#i4$8qS%l_)l+zQz#{YFSNA84i$bS3MqYU!=6)MH~rsK9ThceM7YK9Y{L~uM)CP z4iQaEGA=?|Vt~GJgKQ_~)&>pFOY3P*B6Y$CBA*ngfPym&gIrKEsYhlgJBEog1ZSh8=`+8BbBdQu!BL?ZbW&GH~d^;OxSQdWkzeUcPyWCLV0leip;LSriCr^k zJ4x@NK5^#q(IEw|T1R)mNL)UKr)3e$f=v`L+ghV80wpJc62w^}!J`+xQW*mqMPjgt z0zBT9KsTaj05OyObKYF}s-M>|Z~$+-iE&~&!(yLdt(!o@(mP>W1D{A-m*XQ0fL?wi z{HHq^t7OdxV(3B&fBL+m+{d!hS^h~LdrYNj0@%*3unagJV{pH59+yy(7rcVRx*ceD zf|Z4APK0G12aNoAT&BL3RM(O4k<+?fk?p+V1D?&6A-d&$`JAuHOT!4^NG`3nt+$DR zkBjxo$Fy7&UqZJh7xsyUML@V{HuNoeL9&d2716f^reA+s?kozf0UFJSm&)pry870M zh*#>!xQYd(e_*fhuzyQkwT%;!@qY4L%tGa*J~&

TkRi{gBO%O2U2$Rfmh|p503T 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R02 b/arca-rar/vendor/rars/tests/fixtures/rar13/MULTIVOL.R02 new file mode 100644 index 0000000000000000000000000000000000000000..46fbdf6c95633550d929089ca8a0a7c01a98bc70 GIT binary patch literal 5688 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/README b/arca-rar/vendor/rars/tests/fixtures/rar13/README new file mode 100644 index 00000000..d978a3a0 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar13/README @@ -0,0 +1,49 @@ + �â®â  à娢 ᮤ¥à¦¨â  à娢 â®à RAR ¢¥àᨨ 1.40 (beta) + +******************************************************************** + �¨ª ª¨å £ à ­â¨© ª ¤ ­­®¬ã ¯à®£à ¬¬­®¬ã ®¡¥á¯¥ç¥­¨î ­¥ ¯à¨« £ ¥âáï. + €¢â®à ­¥ ­¥á¥â ­¨ª ª®© ®â¢¥âá⢥­­®á⨠§  «î¡®© ¢à¥¤ ¨«¨ ã¯ã饭­ãî + ¢ë£®¤ã ¯à¨ ¨á¯®«ì§®¢ ­¨¨ ¨«¨ ­¥¨á¯®«ì§®¢ ­¨¨ ¤ ­­®£® ¯à®£à ¬¬­®£® + ®¡¥á¯¥ç¥­¨ï. +******************************************************************** + + Žá­®¢­ë¥ ®á®¡¥­­®á⨠RAR + +1. �®«¥¥ ¢ë᮪ ï 祬 ã PKZIP 2.04 ¨ ARJ 2.41 ­  ¡®«ì設á⢥ + ä ©«®¢ (.EXE,.LIB,¡®«ì訥 TXT,...) á⥯¥­ì ᦠâ¨ï. + +2. � ¡®â  á ¯®«­®íªà ­­ë¬ ¨­â¥à䥩ᮬ (mouse, á®åà ­¥­¨¥ ª®­ä¨£ãà æ¨¨, + ¢áâ஥­­ë© viewer,...), «¨¡® á ª®¬ ­¤­®© áâப®©. + +3. ‘®§¤ ­¨¥ ­¥¯à¥à뢭ëå (solid)  à娢®¢, ¯®§¢®«ïîé¨å ¯®¢ëá¨âì + á⥯¥­ì ᦠâ¨ï ¯à¨ 㯠ª®¢ª¥ §­ ç¨â¥«ì­®£® ª®«¨ç¥á⢠ ­¥¡®«ìè¨å + ®¤­®â¨¯­ëå ä ©«®¢ ­  10 - 40 % (  ¨­®£¤  ¨ ¡®«ìè¥) ¯® áà ¢­¥­¨î + á ®¡ëç­ë¬¨  à娢 ¬¨. + +4. � ¡®â  ¢ ¯®«­®íªà ­­®¬ ०¨¬¥ á  à娢 ¬¨ .ZIP,.ARJ,.LZH(.ICE) + ⨯  ARCVIEW, ­® á ¡®«¥¥ ¬®é­ë¬¨ ¢®§¬®¦­®áâﬨ (¯à¥®¡à §®¢ ­¨¥ +  à娢  ¢ SFX, ¤®¡ ¢«¥­¨¥ ¨ ¬®¤¨ä¨ª æ¨ï ª®¬¬¥­â à¨¥¢, ãáâ ­®¢ª  + ¢à¥¬¥­­®£® ¯®¤ª â «®£ ,...). + +5. ‘®§¤ ­¨¥ ¨ ¬®¤¨ä¨ª æ¨ï SFX  à娢®¢. + +6. ‘®§¤ ­¨¥ ¯®á«¥¤®¢ â¥«ì­®á⨠ à娢­ëå ⮬®¢ 㪠§ ­­®£® à §¬¥à , + á®§¤ ­¨¥ SFX  à娢­ëå ⮬®¢. + +7. “áâ ­®¢ª  ¯ à®«¥©, ª®¬¬¥­â à¨¨, § é¨â   à娢®¢ ®â ¬®¤¨ä¨ª æ¨¨, + ¤®¡ ¢«¥­¨¥ ª  à娢㠨­ä®à¬ æ¨¨ ®¡  ¢â®à¥ ¨ ¢à¥¬¥­¨ ¯®á«¥¤­¥© + ¬®¤¨ä¨ª æ¨¨, ®¡ ¨¬¥­¨  à娢 , ¢®ááâ ­®¢«¥­¨¥  à娢®¢ á ¯®¢à¥¦¤¥­­®© + áâàãªâãன. + +8. ‚áâ஥­­ ï ¯®¤¤¥à¦ª  ANSI escape ¯®á«¥¤®¢ â¥«ì­®á⥩ ¢ ª®¬¬¥­â à¨ïå. + + ‚ ¤ ­­®¬  à娢¥ ᮤ¥à¦ âáï á«¥¤ãî騥 ä ©«ë: + + README + RAR EXE -  à娢 â®à RAR + RAR DOC - ¤®ªã¬¥­â æ¨ï + OPTIONS DOC - ᯨ᮪ ª®¬ ­¤ ¨ ª«î祩 RAR + TECHNOTE DOC - ä®à¬ â  à娢  RAR ¨ § ¬¥ç ­¨ï ¯® ¬¥â®¤ã ᦠâ¨ï + RAR_BBS DOC - BBS ­  ª®â®àëå ¥áâì ¯®á«¥¤­ïï ¢¥àá¨ï RAR + WHATSNEW DOC - ®â«¨ç¨ï í⮩ ¢¥àᨨ RAR ®â ¯à¥¤ë¤ãé¨å + LICENSE DOC - ¨­ä®à¬ æ¨ï ® «¨æ¥­§¨¨ ¯® ¨á¯®«ì§®¢ ­¨î RAR diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/README-solid-flag.md b/arca-rar/vendor/rars/tests/fixtures/rar13/README-solid-flag.md new file mode 100644 index 00000000..4df35096 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar13/README-solid-flag.md @@ -0,0 +1,12 @@ +# solid_flag_cleared.rar + +A solid two-member RAR 1.4 archive written by rars, with `LHD_SOLID` (file +entry flag `0x10`, at offset +17) cleared on the second member. RAR 1.4 headers +carry no checksum, so the byte is simply flipped. + +Both members still extract under RAR 7.12, UnRAR 7.20 and rars. Below `UnpVer` +20 the per-file flag is written but never read back: solid continuation follows +the archive-level `MHD_SOLID` flag and position alone. + +The second member is 44 packed bytes standing for 2700 unpacked, so decoding it +correctly is only possible with the window carried over from the first. diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/README.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/README.RAR new file mode 100644 index 0000000000000000000000000000000000000000..14d01c9a7986879072bb3a3eef87f0aec8e4bcd0 GIT binary patch literal 1112 zcmV-e1gHB_MSflf0Dv|G007_z004R58vx^CnOq)s%ZSBbeswh65%m`L!8BVi^au7&x@r52Hy`89ihO z`i;bjUvMNL3fNP>TTure)|L-5QR2i3cD(9af5O&7|6{r&+<*ikNoYcRX&p6S#^8HD z*G|`c+6?wfRK&180i__pE1FXNAgluvlg0pf4*xaVkREAdwa(@M)40to3!pHNS37!t z&Jxix&+2dECPh@>1xWPyji1zSx51yAca^4H1J>~a;m!_e>?nR@C4aPbNV;`vRgPAIcFz z=VHoKome~HnV@@bQlj5)2eRw)@`(kJ+LODp(5b5lzRhSAp2YT@>IcXQAVgW?N+ygT zx6}ZI)#pDitm=2^DW!_=BZ;)|i6vw;9HHkH0U%+HtFRQcVENG^$ZkqVfG=>7^%;vRRF+u3`9fuXhpaCEhtM+8`?YXAhSzZ$zl{PA z{oO13Tl7+twblqcwuFG;B@KPA^^fen`GDm&GDvauY>;ixRO4XFvvuu{N5Ih8@*=bn zEc=MQdHHsxnxnX%e>tD$t@V@H^sA5%V3FL~V%i;t|0#z){3 z{Ci8fZ&-d*XIUi5;8$u;eg-ZqG5d0~#&=_-LXk z`HE1r--+06M9Z|0;mps-smw`LN0q)Zj7%8*{(d7`SluIU<%jgj+{-)2R%udM7{f>M zPQ6x6LgnrAOfMsC;{#16Mz!xXul{c>VknYcg1%r*b@SyezD7HoJT7}$8xa4Ff4AoC@d>@Zwg_%A|V{1tKNN|ZJXFH}Uo{@u1 zGV`P$)?_z9Y4p%=T`fLAW6P%IGQH*s$Yq~6W<^S#FMIkuDqHq3?B<7(_zbIMb7)*1 ziL1Dv#=}~lr-3{5zru<6s*@8h{iJwf{g%iYm{U+fsWQpZaOe>7CTbuG@@_KxtW_?O zjort52}@7+IzhGe&)Kc$*aBe4gr=J*JE|>tq5l&>jYTTeiggunJdpeQR8p!#;q-qW zIbhId4(4i?O_#j6?AY{EfH@wJLKYeULm^no$VBZZyj^pc29tKw`05&&(N0mJC>H3D zR7mGVa1pe4Saslvw{@OrR3NcIB9sOy^hdQ#%b~}Hb4wYjnb0!724uBuc!6GV(S_JF ziO>={BoaK^6!IFrJN2B_ z2{Wp(SZu3h=HL7?GRjOb;`GM)kO0~^_MePqt0kaJ4QlDOo|oV$n|ztaI#$Wr$`29q z%Y*ziaEQI$LP5n7>MtR=lU2&*U?fo_Q6Ny$qc36NS=Ddn^`+0V-2?M1_oTAa)ibrR ePW(ZF>|=Qw;*reyx$ySCb^AOce7pw^`xfOyCn|UV literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/README_store.rar b/arca-rar/vendor/rars/tests/fixtures/rar13/README_store.rar new file mode 100644 index 0000000000000000000000000000000000000000..413f8411a495e3ce4e2e0c2fc9f785e5b23cdd98 GIT binary patch literal 2050 zcmb_dO>ZMb5Vbh4Ql$I>E_Fe2R>LS+!iTseS)&-1BuXq2tq^Dzd{_yzh_E0oXxTdm z#EAn^dpsStXQpfZQcq7D6FF=D1zvaCUgy4+{MqHISMR;5K5qT`<(udD8%0#9{)E7o*tA>j7&-8it4hy#%Vo8l4R27)Rk4F zs*>}Y0VhJEa~G)P?cY4eKCgi6GjhCw>2SRUitakDiRh0?bD}4bxI&G2KTyXVZ^iT* z=Tf4BiZd~zu`H;jqfZ~UkLX^!xlM|8jz7W2?Jd%Rdg$#xr5!Oo_oW!-oKQ1vowcI) zL3=j}5t2G*ohXju4XUgxrM{u+LRjTmTVJ~u)1RWpR!~J?OY_SN66#4oN?U0z<*?#{ zn%_NrcHWKPtr1QkpQMcSrRvv4TqzZK07+#Hqp8V|etOdVx%-1J8d0u#jO-Z~LZ=$K zxi|>x>%SY*Up#;gNU3FMq?v%A5jD@Be*5H`jo@icB7hqtoX@7$uvy9ANZA`-_I6WV z__~B~l1$P-i?OmYztIepGtSjmf-r$nft-;~!GL8|>FUl|1ixFG^bTQI-lnDi8Qf3t z7Fd@XfIyWIiQ{4#V8At#F^E$EvnZ5raC=E`vPv*WHS$6g63qCyMLfljI*K7O^n1A9 zjN5xHOeuT=a024*eco=JMx-5`zz?q!eCU%3% z-p-1e3nhKz`zw(pSGi0vq(LV);U23~!*T&j*O?f&Z2}3=Qz4BAhN~9FS*Bn9$5;6v zroR^rP$>);8%8S~stCK}TEY9iASz*rz9M68>lLc95Lm+wmuw1WeW*^t?JWs&1cDTF zb}eZ+^t7#Jbm0(PFH90q!d1W+)L0;K(};8zsUtk(!PwN9t<8LLK8)#wnJYVhZF6+6EnD~sL zBV30SaWkh*&t~D~oGq)L?(cL?4qB)4>TI!8Q0Jv}H&VD{9Urg~rZAnPH8z$n`T*m6 baMD^dx%AMC7(4Px>H+KoxT{yxG?e`xmp}dw literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/REPEATB.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/REPEATB.RAR new file mode 100644 index 0000000000000000000000000000000000000000..86851afadc26536fe34036f23182cbdbb423fcb6 GIT binary patch literal 337 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/SOLID.RAR b/arca-rar/vendor/rars/tests/fixtures/rar13/SOLID.RAR new file mode 100644 index 0000000000000000000000000000000000000000..61ee5d2dec048a4b6f002efb185baa5d3f4b3d3b GIT binary patch literal 12789 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 Yg+zpS<`rkAq$(7bCZ%K+>G5&_0F-1BS^xk5 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R00 b/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R00 new file mode 100644 index 0000000000000000000000000000000000000000..39c5dc23271e60ea6a13690d649a6882d8b82eb7 GIT binary patch literal 2000 zcmV;>2QTZ>VeWk&6l3vZj3#jd=-VsAg&3QWlcg?u1r;mWu_WuY!ltBX0N`K_-W5* z`m@0iRsrr!@^)1yV3Gk0o}Q7^WjhlyKlSOrPjUMBZ?!i4);%T#L+qI%TjHG2X}KMn zS?5|~?VUOes1{*UYY5sL1O~&E50t_I;Ig3j`w;nTL%Jhj$s^as%jnWLIroG)mn__e z*>Q1pLx=h80N`v3Zpsw-UprUTde{D_L&%bUaeSKd!6-9Q*6`2u`;uIbw0(vbM7;^PZiiE@PNN3ew_=C~p*U1y zeboV05I}E19>|pUbV8m$M|A2pNKK>nWOn59iAyin-1bfn|33PPqhOxc$Pwl&h(|cv zwjt-_dY!ZsN^*oa>aZZNx=xoZOZilg?Y`^vyJ)>&$J!NO=X6=ul(BIwF5d1y9k;J= zE7bpYNNK^*UG5osd#dQBZ!xH-UK7=BDkj>GasTUJ@I&LgJ0n&8_t>fduy!>p)1gQA zyARDzjXv2uuJ+S%i~)^``p{?i`yfZRyDrgs{C4*Eci=ttFUuY4@Y8Mbnr!UJx#(~R zJRuA6>WxXO0WC9dBo1O#{nYZWBnEu^xbQJZz^M+8o=SkhPV;9^!rawG)#kD7#Vsw{ zF(XA1_#s9gRmtWAu1%C5i%K1rTxD@d+f=}ZwK{CibaQHZsn+$-g3XPx>aBwk4=A#% z$0@Fs769{%wsQ|=ehMlGm*&f5aPxD;LRoqVPT{VTDn8f6@Qt>5BLzc%%vRM67_l&ADDmAX(AY{lk+vG> z@>SMc(OS{!q%FKIBJjZCkEE#U(f3f&ES{YC&P3zQ&&zesX_)wEN!aJXpAxDPH{Dhz ztOPTc@PNynJJK+<5YGt`eCWwIvc}MW6rcI~P2`m5I9o;KmW4Hk+-yg5*JG zbl4Qd(?^#=J~x}@yYBCFbilILnfYx4Jl7HOYMyk>BCkib3jDY_ND2M&@8P*OkNyk` z+Fp$ZiFkGtB*{X;KV@Q>@zl`Ci6B2WsR4KS^w7eTilJI)(4JCv_v&K&Lv$5!vNvew zaqTkP5U^&F25|K*&S1ahi}`-btagU8PP5WSH+U;x<8_S|SXGig3Y}ek+)d2MEd%mu zwtl}b>e%xI)w~LxXb!*;LhnwGrbSgjWMYY!1>BUH`!VPebk?wa4Pq$CX=hCI$#^l} z5f9_H0B_b_F?fp-y0`)i+I`6oNTuQa$Y-p;iE_IEYr*4##(Rq$%l)VeIW#l*@1?G; zM05dF2HnsR1+XY!2M2gl!>iViKab9yI`^=U`qD_yk`*KQI6hXN7%q+HMFsJgrmu_5 z`Px?v-clw5jR6z3v3XbkN3xF#i(0(837K3a)4kA0ZF@>T6kX@lv$R4GbHsH&qKndUyR<$-2?LATN+-=Ls zU-sL`RUkE9+FnLrD?;Pe=03E=$*t`t9qPcHuoDuZPL+y=o>5fPw22hAzhqi*rN*eJ zv|qUz?S86?g%&$YebcyOiERoIx=U5rFvzbXHM zH}nd)@)H>n$GqUyy8608v1~+;%n*U4RatrqaT--5kuktb$liZ!sGJ$;Vz};jfHlv^ zf0HX{5)@owMitkUbH|mtxZ!zXdJH$c6)|DJ>5Ds{Lz@|mfWcPRb}6=K*~Zw1Rwm_7 zSx2l##9R|;aAngK>Hcw>>MkiysJNtOB3`rgu|NtQ6~(fuC={cVe6YMEieV5`^grE_ z#fUocCsR4r-X*rW33SYN>0PYpM$Jx>GA?rcd7$sUu>28WiYCwo^ioO(YIYLbHwMAT iTwMy`UB%vP)N8A)nEM$DoTS!+FfbHzZ_6boyHC&rB=olc literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R01 b/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/ESPLIT.R01 new file mode 100644 index 0000000000000000000000000000000000000000..65f5a83933b26f06057ca58f236460624ba609ec GIT binary patch literal 923 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/README.md b/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/README.md new file mode 100644 index 00000000..b304284f --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar13/encrypted_split/README.md @@ -0,0 +1,9 @@ +RAR 1.402 encrypted compressed split member, generated by the original DOS RAR.EXE under DOSBox-X: + + rar a -v2K -m3 -ppassword ESPLIT.RAR SOURCE.TXT + +SOURCE.TXT is the first 32768 bytes of ../CMULTI.TXT. The password is `password`. +UnRAR 7.20 tests all three volumes successfully. The corresponding unencrypted +RAR 1.402 archive has byte-identical packed data after decrypting the encrypted +volumes with one continuous cipher state; restarting the cipher at each volume +boundary diverges at the first byte of ESPLIT.R00. diff --git a/arca-rar/vendor/rars/tests/fixtures/rar13/rar140_av/rar140_av_patched.rar b/arca-rar/vendor/rars/tests/fixtures/rar13/rar140_av/rar140_av_patched.rar new file mode 100644 index 0000000000000000000000000000000000000000..1501325e87ef871f2f90753e5539f91ede7f9b62 GIT binary patch literal 91 zcmWG?t&1~dSfIlom6^+QYn^iE42QFG4YaL3#inr7ozA%F$0B_1?v!ArXo*98`!uXn u;!5ftJ!4~FU;yC>MhXlkbmznMhXlkbmzn|VyI{rja3j}Vr5O#E2${q-||&%nt$@!TfdzaYBtoIIDU3IK!1HY)%C literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/README-crafted-legacy.md b/arca-rar/vendor/rars/tests/fixtures/rar15_40/README-crafted-legacy.md new file mode 100644 index 00000000..82f5b394 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/README-crafted-legacy.md @@ -0,0 +1,37 @@ +# Crafted RAR 1.5-4.x headers + +Hand-built edge cases that ordinary encoder operation does not emit. +Compatibility observations are recorded with each fixture. + +## empty_compressed_payload_rar30.rar + +A 61-byte RAR 3.0 archive containing `empty.bin`. Its file header declares +RAR29 compression method `0x33`, zero packed bytes, zero unpacked bytes, and +the CRC-32 of an empty file. It was made from a stored empty archive emitted by +rars by changing method `0x30` to `0x33` and recomputing the file-header CRC. + +On 2026-09-12, rars, UnRAR 7.20, and bsdtar/libarchive 3.8.5 all accepted it +and extracted a zero-byte file. 7-Zip 26.00 recognized the archive but reported +the member as an unsupported method. No historical WinRAR or RAR.EXE result is +claimed: none was installed in the test environment. + +## zero_head_size.rar + +A RAR 1.5 file header with `HEAD_SIZE = 0` and the long-block flag cleared, so +the block extent is exactly zero and the next position equals the current one. +A reader that seeks and repeats spins on that offset forever. + +RAR 7.12, UnRAR 7.20 and rars all reject it, and none hang. rars gets there by +refusing any header below the 7-byte minimum rather than by comparing +positions; either route works as long as the walk cannot stand still. + +## solid_flag_cleared_rar15.rar + +A solid two-member RAR 1.5 archive with `FHD_SOLID` cleared on the second +member and the header CRC recomputed. Both members still extract, because +below `UnpVer` 20 the per-file flag is not consulted: continuation follows the +archive-level `MHD_SOLID` and position. + +The second member is 46 packed bytes standing for 2700 unpacked, so extraction +can only succeed by carrying the window across. The same edit to a RAR 2.0 +archive breaks it, which is where the flag starts being read. diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/empty_compressed_payload_rar30.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/empty_compressed_payload_rar30.rar new file mode 100644 index 0000000000000000000000000000000000000000..f090e66afa4638ac94677bd2280e490f28e504f6 GIT binary patch literal 61 zcmWGaEK-zWXE;Bhn1O+p0Rkqfmnbx7LOBc!%pjJSxK6CBF(<>8Mh1q|+=7xyy`;=M E05`e|82|tP literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/README.md b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/README.md new file mode 100644 index 00000000..d1738fd8 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/README.md @@ -0,0 +1,16 @@ +# RAR 1.5-4.x Encryption Fixtures + +Focused encryption fixtures for `rar15_40_fixtures.rs`. + +| Fixture | Password | Source | Purpose | +|---|---|---|---| +| `header_enc_1234.rar` | `1234` | `node-unrar-js/HeaderEnc1234.rar` | Minimal third-party `MHD_PASSWORD` fixture. Used only to verify parsing without a password returns `NeedPassword`. | +| `header_rar300_password.rar` | `password` | spec repo `fixtures/1.5-4.x/rar300/header_encrypted_rar300.rar` | RAR 3.00 `-hp` header encryption. Decrypted `hello.txt` payload CRC32 is `0xa538535e`. | +| `header_rar420_password.rar` | `password` | spec repo `fixtures/1.5-4.x/rar420/header_encrypted_rar420.rar` | RAR 4.20 `-hp` cross-version header encryption. Same plaintext oracle as the RAR 3.00 fixture. | +| `per_file_rar300_password.rar` | `password` | spec repo `fixtures/1.5-4.x/rar300/encrypted_per_file_rar300.rar` | RAR 3.00 per-file AES-128 encryption. Decrypted `hello.txt` payload CRC32 is `0xa538535e`. | +| `per_file_rar4_libarchive_mixed.rar` | `password` | spec repo `fixtures/1.5-4.x/third_party/libarchive_rar4_mixed_encrypted.rar` | Focused RAR4 encrypted-compressed member oracle. Use member `b.txt` only; historical RAR 3.93 validates it as `This is from b.txt` with CRC32 `0xa9fa1485`, but rejects later member `d.txt` with a CRC/password error. | +| `rar4_junrar_password.rar` | `junrar` | spec repo `fixtures/1.5-4.x/third_party/junrar/rar4-password-junrar.rar` | Tiny RAR4 encrypted compressed member. Payload is `file1\n`, CRC32 `0xe229f704`; RAR 3.93 tests it OK. | +| `rar4_junrar_header_encrypted.rar` | `junrar` | spec repo `fixtures/1.5-4.x/third_party/junrar/rar4-encrypted-junrar.rar` | Tiny RAR4 header-encrypted archive with the same `file1.txt` payload. | +| `rar4_junrar_file_content_encrypted_unicode.rar` | `test` | spec repo `fixtures/1.5-4.x/third_party/junrar/rar4-only-file-content-encrypted.rar` | RAR4 per-file encrypted member with compact Unicode filename `新建文本文档.txt`; payload is `aaaaaaaaaa`, CRC32 `0x4c11cdf0`. | +| `rar4_sharpcompress_files_only.rar` | `test` | spec repo `fixtures/1.5-4.x/third_party/sharpcompress_rar4_encrypted_files_only.rar` | Whole-archive RAR4 per-file encryption fixture with three encrypted compressed files, three directories, and compact Unicode filename `теÑ�Ñ‚.txt`; RAR 3.93 tests it OK. | +| `rar4_mixed_visible_names_password.rar` | `known-pass` | generated with WinRAR 4.20 under Wine | Mixed RAR4 fixture with visible names, one unencrypted stored member (`1File.txt`), one encrypted compressed compact-Unicode member (`2中文.txt`), and one encrypted compressed ASCII member (`3Sec.txt`). Replaces the old `node-unrar-js/FileEncByName.rar` partial oracle whose member passwords were unknown. | diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_enc_1234.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_enc_1234.rar new file mode 100644 index 0000000000000000000000000000000000000000..628e2f245634a7438cbdb1739b7be9776adca78e GIT binary patch literal 356 zcmWGaEK-zWXE-;rxPgI}0ToO>zxuV)JGXzgy=P4J(7JF??4snE>UPSjF#Ly1OSaH{FJJ-=-G# zP}3{QJ3k)eOlD@t_f_+R*_Qe)!fVCdUECU)y-R!Y@>sTSHVjIP+xy?bg<+Ha>s70_ z`5XJ*ex|yy+d7QPeZ5j4Z9RET+#@52%jeYiqa#l> z?*4c}CS=h|4;QQp$pnimp*$rBjY@&8HWFN3M+*G(4n zZhutDc$eLuqi)Llo4E>VYaZOndcv>3oV%!De)aB@#v@lAf4ceqbYFb+p=-`v;`wIW z*|%Jniq>+>6VXoI#-02(T*7ePsr@&DQd5}U{+-Oj?7u$ia9ddYPnf-_%8U*6H|?I? Mc)-}Mu}?by0ON5@qW}N^ literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_rar420_password.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/header_rar420_password.rar new file mode 100644 index 0000000000000000000000000000000000000000..6dd7d8a7696bf25c4f0697a0ca5cd7bcba257839 GIT binary patch literal 164 zcmWGaEK-zWXE-;rxPgI}0RlLMf4tcl#PdvB=HkMbvsw=iR%WbsU+va;#5nr8yUpjH zQ?4C#-Q9CwPxGl~jm5Tel%1E$UkH8@_2tq#7wOv@d(Ln)i!E*su{~A5ky^3x?xf7Z z&!10hWGP?xci*z9h8HX^_wimXnZ_E!qI3C2=w3Cxxt$A-9+~VfGYMv|z~g=VbyImu NS4H!1UR`tJ769)zPNDz+ literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar300_password.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar300_password.rar new file mode 100644 index 0000000000000000000000000000000000000000..f88d705171bc2241fd22d4828f31cef63f61c109 GIT binary patch literal 124 zcmWGaEK-zWXE;Bhn1O+p0Rmp6l&G{AG8h1PazM-!7i_Wgq}l8kSz}HH1)xAiYEDkR zUP(oXS7UnZ0o(ZIyl}NkVh2T>q^)(tn`JoGdrP+#@odriw$;&Xio!#I-TS{6-AeT2 V7yE5CrTEWh@g+xWs~H^F82}U2Cy4+6 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar4_libarchive_mixed.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/per_file_rar4_libarchive_mixed.rar new file mode 100644 index 0000000000000000000000000000000000000000..f100de51bcbdccf00b1e04e4d469bd0650e3572f GIT binary patch literal 311 zcmWGaEK-zWXE;Bhn1O+p0Rps=OB5z(F$e*9Aj}k+7xgYByevZ2fR#Z3D3GXEQc=S2 z;g64WNJeI{0uZGY<>xAZh2#55RHhh#m4WrPiu_uc4$^B3(VGO)yN^kFR;5-~D8q)L z1tuqde&ZFWUvcqT&Fd>mww<_=-P9#Ff87S&AGfw0cj0>VWcP7Y*O=PQnv#d)nq;tR zHrRRSqPPYu{Pq;8Yg8ZZQu9qgxF!Xpcm1PU;m=EhgBU*iPV6uHVSmy+Lpng$tmi<* g$;&HUSAFYbzOzr_K~GxvZI-VukJwf-IIuGS08s2``~Uy| literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_file_content_encrypted_unicode.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_file_content_encrypted_unicode.rar new file mode 100644 index 0000000000000000000000000000000000000000..ecb2873f8c2cccd7fb68fda5cbacbc78fa4b427d GIT binary patch literal 122 zcmWGaEK-zWXE;Bhn1O+p0Rr?+l&DPeXAl7LxPX}H!&yO}yx6Y+vc^gb3P6DihxV>G zcVy$fb4Rvr)hnqeVMtBe@GGueCq1D(IYY06p`s+nE$#z*_>E%>A0|FDK6=-FsoV0y Vv!a7L{Qgh)V{pW_n!$mc0RTE_Es6jD literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_header_encrypted.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_junrar_header_encrypted.rar new file mode 100644 index 0000000000000000000000000000000000000000..88d0b44029529b0b2eff82fdce42583fe2dcedbe GIT binary patch literal 148 zcmWGaEK-zWXE-;rxPgI}0Rnc~W{W#$S!){lxQgw5TzF(6@>c!|Ct1~K6~_uJNoVl+na{pO&#qD#h2aQJJoVu2r1uKnf{`YX+5g~*npUs<-6vi@2frs$QpApENNt5NXyJg zHPkDqD2Z5MT*kB{;{n3~of#G~UMD}y_53y2*n%y}F(-bV!&~MzPYO+XzNdG-@jPN% J&EUY!007!iB~$xs}Sis2M9<0Gn+DNxOmFd^+)6s!f zCPaY^IJsCYb2n=jm_cxlqRqL;Sb(9Ey!h?OSi*H<#dsC#vle@@X zT>ZDy`4W{WreM3|Kz4~cecK1Iivw(zad2uf$TAd5-g5ZAVCB^KzWav#FJ(_r2eBji qOPP2hrpEPDp6?PnG12(8x!+r^l^Z_o5vj4uyPSW-wwl3#odEz(WL*{j literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_sharpcompress_files_only.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/encrypted/rar4_sharpcompress_files_only.rar new file mode 100644 index 0000000000000000000000000000000000000000..d4ff767b6e463943374f66b659546639ea780eff GIT binary patch literal 60069 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

yfhsxEV$0RRs7a#atgB(aKHo&68zIUZrWD=9 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

sWRew4Pwx$<%8XL$0HV?MVrOZ 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ð@vL+@-Dfh8ec}~oO!mY` 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

Gdj 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 z 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 z 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�X<+IHbqWS|G(<@!Bto-_c6wCIaY^UK9Q7mBh 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 z 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

F&LQM}kS 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

S!cK4WA~{>{f`jUC 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 z zNR2l$$<|BC%zG}ukSf3y$|jzuam?(cT^dhLUhvtabsQaexs#rp;JHELTrnK?3`itGGljfaqT6M@_ z{u3F6Sb3qn+t#a12=s{Wh~F1el=|(Klf_w`H}n2)jy0L3b?$Xy5dUum$v^g|dNj7h x$G%XC&v}v{puHo3K_ukA!1`}{pFgg=tE$iu-Tws?!bpJiPs0)0Y6b^(1^{ptt-=5R literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lorem_rar300.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lorem_rar300.rar new file mode 100644 index 0000000000000000000000000000000000000000..333c12176fb8098a0b1f91c8022d6160d09d2980 GIT binary patch literal 13349 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match.txt b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match.txt new file mode 100644 index 00000000..5143781a --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match.txt @@ -0,0 +1,257 @@ +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +alpha beta gamma delta epsilon zeta eta theta +0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef \ No newline at end of file diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match_rar300.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_match_rar300.rar new file mode 100644 index 0000000000000000000000000000000000000000..0bd29d415fc51ada6599e7d1ecb8e443f6dbec78 GIT binary patch literal 275 zcmWGaEK-zWXE;Bhn1O+p0Rn>gN)#H*84iMY>lhfAj92@2Jf1Z-M%GlEK>;XMlv8{WspUYEfIBzO#vuNtq>RG8U(fQKk+?{9p zyzi}C_HbcI@EZezEe|^?FaO!U{A+L8QJo2u^X@PGkiM+f|In7>Ys6J5malkn!0e9M zyhSG_zLfp(+yAl4k%f<0r!7dBq`z_U`L~8!_+D|mOLd#SYppxS-doD)-vsk7&G4Ri zOZMAwIg#H@&wa8)uUO2x{{PaZ*iEYMuH`&9R~QfSi>jORy??1S3=BLI_6w~4wp~`* XKjlTc^zR0cBx|3;5!-482X+Pk5~_G} literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_repeat_rar3.cbr b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_lz_repeat_rar3.cbr new file mode 100644 index 0000000000000000000000000000000000000000..259afa77372dc84597197ae25e6f5017cf83a267 GIT binary patch literal 381 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

F$*-9JK$mW|)T1F{HtJ&O;d!3%5Fb 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_solid_rar300.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/ppmd_solid_rar300.rar new file mode 100644 index 0000000000000000000000000000000000000000..51baec36dd61a3a55c0e915220d3d5f932037672 GIT binary patch literal 19925 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 Yh6A`(&j0|wh-dbx|J1}idjLQO0I(+(U;qFB literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_a.txt b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_a.txt new file mode 100644 index 00000000..b537ae1f --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_a.txt @@ -0,0 +1 @@ +amet aliqua dolor sed sit et labore et ad incididunt adipiscing sit et lorem incididunt ut enim lorem veniam labore sed quis elit aliqua sit eiusmod lorem lorem lorem ad magna lorem incididunt minim adipiscing ut quis lorem dolore elit labore et magna elit tempor elit minim elit labore do lorem ut magna ad sit consectetur ad quis do sit quis eiusmod quis veniam dolore ut dolore minim adipiscing do do aliqua et dolore incididunt aliqua ipsum et elit quis incididunt ut minim consectetur tempor magna veniam minim quis tempor dolor labore minim dolore sit consectetur dolore incididunt tempor et quis lorem et ipsum do veniam enim aliqua aliqua incididunt ad consectetur consectetur dolore elit lorem adipiscing magna magna elit incididunt dolore tempor aliqua tempor labore sed minim magna enim quis lorem incididunt quis dolore amet dolore magna adipiscing ut ipsum et tempor aliqua magna adipiscing dolore ut et tempor ut tempor lorem magna magna enim enim eiusmod labore enim lorem elit ad consectetur magna aliqua consectetur dolor magna sed ipsum minim dolor dolor lorem labore lorem sed elit sed sit enim consectetur tempor do dolor consectetur consectetur sed dolore consectetur minim sed ad veniam do labore veniam eiusmod et et sit lorem do incididunt eiusmod ut adipiscing sed sit sed quis dolore adipiscing enim ut lorem elit lorem incididunt amet ipsum quis consectetur labore veniam dolore minim ut magna elit ad veniam dolore labore elit dolore ad lorem incididunt minim aliqua eiusmod minim ad ut ipsum quis do amet adipiscing ipsum do dolor dolor do do quis consectetur ut aliqua sed amet lorem magna ipsum aliqua adipiscing aliqua labore consectetur veniam enim dolore ipsum incididunt adipiscing tempor sit adipiscing aliqua minim ut aliqua adipiscing et sit minim incididunt do dolore et lorem eiusmod enim incididunt do lorem consectetur adipiscing eiusmod aliqua amet eiusmod ut adipiscing sed minim sit incididunt magna tempor minim magna et magna elit dolor quis ipsum dolor amet consectetur consectetur magna adipiscing sed eiusmod enim dolore sed tempor eiusmod eiusmod sit do elit enim veniam et amet aliqua magna sit eiusmod ipsum ut dolor incididunt amet amet eiusmod sit enim aliqua incididunt dolor aliqua magna elit aliqua dolor sed tempor do aliqua magna sit labore sed sit ipsum do lorem enim minim lorem dolor ut sit ipsum adipiscing elit aliqua ut consectetur sit labore consectetur minim elit consectetur quis sit ut incididunt magna do magna sed veniam et eiusmod sit adipiscing ad eiusmod ipsum lorem lorem do quis enim eiusmod labore incididunt eiusmod incididunt dolor dolor eiusmod enim labore sit sed adipiscing enim magna veniam et minim tempor sed consectetur magna adipiscing do adipiscing elit tempor dolor sed dolor labore dolor ad aliqua ad eiusmod elit incididunt do ipsum eiusmod consectetur eiusmod aliqua do elit eiusmod sit magna enim aliqua enim dolor elit elit lorem elit incididunt dolor sed magna dolor quis dolor lorem ad lorem do tempor et et amet sit dolore eiusmod dolor dolore minim consectetur consectetur amet amet eiusmod do sit veniam dolore enim do amet adipiscing amet magna quis ipsum eiusmod enim minim magna quis veniam adipiscing consectetur do ut magna consectetur ipsum veniam minim elit sed dolor minim labore ut magna sed magna labore magna labore lorem incididunt eiusmod consectetur sed et lorem ad ut aliqua lorem ipsum veniam tempor aliqua amet aliqua amet amet sed sed incididunt aliqua incididunt consectetur enim dolor elit et lorem consectetur dolore eiusmod dolore ad labore minim ad quis elit elit eiusmod et minim et elit veniam ut eiusmod magna enim quis ad sed ad elit ipsum dolor dolore ad tempor consectetur dolore adipiscing do do veniam do magna tempor consectetur veniam veniam quis labore enim dolor sit enim dolore aliqua incididunt consectetur amet sed ut adipiscing aliqua quis ipsum et minim incididunt veniam ad tempor incididunt dolore consectetur magna quis ipsum dolore dolor sed ad sit sed quis dolor amet enim minim minim veniam dolor labore elit incididunt ut incididunt consectetur eiusmod labore amet enim et adipiscing sit ut enim magna ut sit minim do sed elit incididunt quis magna lorem adipiscing dolore labore aliqua lorem lorem ad enim elit sed adipiscing consectetur do amet magna adipiscing sed do aliqua sed minim labore consectetur magna tempor et ut sit adipiscing aliqua incididunt adipiscing do sit lorem sit aliqua quis lorem magna do minim quis ad amet dolor dolore tempor aliqua do ut dolore minim tempor dolore eiusmod lorem sit labore veniam labore tempor do magna incididunt eiusmod quis minim aliqua et sit ad incididunt incididunt adipiscing magna lorem sed ad enim quis quis quis dolore adipiscing labore enim dolore ut quis veniam do veniam consectetur labore enim minim dolore adipiscing tempor dolore lorem minim incididunt aliqua ut incididunt eiusmod enim aliqua quis veniam quis dolor et quis elit ad ad do ad lorem ut quis ad amet ad incididunt sed consectetur dolor enim lorem tempor sed veniam ut minim magna do amet labore sed et consectetur labore dolore ipsum sed dolore sit quis aliqua ut dolor tempor dolor minim labore lorem consectetur dolore veniam consectetur veniam dolor incididunt ad veniam sed enim do adipiscing dolore adipiscing elit eiusmod sed dolor dolor veniam dolore minim tempor labore dolore magna quis ipsum consectetur do ad quis veniam magna sed tempor enim quis elit incididunt magna incididunt consectetur et sed enim eiusmod veniam elit sed enim veniam elit minim lorem enim incididunt eiusmod ut elit sed adipiscing dolor ad quis consectetur aliqua labore aliqua quis amet enim sed labore dolore consectetur amet amet veniam labore tempor do incididunt elit sit veniam adipiscing veniam minim do dolor sit elit incididunt eiusmod et sit consectetur ipsum ipsum enim lorem adipiscing minim ipsum et veniam dolore quis enim labore eiusmod minim sed sit enim veniam consectetur sit elit incididunt elit et labore incididunt consectetur elit elit do labore magna aliqua incididunt adipiscing labore veniam sed eiusmod et aliqua sit adipiscing dolor ipsum lorem lorem et eiusmod incididunt aliqua do adipiscing incididunt consectetur ad amet lorem lorem incididunt amet minim magna ipsum aliqua incididunt sed amet dolor labore ad do lorem ipsum magna ipsum dolore amet ipsum sed sit ut dolor adipiscing lorem et ad amet quis sed minim adipiscing minim labore incididunt eiusmod ad sed sed ad ad elit elit ipsum aliqua aliqua consectetur tempor ut enim veniam magna ad dolore ipsum tempor magna ut magna adipiscing veniam magna ut minim dolor veniam sed quis enim quis dolor sed consectetur sit amet ipsum adipiscing ut ipsum ipsum ad dolor dolore et dolore tempor sit eiusmod ipsum amet magna ipsum labore minim amet incididunt veniam labore lorem quis dolore sed dolor sed eiusmod dolor do ipsum incididunt ipsum quis sed eiusmod quis amet sed incididunt sit minim do sit ut elit dolore magna adipiscing eiusmod eiusmod dolore incididunt aliqua et sit amet ad labore dolore magna quis aliqua veniam dolore magna lorem do quis consectetur adipiscing tempor incididunt dolore eiusmod sit ut tempor amet aliqua dolor ipsum do ad magna eiusmod ut do eiusmod tempor sed eiusmod quis quis dolore dolore lorem dolore sit amet eiusmod quis eiusmod eiusmod aliqua dolor labore sed et labore tempor quis incididunt dolor aliqua ipsum amet ipsum dolore et aliqua sed elit veniam aliqua quis eiusmod tempor ad tempor incididunt do labore enim eiusmod magna dolore consectetur lorem amet sed minim elit aliqua amet sit consectetur ut quis enim ipsum sit magna minim sed veniam sit adipiscing sed dolor ad aliqua dolore ad dolor dolor adipiscing ad consectetur dolore ut lorem aliqua tempor et veniam do elit adipiscing enim et elit ut labore minim tempor magna adipiscing et quis dolor sed ut adipiscing lorem quis magna incididunt dolore et dolor incididunt enim dolore aliqua aliqua ut ipsum tempor labore lorem adipiscing do veniam veniam ad lorem magna sit do dolore quis eiusmod magna ad aliqua magna do dolore ut magna dolore ut enim ad aliqua do labore do amet dolore labore aliqua amet magna consectetur sed ad lorem ut quis minim aliqua ipsum tempor ut incididunt do minim minim lorem dolor dolor lorem incididunt sed labore sed tempor ad quis et eiusmod incididunt labore sit et tempor amet ut amet lorem consectetur sed tempor amet aliqua do ut sed dolore do quis ut veniam sed ut eiusmod et adipiscing veniam et incididunt veniam ut dolor dolor amet adipiscing amet elit quis lorem sit sed amet et sit incididunt ad quis consectetur lorem dolor ut enim ipsum magna adipiscing magna ut tempor ipsum ad sit quis magna minim ut minim quis sit sed minim sed consectetur et veniam ipsum adipiscing minim ad dolor incididunt sit minim labore do minim dolore et incididunt sit enim et sit amet incididunt enim veniam adipiscing consectetur dolore sed ut quis magna do et ad magna adipiscing enim eiusmod et sit lorem quis minim tempor veniam sed ipsum magna ad labore do sit elit dolore sed sed veniam elit ut amet amet sed adipiscing ut magna ad enim ipsum magna enim dolore amet ut sed sed et veniam do sed et adipiscing et tempor enim et elit eiusmod consectetur enim consectetur quis aliqua veniam labore magna amet ipsum dolore eiusmod dolore veniam amet ad adipiscing eiusmod enim et et eiusmod sit amet amet veniam sed elit dolor ad magna veniam ipsum aliqua consectetur minim sit elit aliqua adipiscing dolore aliqua minim do ut eiusmod lorem lorem do enim elit dolor quis elit sed minim ad eiusmod sed enim quis dolore incididunt lorem sit eiusmod tempor amet sit sed amet minim aliqua ipsum tempor dolor dolor quis sit do eiusmod elit sed dolore ipsum tempor lorem dolor amet incididunt tempor quis ad veniam elit sit minim eiusmod sed lorem dolore eiusmod sit tempor ad quis amet enim sed incididunt dolor minim aliqua enim quis dolore et aliqua ut magna incididunt do elit ad do magna amet ipsum enim dolore sit consectetur elit adipiscing ut sed magna lorem sed magna sed dolore sed et amet incididunt veniam sit quis tempor dolor ad magna tempor magna magna quis dolore minim aliqua lorem enim do labore minim amet amet dolor aliqua amet minim adipiscing et eiusmod tempor do consectetur amet incididunt labore incididunt sit enim amet sed do minim minim ad enim lorem magna lorem ad amet incididunt quis magna sit labore lorem ut enim minim ut sed tempor ut incididunt enim labore ipsum sit et ipsum ad veniam veniam lorem ipsum sit aliqua amet dolore dolore tempor magna sed aliqua ad tempor et veniam elit enim elit sit magna tempor consectetur sit ipsum veniam eiusmod ut quis tempor sed minim ad ipsum enim ut ut incididunt tempor do eiusmod labore veniam elit ad enim dolore amet ipsum eiusmod minim sit dolore consectetur magna ad ad et eiusmod veniam sit aliqua lorem et adipiscing incididunt ad consectetur incididunt veniam elit sit elit eiusmod eiusmod minim elit minim labore quis et tempor et ad minim quis adipiscing ut labore incididunt magna sit aliqua et sed amet amet lorem incididunt ut sit lorem ad dolor consectetur labore incididunt minim dolore do amet amet dolore sit sed lorem labore incididunt ad veniam quis elit magna veniam incididunt lorem magna elit ut consectetur minim consectetur eiusmod minim elit dolor magna magna consectetur consectetur incididunt aliqua lorem dolore adipiscing ut elit ipsum dolore quis adipiscing veniam dolore veniam enim ad magna dolor elit incididunt labore sit aliqua ad ipsum incididunt dolor magna sit ad et ipsum dolore elit lorem lorem do labore sed quis ut consectetur enim amet magna veniam eiusmod magna ad labore dolore ut magna consectetur veniam incididunt veniam incididunt adipiscing et sed tempor amet sed aliqua sed consectetur quis enim dolor quis tempor eiusmod amet sed sed sed tempor incididunt sed aliqua labore lorem amet amet sed elit adipiscing dolor aliqua magna enim adipiscing magna ut veniam elit aliqua amet magna labore incididunt veniam adipiscing dolor ad dolor amet minim ipsum lorem quis incididunt incididunt ut minim amet aliqua enim amet minim magna magna dolor elit incididunt amet do adipiscing minim quis incididunt tempor quis consectetur elit do veniam amet tempor et magna do dolor dolore do adipiscing veniam labore lorem do enim aliqua sit enim tempor labore sed enim ipsum ipsum eiusmod consectetur amet ad sit sit ut ad aliqua elit quis adipiscing dolore dolore incididunt sit veniam adipiscing incididunt minim dolore amet veniam aliqua sed quis lorem veniam sit adipiscing aliqua incididunt minim et magna enim elit sed ipsum ad consectetur minim minim magna dolore elit ut sed minim ut incididunt sed et sit minim amet consectetur magna lorem labore ipsum et adipiscing incididunt quis magna eiusmod elit sit dolor minim quis ipsum ut labore adipiscing consectetur enim dolore adipiscing dolore incididunt dolore tempor adipiscing elit tempor minim aliqua dolor eiusmod ipsum labore ipsum enim consectetur amet do et ipsum aliqua dolore dolor aliqua incididunt dolor incididunt dolore aliqua ad do incididunt sed tempor et ipsum magna et lorem ut do aliqua quis eiusmod amet enim aliqua magna sed dolor enim tempor ut incididunt dolore lorem aliqua aliqua sit ipsum aliqua dolore lorem sit eiusmod eiusmod tempor magna ipsum ad tempor aliqua dolor et ad dolor magna labore eiusmod dolore magna lorem consectetur eiusmod tempor adipiscing amet aliqua amet aliqua sit incididunt eiusmod dolore ut tempor eiusmod sed enim tempor ipsum veniam dolor ad elit sed incididunt magna do aliqua enim dolor dolor veniam consectetur sed ut dolor amet do magna quis ad sed elit adipiscing sit sed quis et ipsum quis dolore do adipiscing magna dolor magna eiusmod eiusmod do dolore amet ipsum labore tempor quis ipsum lorem eiusmod ut quis consectetur magna ipsum veniam aliqua veniam minim ad dolore ut consectetur adipiscing elit sit aliqua amet aliqua dolore sit quis sed labore adipiscing ipsum tempor labore eiusmod enim quis tempor elit ad lorem lorem et ipsum consectetur sed magna ipsum lorem elit dolor dolore consectetur ipsum dolore adipiscing adipiscing labore do elit et dolore tempor eiusmod incididunt ad dolor adipiscing enim consectetur adipiscing minim enim do aliqua ut enim et tempor lorem et lorem sit minim ad aliqua minim enim ut veniam aliqua eiusmod eiusmod dolor ad ut adipiscing veniam dolore et enim aliqua minim magna dolore et enim minim quis aliqua labore enim et consectetur sed minim dolore do aliqua incididunt enim magna sed sed do lorem enim ipsum labore labore tempor elit dolore labore adipiscing veniam et eiusmod veniam ad amet incididunt ut ipsum ad sit tempor lorem sed magna quis ipsum do incididunt lorem eiusmod eiusmod do aliqua ipsum adipiscing veniam dolor eiusmod sit minim ad dolor amet veniam do ut enim eiusmod elit lorem ad veniam veniam consectetur dolore quis aliqua ad tempor do do incididunt ut dolore labore dolor adipiscing ut elit enim ipsum enim elit ad elit elit veniam incididunt incididunt adipiscing enim amet quis do quis quis tempor lorem veniam veniam minim do labore et consectetur minim amet lorem tempor ut magna eiusmod dolore et eiusmod enim sit aliqua ad do magna minim sed ut lorem do dolor ad et sit dolore elit enim quis ad quis sed ut tempor elit ipsum sit enim dolore dolore dolore consectetur amet do ipsum dolor adipiscing lorem minim ipsum ut quis veniam lorem dolor ipsum lorem ipsum magna eiusmod eiusmod lorem enim lorem magna adipiscing et adipiscing sed do aliqua magna dolore sed elit consectetur adipiscing incididunt ipsum elit magna veniam labore ipsum eiusmod eiusmod ut sit lorem aliqua consectetur dolore ad dolor consectetur adipiscing elit consectetur do sit ipsum eiusmod quis amet dolor labore amet elit ipsum quis do tempor ipsum aliqua dolor labore adipiscing elit minim consectetur sit ipsum adipiscing ipsum quis quis sit dolor quis elit do veniam sed dolore ut elit quis ipsum quis sed adipiscing eiusmod tempor tempor labore minim enim incididunt minim incididunt dolor ut elit et eiusmod consectetur enim ad sit elit dolor ut sed magna do eiusmod tempor ut labore tempor tempor eiusmod incididunt et dolore lorem tempor amet do consectetur do aliqua amet magna veniam quis amet consectetur labore ad ad amet amet consectetur dolor enim sed elit tempor ad eiusmod consectetur sed et do dolor ut amet magna tempor labore sit amet minim eiusmod dolor minim consectetur et magna ipsum ipsum quis adipiscing ad tempor quis tempor dolore tempor dolore ad minim tempor eiusmod ad sit consectetur incididunt ipsum sed enim veniam adipiscing ipsum elit do eiusmod aliqua incididunt elit tempor ipsum elit do veniam aliqua lorem adipiscing sit amet elit tempor dolore sed amet consectetur elit dolor do aliqua dolore dolore magna enim magna ut labore aliqua dolore et consectetur dolore tempor adipiscing ut dolor sed adipiscing elit amet amet adipiscing lorem consectetur et tempor consectetur ipsum tempor dolor enim elit minim veniam adipiscing dolor labore ad ad adipiscing enim eiusmod consectetur aliqua veniam minim veniam lorem adipiscing eiusmod et magna ipsum ipsum tempor et magna tempor amet et dolor dolore eiusmod minim quis aliqua minim do enim eiusmod aliqua dolor et eiusmod ut dolor sed dolor minim ad eiusmod lorem consectetur eiusmod elit eiusmod sed sed do et ut lorem do consectetur ad do ipsum sit ut ut enim adipiscing sed tempor ad quis aliqua et aliqua do enim sed minim consectetur eiusmod amet tempor sit incididunt tempor dolore quis aliqua veniam adipiscing incididunt labore amet et veniam elit ipsum quis ad elit dolor quis dolor ipsum dolore dolore et aliqua et veniam eiusmod dolore consectetur aliqua veniam et incididunt lorem incididunt magna quis magna quis labore consectetur aliqua aliqua tempor ipsum quis tempor tempor labore elit veniam ad minim magna do dolor labore tempor adipiscing consectetur amet labore ipsum tempor aliqua eiusmod consectetur aliqua et et lorem aliqua elit enim ipsum labore ad consectetur dolore adipiscing incididunt labore sit eiusmod sed amet consectetur eiusmod amet consectetur quis enim dolore do elit magna veniam ut labore labore dolore magna do consectetur dolore enim dolore do aliqua adipiscing do minim amet minim lorem eiusmod sit ut incididunt veniam ad dolore quis consectetur enim labore labore magna labore tempor adipiscing ipsum dolor quis sit sit magna incididunt amet labore incididunt consectetur et labore dolore aliqua ipsum aliqua adipiscing aliqua labore et incididunt do tempor consectetur enim sed consectetur lorem magna ipsum minim dolor magna elit labore eiusmod labore eiusmod quis sit incididunt ipsum quis labore sed ut labore eiusmod dolore sit consectetur incididunt magna ut enim quis et dolore amet eiusmod amet tempor amet enim adipiscing elit adipiscing labore ad amet sit veniam sit ut ipsum labore amet tempor magna eiusmod sed incididunt lorem incididunt et veniam labore do quis veniam do ad aliqua incididunt eiusmod do consectetur sit et consectetur labore amet labore sit magna sit magna eiusmod eiusmod et minim magna ad eiusmod quis aliqua eiusmod magna aliqua labore eiusmod et veniam incididunt magna adipiscing consectetur elit magna adipiscing enim elit ipsum eiusmod enim ipsum eiusmod ut lorem tempor tempor tempor enim enim minim ut adipiscing do elit eiusmod incididunt veniam incididunt minim consectetur lorem incididunt ad tempor enim enim elit elit dolor enim eiusmod incididunt adipiscing veniam do sit ut lorem tempor dolor ut amet sit magna quis consectetur eiusmod amet incididunt ut eiusmod magna ad veniam dolore sed adipiscing adipiscing consectetur consectetur magna consectetur amet sit labore aliqua dolore amet ut amet eiusmod enim quis veniam minim eiusmod enim amet lorem tempor consectetur elit elit veniam et aliqua et ipsum ad dolor amet magna et aliqua amet adipiscing tempor veniam amet sed quis tempor dolor incididunt et lorem dolore labore adipiscing quis elit adipiscing veniam lorem quis veniam do ipsum sed dolore adipiscing dolor sit sit incididunt eiusmod sit labore veniam aliqua dolore veniam ad et minim sed amet ut tempor ad tempor incididunt ut ut tempor magna adipiscing adipiscing dolor amet elit elit lorem elit minim incididunt labore enim labore aliqua sit ipsum consectetur dolore lorem ipsum ut sed ut amet elit veniam minim tempor ut eiusmod aliqua quis ipsum dolore labore amet veniam dolore tempor aliqua ipsum tempor sit elit ad ad sit ut amet lorem tempor amet amet do lorem et ad lorem et dolor aliqua ut dolor et magna enim dolore sit amet magna minim veniam incididunt ad enim magna ut elit dolore incididunt et quis eiusmod labore sit dolor adipiscing aliqua enim veniam tempor sit sit tempor sit adipiscing sit veniam ad aliqua dolor lorem dolore ut elit dolor do et enim ipsum aliqua ut magna do incididunt ad ipsum minim enim lorem sed enim et labore elit sed eiusmod et labore magna ipsum sed dolore consectetur quis veniam labore labore do aliqua aliqua consectetur eiusmod dolore minim incididunt minim veniam ut minim magna enim incididunt et ad elit do lorem dolor amet et sit tempor sed do magna do amet sit dolore amet labore ipsum labore et quis aliqua eiusmod magna tempor amet veniam lorem magna adipiscing sed enim dolor labore do lorem ad sed quis dolore veniam lorem aliqua incididunt sit sit minim eiusmod enim enim ad veniam veniam aliqua labore dolor enim et dolore eiusmod aliqua minim ipsum adipiscing consectetur ipsum enim sit ipsum sit magna dolore do adipiscing consectetur magna amet elit adipiscing dolor dolore tempor veniam aliqua ut sed enim amet do aliqua elit dolor enim sed ipsum lorem ut enim do et ut ut dolor consectetur adipiscing minim ipsum ad ut ut tempor tempor dolore amet consectetur elit elit ipsum tempor dolor labore eiusmod adipiscing elit sed amet veniam veniam dolore incididunt sit et minim quis enim lorem et do sed veniam do adipiscing amet veniam ad incididunt minim ipsum incididunt labore magna lorem amet elit et ad sit do veniam enim ut adipiscing dolore eiusmod sit elit elit et aliqua sit consectetur et tempor veniam ad enim ad enim ut incididunt magna ut lorem ad incididunt amet ut amet ipsum do incididunt enim ut ad sit adipiscing enim sed et enim ut sed dolore sit eiusmod amet magna veniam magna sed minim minim lorem magna minim quis sit tempor labore sed sit do amet dolor ut veniam incididunt lorem et aliqua quis amet magna incididunt et elit dolore lorem incididunt ipsum ut enim dolor elit minim ipsum labore dolor do enim ipsum tempor ipsum dolor dolor ipsum aliqua do tempor do dolor magna et enim tempor eiusmod consectetur ad tempor dolore elit eiusmod enim elit elit ad veniam adipiscing do do magna eiusmod veniam do aliqua lorem minim et sed minim elit amet elit consectetur dolor sed incididunt adipiscing amet consectetur magna enim dolor eiusmod incididunt veniam adipiscing consectetur ipsum labore adipiscing incididunt sit veniam do elit quis ad do dolore ad labore eiusmod dolor dolor dolor elit sit dolore labore veniam magna labore lorem enim consectetur labore ut magna sit adipiscing lorem elit do adipiscing dolore enim do do sed tempor sed do ipsum lorem lorem ad labore ipsum adipiscing dolor eiusmod labore minim do sit elit minim sit adipiscing lorem adipiscing ad amet enim enim minim minim lorem labore quis lorem magna elit et consectetur magna lorem elit amet dolor lorem amet eiusmod aliqua dolor dolore magna sed adipiscing incididunt lorem magna sed tempor sed magna incididunt incididunt dolore dolore magna labore sed dolor consectetur et aliqua incididunt amet enim adipiscing dolore lorem dolore ipsum eiusmod amet elit eiusmod incididunt ipsum ut quis aliqua et dolore dolor veniam ipsum amet magna ut magna incididunt magna sed aliqua ipsum adipiscing adipiscing do veniam incididunt do dolore lorem aliqua sed adipiscing magna dolore quis magna consectetur elit dolor adipiscing et consectetur ipsum minim incididunt do lorem amet sit ipsum veniam aliqua ut et consectetur adipiscing aliqua labore minim sit minim incididunt elit dolor amet eiusmod dolore et et dolore minim tempor ut aliqua elit labore sed incididunt tempor incididunt aliqua elit incididunt enim sit consectetur minim enim ad tempor dolor lorem ut aliqua et ipsum labore sit ad ad elit labore tempor dolore dolor eiusmod minim ipsum sed aliqua dolore enim eiusmod amet aliqua consectetur ut minim do veniam labore quis elit et quis incididunt lorem dolore sed sit do sed lorem aliqua dolor eiusmod ad dolore minim consectetur elit do quis dolor consectetur labore tempor incididunt ad labore minim et minim minim sit aliqua et aliqua dolor minim ipsum ipsum lorem sed ipsum sed do consectetur magna et enim veniam minim eiusmod lorem labore eiusmod elit elit tempor quis veniam ipsum lorem labore dolore adipiscing incididunt amet consectetur elit dolor incididunt ipsum consectetur eiusmod lorem labore magna enim dolore consectetur ipsum ut elit sed minim dolore labore adipiscing ipsum enim veniam incididunt ut incididunt dolore ut sed labore eiusmod aliqua lorem dolor et quis quis ut consectetur ut consectetur magna dolore dolore quis dolore enim consectetur sed ut quis et do tempor veniam labore incididunt magna incididunt do elit tempor magna magna veniam veniam dolore elit sed lorem minim dolor sed veniam incididunt consectetur sed aliqua sed et lorem consectetur et sit elit amet sit incididunt ipsum consectetur dolor sit labore magna quis ad labore lorem ipsum sed ipsum dolore et quis ad adipiscing tempor enim labore sit eiusmod eiusmod incididunt ad incididunt do dolor elit quis labore magna tempor ut ut veniam quis quis ut aliqua sed consectetur amet ipsum eiusmod tempor incididunt dolor ad aliqua eiusmod aliqua consectetur amet quis ad sit magna adipiscing et veniam elit tempor enim dolore ad veniam consectetur adipiscing do consectetur quis amet ad incididunt ut et tempor veniam ipsum magna dolor lorem tempor elit amet adipiscing incididunt labore dolore aliqua sed ut enim eiusmod et eiusmod dolor aliqua enim ipsum amet magna quis et consectetur dolor lorem dolor lorem consectetur sed adipiscing quis labore incididunt veniam magna dolore sed veniam minim sed magna incididunt sit veniam incididunt labore elit dolor quis quis eiusmod amet minim enim lorem ad veniam incididunt ad ipsum do tempor minim lorem veniam enim labore eiusmod aliqua lorem magna eiusmod quis incididunt veniam quis ipsum aliqua minim labore minim veniam ad sit ut incididunt quis sit aliqua lorem lorem magna enim ut tempor consectetur incididunt quis ipsum amet do dolore veniam enim ut ad consectetur aliqua et quis do aliqua enim sed quis minim ipsum incididunt magna aliqua ut amet eiusmod consectetur labore incididunt aliqua magna minim amet dolore ad dolor enim aliqua enim incididunt sed incididunt et quis ipsum ad quis do consectetur ad sed incididunt sed sit sed lorem sit minim sit labore amet labore elit elit ipsum elit dolor sit sit quis ipsum aliqua minim sit ipsum sed ut amet tempor sit ipsum incididunt enim enim elit consectetur magna aliqua et consectetur tempor enim incididunt dolore aliqua minim consectetur eiusmod dolore dolor ad ipsum lorem aliqua do sit labore dolor lorem minim ipsum quis sed magna do aliqua enim sed labore incididunt sit ad elit do ad minim amet dolore dolore quis lorem tempor veniam labore sit ut minim amet sed sit tempor sed adipiscing eiusmod enim amet magna elit enim lorem elit veniam et tempor ad amet ut minim eiusmod ut enim labore sit sed ipsum dolore do veniam dolore eiusmod adipiscing adipiscing elit quis elit incididunt tempor sed lorem et dolore amet ut et dolor dolore sed sit elit sit ut incididunt amet sit minim labore dolore minim adipiscing consectetur adipiscing sed tempor veniam eiusmod tempor quis sed aliqua amet lorem elit sed et enim magna lorem eiusmod lorem consectetur veniam adipiscing sed ad elit dolor ut veniam tempor veniam tempor adipiscing sit lorem incididunt eiusmod aliqua eiusmod minim ut eiusmod aliqua veniam sed incididunt enim sed tempor enim dolor ut elit enim et tempor do veniam lorem sit enim dolore ipsum consectetur enim elit magna labore do ut incididunt enim lorem dolor incididunt amet quis aliqua adipiscing et minim incididunt et sit ut ad consectetur veniam minim et adipiscing ad do magna ipsum do do amet sed ad dolore do et amet ut eiusmod dolore eiusmod adipiscing sed ipsum do dolore aliqua do et do sed consectetur do sed eiusmod amet sed incididunt minim labore minim et quis consectetur incididunt ipsum dolor aliqua adipiscing eiusmod ipsum dolore quis do ipsum ut sit enim ad veniam eiusmod amet lorem tempor elit enim tempor dolore ut veniam elit dolore dolor ipsum eiusmod lorem ad labore lorem consectetur quis sed minim enim adipiscing ut do ad consectetur ipsum ipsum et incididunt magna minim minim sit incididunt do ut ipsum elit eiusmod ut aliqua aliqua et enim adipiscing aliqua dolore minim dolor eiusmod ad incididunt ad consectetur elit dolore et dolor ad ut minim incididunt adipiscing sed lorem do ipsum sed dolor consectetur enim sed labore veniam ut do sit do ipsum et consectetur sed magna adipiscing amet ipsum minim incididunt magna lorem aliqua dolore do lorem quis incididunt eiusmod sit sed consectetur enim veniam adipiscing dolor consectetur veniam minim aliqua ad incididunt dolore aliqua quis lorem elit incididunt minim lorem minim lorem dolore ut enim consectetur ipsum quis incididunt ad ut adipiscing consectetur elit dolor enim labore magna magna eiusmod minim minim sed adipiscing dolore enim sed incididunt elit minim do enim sed veniam amet veniam ad sed tempor aliqua quis sed dolore ad elit adipiscing magna minim lorem sit adipiscing sed consectetur quis eiusmod elit consectetur ad ad ipsum enim elit incididunt sed sed adipiscing ad sed incididunt ipsum ipsum amet quis et ut do tempor incididunt tempor enim adipiscing do sed sed et enim amet aliqua tempor amet incididunt ipsum dolor sed dolor et adipiscing labore do ipsum sed eiusmod lorem veniam minim enim et ut ut ut tempor enim quis et adipiscing quis ut incididunt do sit dolor quis consectetur veniam eiusmod tempor aliqua ut veniam incididunt sit incididunt ipsum ut enim adipiscing sit elit veniam et incididunt consectetur minim amet elit enim sit veniam tempor eiusmod dolore labore consectetur incididunt ad et aliqua consectetur ipsum dolore adipiscing minim elit amet sit sed magna lorem lorem tempor do adipiscing ipsum do minim minim amet amet dolor veniam consectetur aliqua ut sed amet dolor adipiscing consectetur enim ut adipiscing incididunt magna et consectetur enim dolor et elit adipiscing dolor minim amet elit adipiscing enim enim veniam amet magna sed dolor aliqua tempor dolor tempor dolore sed consectetur minim aliqua et ut magna aliqua veniam magna elit amet magna aliqua sit ut quis ut tempor elit labore minim magna incididunt eiusmod minim aliqua consectetur ipsum ipsum tempor enim labore consectetur minim quis labore aliqua tempor tempor amet labore adipiscing magna et magna do enim adipiscing amet enim elit do sit minim dolor ad elit ut dolore adipiscing minim do et veniam ipsum incididunt adipiscing ad veniam ipsum do quis do enim adipiscing ut lorem labore eiusmod ut elit ad sit consectetur dolore ipsum quis incididunt consectetur lorem dolore et et tempor magna ut lorem ad enim minim ut incididunt elit dolore lorem magna ad ipsum ad adipiscing ad eiusmod ipsum amet labore veniam consectetur labore amet amet sed dolore incididunt veniam dolor dolore sit dolor veniam incididunt et tempor adipiscing ipsum dolore ut elit et adipiscing consectetur elit adipiscing dolore minim eiusmod ad veniam do et enim aliqua dolore elit adipiscing do sit aliqua lorem ipsum enim eiusmod dolor dolore ad consectetur labore magna dolor ut quis amet magna ipsum veniam amet eiusmod minim quis tempor labore quis adipiscing incididunt labore dolor incididunt tempor lorem do adipiscing aliqua tempor tempor ad lorem sit labore incididunt do veniam consectetur do quis ad elit quis eiusmod eiusmod adipiscing ipsum ipsum lorem veniam consectetur enim labore eiusmod veniam ipsum sed aliqua dolore sed dolor veniam ad elit lorem amet ut tempor sed et ipsum incididunt sit do veniam ut elit elit dolore aliqua ut aliqua sed lorem lorem amet et veniam amet tempor dolor enim elit magna ad magna amet amet incididunt amet enim veniam quis eiusmod adipiscing amet amet enim veniam sit amet ipsum enim sed sed tempor lorem amet veniam lorem dolor labore veniam ut veniam incididunt do minim amet incididunt ut tempor labore tempor do et consectetur sed lorem do elit veniam ipsum et ipsum lorem dolor enim labore lorem ad elit amet veniam incididunt quis enim incididunt elit aliqua enim sed consectetur quis adipiscing consectetur dolor eiusmod tempor dolor sit magna elit adipiscing eiusmod magna magna labore veniam dolor ut aliqua tempor consectetur consectetur enim sit tempor consectetur minim et enim dolor labore ut adipiscing dolor dolor minim ad sed eiusmod incididunt tempor aliqua eiusmod ut dolore enim enim ad dolor adipiscing ut tempor dolore quis et tempor veniam sit labore eiusmod lorem elit do ut minim minim amet adipiscing sed veniam dolore enim ipsum consectetur aliqua do ipsum minim sit sed ad aliqua sit consectetur veniam ad magna labore aliqua elit labore ut ipsum amet et tempor dolore do quis incididunt dolor aliqua ut amet minim veniam dolore elit ut et dolor aliqua quis tempor magna dolore consectetur ipsum veniam adipiscing adipiscing lorem tempor elit elit veniam dolore dolore ad ut magna ut consectetur elit lorem elit dolore magna ipsum ad amet magna dolor lorem amet magna sed elit tempor eiusmod quis amet sit sed ut tempor enim ipsum magna ipsum minim labore ipsum quis ad eiusmod do do minim quis incididunt do incididunt et do minim sit aliqua minim ad lorem veniam sit ut dolor adipiscing sit ad lorem elit et dolor adipiscing eiusmod adipiscing do do labore labore veniam magna aliqua veniam dolore adipiscing veniam labore incididunt dolor quis lorem dolor do quis enim labore adipiscing quis do ut consectetur ad enim minim incididunt incididunt quis labore elit elit et lorem do sed et et tempor sit aliqua quis veniam minim sit adipiscing veniam labore incididunt adipiscing ut ipsum quis consectetur veniam minim incididunt ut tempor dolore amet dolor dolore veniam consectetur ipsum aliqua adipiscing dolore magna quis labore ad do do et amet lorem veniam labore ut minim minim aliqua tempor ut veniam tempor adipiscing sed adipiscing minim labore aliqua et sed minim enim ut do sed labore dolor sit eiusmod labore minim minim do dolore elit dolore eiusmod elit amet consectetur sed veniam elit ut lorem minim ut incididunt elit amet dolor dolor consectetur labore enim quis incididunt elit do enim incididunt sed lorem do amet sit quis ut do quis minim do veniam ut magna ipsum minim quis minim amet sit consectetur dolore et ut sit ipsum tempor ad eiusmod do ipsum do labore ipsum tempor do magna ad adipiscing sed quis sed consectetur do dolore eiusmod magna dolor veniam ipsum amet amet incididunt eiusmod eiusmod et consectetur do lorem sed lorem magna ad enim aliqua lorem ut magna labore lorem enim dolore incididunt sit sit aliqua aliqua lorem incididunt dolor et adipiscing tempor aliqua ipsum ut et magna eiusmod adipiscing lorem amet et et sed ut ad dolore sit ut labore magna dolore do dolor ipsum ut amet tempor adipiscing dolor labore tempor sit aliqua enim eiusmod minim sit adipiscing enim eiusmod consectetur consectetur eiusmod dolor adipiscing quis do magna aliqua dolor et aliqua labore dolore labore incididunt tempor dolore ad dolore et consectetur minim amet lorem consectetur do consectetur ad ad amet adipiscing amet veniam elit labore amet dolor et dolore magna incididunt incididunt enim ad quis ut magna ad dolore minim minim ut et sed et amet minim minim adipiscing incididunt ipsum sed enim amet labore adipiscing amet incididunt labore ad minim ipsum tempor veniam elit minim amet do aliqua minim aliqua et eiusmod amet enim ad quis dolor minim enim incididunt minim dolor dolor lorem lorem minim dolor dolor amet magna sed ipsum adipiscing ut eiusmod minim sed minim tempor adipiscing minim consectetur ut dolor tempor sit ut labore eiusmod dolore sit lorem minim ipsum amet ut enim veniam adipiscing adipiscing dolor minim consectetur labore dolore lorem eiusmod veniam enim do minim do amet labore ipsum ipsum do consectetur lorem enim eiusmod lorem amet sed sit elit sed ad aliqua et et adipiscing dolor amet do lorem ad elit consectetur minim consectetur elit aliqua enim labore sit lorem adipiscing aliqua tempor ad ad consectetur sed sit dolor do elit incididunt do magna amet do amet do magna sit do dolore sit adipiscing labore incididunt ad sit lorem incididunt et ad lorem do veniam et et tempor consectetur adipiscing et magna adipiscing dolore quis magna ad elit amet ut veniam quis adipiscing veniam tempor et elit ipsum elit sit tempor dolor veniam ipsum adipiscing ut eiusmod quis ut labore labore labore minim enim quis enim ad ad labore tempor ipsum adipiscing minim sed amet dolore quis sit ut adipiscing eiusmod sit lorem quis ad elit adipiscing veniam incididunt adipiscing do do minim tempor elit lorem minim elit enim sed do consectetur minim veniam sit lorem tempor quis amet veniam aliqua incididunt et labore minim sit elit enim tempor ipsum dolor elit consectetur adipiscing ut amet quis incididunt incididunt aliqua tempor dolor ipsum magna labore aliqua tempor do veniam tempor quis eiusmod tempor lorem sit incididunt do sed ipsum minim dolore et sed ipsum et eiusmod veniam ut quis labore aliqua magna dolore elit consectetur dolore ipsum incididunt sed adipiscing eiusmod adipiscing quis sit enim consectetur ut ut aliqua sed enim quis amet dolor sed elit veniam sed aliqua consectetur labore ut lorem amet do dolore amet amet ut ipsum labore dolore quis et dolore quis ipsum incididunt sit veniam quis do ut labore sit ad magna ut ut lorem sed enim ipsum do sed eiusmod dolore lorem amet magna ipsum adipiscing eiusmod quis sit consectetur do quis ut dolore amet dolor dolore et dolore dolor ut tempor ad amet labore incididunt enim eiusmod minim do et magna dolor dolore amet lorem ad dolor adipiscing enim enim veniam tempor et dolore amet consectetur veniam amet ut ipsum dolor tempor ad quis veniam do minim sed quis tempor tempor do ut incididunt et labore tempor eiusmod enim veniam ut amet amet veniam et sed ad veniam sed ut aliqua et enim ipsum do dolore et tempor et amet labore amet ad veniam et amet elit eiusmod dolor minim magna aliqua aliqua tempor consectetur ut ad ut do sed elit enim lorem ad et tempor dolor sed et quis incididunt labore ipsum ut sed et dolore amet eiusmod amet adipiscing quis incididunt sit sit eiusmod amet et ad dolore labore dolore amet et amet ipsum adipiscing veniam incididunt eiusmod ad quis sed et do ipsum ut dolor adipiscing lorem aliqua eiusmod incididunt do elit do ut tempor labore eiusmod minim quis sed sit minim tempor ipsum do adipiscing quis aliqua sit enim quis sed lorem sed eiusmod sit incididunt labore do magna sed tempor amet et ipsum sit incididunt labore eiusmod lorem labore ad elit amet eiusmod amet adipiscing et consectetur do tempor elit ad veniam minim adipiscing enim ipsum enim labore sed minim minim labore labore et tempor ut ut dolor elit tempor ipsum eiusmod sit minim incididunt magna veniam veniam et eiusmod amet adipiscing dolor sed et et labore eiusmod labore magna dolor et enim sed quis magna ad sit veniam aliqua amet ut dolor quis amet incididunt sit ut quis magna adipiscing amet lorem magna minim enim sit sit dolor ad eiusmod sit minim aliqua magna ad tempor ut minim incididunt dolor ut ad labore do quis ut labore incididunt enim magna enim amet labore enim et incididunt sit eiusmod sed ad amet sed minim ipsum sit consectetur quis minim ipsum lorem eiusmod eiusmod ipsum consectetur ut labore enim lorem ut magna aliqua incididunt sit minim incididunt ipsum lorem amet elit dolore et ad incididunt eiusmod amet do enim amet aliqua aliqua amet magna amet amet aliqua elit quis adipiscing lorem adipiscing et magna labore tempor et ad ut dolore lorem ut elit veniam incididunt sed enim lorem dolore eiusmod sit dolore elit ut sed amet dolore labore aliqua magna tempor sed sit quis quis quis dolor veniam tempor incididunt labore tempor ut minim dolore labore et incididunt magna lorem ipsum et eiusmod elit sit lorem tempor dolor veniam consectetur veniam et sit elit amet labore quis dolor consectetur ad sed et veniam tempor consectetur elit ipsum do ad labore magna magna labore enim do elit lorem do et amet adipiscing adipiscing consectetur do dolor sed consectetur incididunt ad aliqua do quis consectetur labore incididunt minim dolor tempor enim tempor elit lorem magna enim consectetur labore enim amet do incididunt amet eiusmod eiusmod sed lorem amet adipiscing sed adipiscing ad lorem ipsum ad ipsum labore do elit dolore ad sit quis dolor enim amet adipiscing consectetur lorem ut consectetur consectetur labore eiusmod ipsum labore enim dolore tempor veniam do aliqua amet magna enim dolore ipsum elit sit labore et elit dolore eiusmod sit minim do amet sed ad ut sed sit lorem lorem tempor dolore consectetur ipsum eiusmod consectetur ipsum ipsum lorem sed elit lorem quis do et quis quis enim ad et eiusmod aliqua dolor adipiscing consectetur tempor veniam quis dolor tempor amet tempor adipiscing labore incididunt labore tempor enim aliqua dolor elit elit sit elit dolor quis do dolore tempor dolor sit aliqua enim tempor elit magna do ad do sit consectetur veniam ut adipiscing labore amet adipiscing dolor ut dolor incididunt amet aliqua elit do sed enim dolore quis aliqua et incididunt sit sit minim tempor labore et minim incididunt adipiscing aliqua eiusmod amet ad sed eiusmod ad adipiscing enim ipsum minim incididunt sed eiusmod sit ad amet adipiscing tempor et ad eiusmod aliqua ipsum ipsum veniam labore amet labore et dolore adipiscing sed sed enim amet do sit eiusmod elit eiusmod eiusmod adipiscing sit ut adipiscing ut amet dolore magna dolor incididunt lorem incididunt amet incididunt tempor enim dolore incididunt enim amet quis minim dolor minim dolore elit adipiscing et et incididunt veniam eiusmod sed magna lorem dolore dolore veniam quis quis sed lorem incididunt quis dolore incididunt amet consectetur enim sed sit ut sit veniam et incididunt ipsum et dolor aliqua dolor elit eiusmod incididunt enim minim minim eiusmod tempor veniam minim sed elit ut amet elit minim incididunt enim quis ipsum elit adipiscing aliqua amet aliqua eiusmod consectetur sit adipiscing ut ipsum dolore eiusmod magna veniam tempor tempor minim veniam ut elit tempor incididunt dolor elit labore amet tempor ad tempor dolor labore dolore ut incididunt sed dolor labore labore minim amet sed veniam veniam lorem dolore tempor ut elit tempor veniam labore eiusmod labore dolore lorem amet veniam elit veniam sit elit sed tempor elit aliqua consectetur labore tempor tempor veniam ipsum veniam minim consectetur incididunt magna tempor tempor minim magna aliqua ut do dolore sed labore dolor ipsum sit magna sed quis do adipiscing ut magna aliqua adipiscing elit sed dolor ut incididunt minim dolore do do enim et dolor ut elit veniam adipiscing et sit dolore tempor aliqua magna dolor ipsum dolor eiusmod elit labore dolor adipiscing ipsum labore amet dolor minim et dolor ipsum amet et amet veniam et ut et do lorem enim sed magna ad sit enim dolor ad magna magna enim tempor ipsum elit magna minim magna amet lorem incididunt ipsum amet eiusmod minim incididunt magna dolor enim labore do eiusmod adipiscing ut et dolor incididunt sed lorem ad minim ad sit do quis elit aliqua aliqua incididunt lorem incididunt dolor ad aliqua dolor elit dolor ut dolore labore magna do dolore ipsum amet et et enim tempor amet magna sit adipiscing sed magna lorem et ad minim aliqua labore amet amet eiusmod incididunt labore sed enim labore aliqua tempor veniam incididunt minim enim aliqua dolor lorem adipiscing magna elit elit enim minim tempor ut magna sit dolor lorem elit ad eiusmod elit quis adipiscing dolore consectetur magna dolor dolore consectetur ipsum do ad sed aliqua veniam minim eiusmod tempor ut tempor adipiscing lorem enim aliqua et amet consectetur incididunt lorem consectetur lorem sed tempor adipiscing ut minim adipiscing elit ut minim aliqua adipiscing ut aliqua incididunt ipsum consectetur aliqua lorem ad adipiscing sit ipsum do amet magna incididunt enim tempor consectetur aliqua minim consectetur consectetur dolore amet et ad dolor labore consectetur do sed tempor labore elit aliqua veniam ipsum quis elit ad adipiscing sed elit quis veniam ut quis veniam sed veniam elit tempor et ut adipiscing labore dolore minim dolore eiusmod ipsum elit elit magna amet ut sit magna dolor ut ut dolore incididunt enim labore sit adipiscing ipsum incididunt adipiscing magna veniam adipiscing ut dolore quis dolore veniam enim dolore enim et tempor ad sit incididunt ad minim do dolore tempor eiusmod consectetur ut minim magna elit adipiscing dolor elit dolor sed minim ut quis elit et ad sed ipsum incididunt tempor incididunt labore ut adipiscing ipsum do elit amet amet eiusmod minim minim quis magna minim do enim aliqua labore ut minim do tempor quis eiusmod sed elit labore incididunt quis eiusmod ipsum aliqua adipiscing minim sit minim ad amet elit tempor amet veniam dolore labore incididunt sed lorem ut eiusmod amet eiusmod dolor adipiscing incididunt adipiscing incididunt enim dolore magna dolor minim ad labore adipiscing sit amet incididunt sit incididunt dolore aliqua quis elit labore et magna dolor consectetur lorem tempor ipsum aliqua labore amet et incididunt adipiscing quis adipiscing enim ipsum eiusmod adipiscing et sed quis consectetur magna et dolore quis dolore ut ipsum amet adipiscing lorem do ut veniam dolor consectetur ad lorem incididunt do dolore amet do amet consectetur do dolore elit minim do labore enim adipiscing dolore adipiscing veniam ipsum adipiscing enim incididunt eiusmod tempor minim incididunt ipsum minim incididunt dolor consectetur et amet tempor do consectetur ipsum veniam et labore tempor tempor tempor enim dolore quis magna adipiscing magna amet elit ut minim dolor elit sed do magna labore eiusmod ad labore lorem et veniam et amet lorem ut incididunt consectetur do magna veniam incididunt adipiscing aliqua minim incididunt quis veniam lorem elit ad et eiusmod tempor labore do dolor ipsum dolore eiusmod consectetur amet ipsum tempor et elit enim ad veniam ipsum ipsum lorem et labore labore ut elit incididunt consectetur sit elit do do elit lorem sit adipiscing ut minim do et sed do sit ad labore amet sed eiusmod do aliqua magna eiusmod ipsum do adipiscing sed labore dolore quis dolore elit lorem eiusmod labore sit dolor ut tempor sed ipsum amet veniam veniam ad dolore do tempor eiusmod incididunt consectetur ipsum labore eiusmod consectetur enim elit et consectetur enim ut magna incididunt sit do dolor enim labore consectetur aliqua ut et ad amet quis dolor lorem magna veniam magna et aliqua enim magna amet elit ipsum magna do ut minim aliqua labore sed aliqua tempor magna eiusmod dolore tempor aliqua ipsum consectetur ut elit et ad tempor minim sed quis quis elit dolor enim sed do dolore ipsum do et et veniam consectetur dolor minim aliqua dolore magna adipiscing ipsum aliqua aliqua dolore eiusmod do dolor magna enim elit aliqua ad consectetur amet minim quis ut ad enim eiusmod ad veniam adipiscing enim labore minim consectetur lorem adipiscing ipsum lorem dolor incididunt tempor ut adipiscing consectetur lorem ut ipsum elit ipsum incididunt sit tempor tempor magna enim amet incididunt dolore ad sit quis eiusmod et ad lorem labore elit incididunt magna dolor ut enim aliqua incididunt lorem tempor dolore do elit incididunt et incididunt tempor ipsum ipsum ut enim ut aliqua consectetur veniam amet eiusmod adipiscing amet et ut eiusmod lorem tempor tempor tempor quis dolor incididunt amet veniam ad ipsum amet ipsum quis do sed eiusmod ipsum dolor amet amet elit eiusmod adipiscing consectetur labore adipiscing ut tempor amet do aliqua consectetur labore lorem aliqua consectetur quis ad sit ipsum quis amet ut minim do dolore adipiscing ipsum dolor enim dolore dolore magna veniam ut quis sed veniam et magna labore labore ad aliqua enim dolor aliqua eiusmod sit do elit ipsum elit sit adipiscing consectetur ad incididunt incididunt ad amet aliqua elit magna ad adipiscing et veniam aliqua ad amet minim quis ad sit incididunt labore tempor minim lorem enim et ad et ipsum elit enim do consectetur dolore enim et dolor quis eiusmod dolor sed veniam dolore do minim amet magna ad ipsum eiusmod dolor amet dolore veniam amet consectetur minim lorem enim magna lorem ipsum dolor magna tempor et ipsum minim dolore ad minim magna dolor labore labore aliqua minim lorem sed tempor labore dolor tempor dolor consectetur consectetur aliqua lorem aliqua incididunt adipiscing aliqua minim elit amet et sit tempor dolore minim et enim sit quis enim magna minim consectetur dolore do sit do dolor enim sit aliqua eiusmod magna labore aliqua quis aliqua do labore do dolore labore magna labore aliqua amet do aliqua sed dolor minim do ipsum aliqua incididunt veniam amet et aliqua ad quis veniam eiusmod minim sed sit aliqua do ut elit elit incididunt magna aliqua dolor incididunt minim amet sed ipsum minim sed elit eiusmod dolor sed incididunt sit amet elit et eiusmod labore ut dolor dolore aliqua labore ipsum ut adipiscing incididunt aliqua aliqua minim sed enim enim amet amet incididunt ipsum lorem ad ipsum labore lorem tempor dolore labore eiusmod consectetur veniam minim adipiscing quis labore enim adipiscing minim adipiscing incididunt eiusmod veniam labore sed sed consectetur do minim dolor enim enim magna dolor dolore enim et aliqua aliqua magna elit sit et sit labore dolore magna consectetur sit veniam ad eiusmod dolore veniam incididunt aliqua elit dolore sit labore elit sit dolor et sed aliqua dolore do lorem eiusmod enim minim incididunt elit ut amet dolore aliqua labore dolor et sed ut quis magna aliqua magna dolor veniam sit incididunt sit sed incididunt ipsum dolor magna tempor dolor incididunt minim et et quis minim ad ad consectetur incididunt ipsum sed incididunt minim incididunt incididunt labore lorem veniam minim elit magna amet dolor et incididunt adipiscing sit veniam veniam labore adipiscing incididunt ad incididunt ut lorem sed lorem ipsum et quis ut amet enim consectetur quis adipiscing dolore incididunt do dolor magna ipsum ut veniam amet labore consectetur do ipsum ad do aliqua do ipsum enim dolore eiusmod do ipsum et dolor consectetur quis ad minim enim incididunt veniam ad et sed labore lorem ut ipsum do ipsum tempor adipiscing eiusmod consectetur elit amet dolor ipsum sit amet do eiusmod et aliqua aliqua enim et lorem incididunt aliqua magna incididunt elit quis dolore amet magna sit ut magna incididunt elit magna lorem enim aliqua magna eiusmod ut incididunt magna ad minim adipiscing amet ut consectetur sit aliqua sit quis do consectetur tempor et et dolore consectetur aliqua sed ad veniam elit sed dolor veniam dolore eiusmod elit ad enim magna elit sed consectetur ad amet ipsum labore tempor amet enim elit do quis ipsum ut labore et quis ipsum consectetur magna incididunt minim minim et ad quis eiusmod do sed consectetur tempor minim dolore quis quis tempor dolor ut elit veniam tempor sit tempor elit veniam dolor tempor minim magna minim minim minim do ipsum aliqua tempor dolore lorem incididunt minim sit lorem lorem aliqua consectetur labore sit adipiscing tempor dolor dolore amet incididunt consectetur labore enim sit dolore sed veniam et consectetur tempor minim amet sit ad amet dolor ad incididunt consectetur consectetur elit do sit ipsum enim adipiscing lorem enim veniam adipiscing lorem ad labore veniam adipiscing enim incididunt do amet eiusmod tempor enim incididunt sit enim enim adipiscing eiusmod lorem ut labore quis adipiscing consectetur lorem dolore sed labore elit dolor dolor adipiscing enim quis amet elit elit veniam magna tempor dolore dolore lorem aliqua dolore adipiscing labore ipsum sit consectetur ut amet minim et dolore elit elit ipsum tempor consectetur magna minim consectetur ut magna elit sed tempor ad enim magna adipiscing do aliqua elit sit magna ipsum eiusmod do magna consectetur quis amet ut eiusmod magna do enim lorem ad magna elit lorem eiusmod et ipsum adipiscing incididunt sit labore veniam ad incididunt et magna magna adipiscing labore sit minim ad adipiscing ad consectetur ad sed enim veniam sed lorem dolor minim minim incididunt lorem adipiscing dolore eiusmod sed ad aliqua adipiscing et magna amet labore ipsum incididunt dolore incididunt incididunt ipsum ad ipsum do tempor elit quis adipiscing labore magna et et ipsum magna adipiscing sit eiusmod veniam do ut quis elit veniam quis consectetur sed aliqua sed minim magna aliqua tempor sit minim veniam tempor ut dolore ut labore et elit sit consectetur dolore enim labore enim labore ipsum sit dolor incididunt incididunt sed adipiscing ad minim et aliqua minim minim tempor enim incididunt magna dolore sit aliqua lorem elit et incididunt sed enim sed dolor consectetur incididunt sit ipsum adipiscing tempor consectetur consectetur do aliqua sit elit ad lorem ut do consectetur amet aliqua amet enim eiusmod magna adipiscing sit eiusmod minim et adipiscing do enim veniam ipsum veniam enim adipiscing consectetur eiusmod minim dolore adipiscing adipiscing ad ut sit eiusmod aliqua aliqua veniam sed consectetur lorem ad veniam veniam dolore do incididunt magna incididunt incididunt dolor eiusmod eiusmod amet sed sed enim labore consectetur labore adipiscing incididunt et dolor labore veniam sit magna consectetur sed do ut do quis do adipiscing tempor ad veniam amet minim enim adipiscing magna ad sit ut adipiscing sed magna magna minim ad elit amet minim aliqua minim dolor eiusmod ipsum quis labore sed ad veniam ipsum minim ipsum enim elit ipsum quis tempor dolor consectetur minim consectetur adipiscing adipiscing ad enim ipsum dolore enim enim veniam ad dolore lorem minim ut et ad ipsum magna elit dolore elit minim sit eiusmod ut consectetur ipsum dolore enim incididunt do tempor lorem labore eiusmod incididunt labore et et tempor quis ad consectetur ut ipsum minim veniam dolore eiusmod sed aliqua ipsum lorem incididunt amet et adipiscing incididunt magna enim quis labore consectetur elit dolore ipsum enim consectetur ut labore quis aliqua ad quis lorem adipiscing ipsum aliqua enim incididunt dolor veniam dolore incididunt lorem amet elit veniam incididunt eiusmod adipiscing sit ad incididunt eiusmod ipsum enim dolor adipiscing tempor tempor veniam ipsum ad ut aliqua do ut do ad dolore consectetur quis consectetur dolore aliqua amet minim veniam lorem aliqua lorem ut adipiscing elit labore sit lorem ut consectetur magna do dolore quis labore quis minim consectetur enim aliqua incididunt adipiscing veniam do eiusmod sit ad sit magna sit et ipsum magna incididunt tempor magna ipsum sit labore sed ipsum aliqua eiusmod quis labore amet do labore ipsum amet do magna sit aliqua sit ad dolor ut ut dolore dolor ut tempor magna aliqua consectetur veniam aliqua et et veniam ad veniam enim dolore ut do labore labore elit adipiscing aliqua magna adipiscing amet ipsum sed quis lorem labore labore minim consectetur adipiscing do magna do amet dolor consectetur dolore dolor minim consectetur consectetur ut consectetur adipiscing ut sed eiusmod minim amet magna elit ut eiusmod quis lorem quis quis elit consectetur ad do ipsum sit elit enim minim lorem ut aliqua lorem dolore ipsum consectetur minim enim lorem magna labore quis quis ut ad amet tempor incididunt elit minim aliqua et veniam magna ad sed sit dolore quis do lorem do ad dolore ipsum do ipsum dolor tempor tempor sit minim dolore labore sed veniam ipsum ipsum magna sed eiusmod tempor elit sed et sed dolor elit ut incididunt et consectetur enim ut labore ut elit labore dolore ad dolor quis dolore incididunt incididunt adipiscing adipiscing enim amet ipsum ad amet labore tempor tempor minim sit sed elit eiusmod do lorem minim sed ut labore sed ad eiusmod veniam veniam dolor veniam quis lorem sed ut veniam amet elit enim tempor enim incididunt lorem elit magna veniam quis consectetur elit minim sit adipiscing sit adipiscing quis ad elit ipsum ut quis eiusmod amet quis minim lorem labore ad enim adipiscing ipsum enim ipsum veniam sit ipsum adipiscing tempor dolor incididunt aliqua enim adipiscing minim eiusmod incididunt do consectetur enim do do sed aliqua tempor elit elit sit quis incididunt amet tempor do tempor enim dolore aliqua tempor ipsum dolore ipsum dolor ut eiusmod dolore tempor magna elit do dolore do incididunt dolore magna eiusmod consectetur amet magna sit minim enim amet minim elit veniam do ut ut sed dolore ad enim minim ad tempor do labore labore ipsum labore magna ut lorem aliqua sit do enim dolore consectetur ad dolor sit elit tempor labore tempor minim do amet sed minim sit quis amet minim et eiusmod magna elit tempor ipsum ipsum sit consectetur et labore minim dolore dolor incididunt ipsum aliqua quis amet dolor do lorem ad enim labore elit enim quis elit adipiscing veniam amet magna aliqua incididunt amet aliqua veniam amet consectetur tempor minim ipsum tempor lorem quis minim minim et labore dolor ipsum veniam veniam labore amet incididunt ad sed ipsum ipsum dolore ipsum consectetur elit enim quis do dolore sit aliqua do consectetur ipsum aliqua sit et amet sed sit magna dolor minim eiusmod amet elit elit eiusmod aliqua labore tempor aliqua veniam minim lorem aliqua dolor quis sed aliqua magna consectetur lorem quis magna ad tempor enim do magna consectetur ad lorem et magna consectetur tempor aliqua dolore tempor veniam magna ut et et tempor ut sit minim dolor sit elit eiusmod adipiscing ipsum veniam enim aliqua veniam ipsum aliqua tempor elit enim ut incididunt ipsum minim ipsum ut quis aliqua sed minim aliqua tempor veniam dolor sit eiusmod consectetur tempor incididunt labore consectetur quis consectetur ut veniam et adipiscing lorem dolore quis consectetur adipiscing minim ad consectetur minim dolor enim quis quis enim enim lorem dolor adipiscing labore sed ipsum incididunt sed ut quis elit labore sit dolor adipiscing adipiscing adipiscing lorem consectetur ut ad et labore eiusmod consectetur minim adipiscing ut dolor incididunt veniam tempor tempor dolor dolore minim labore dolore minim magna veniam lorem adipiscing sed tempor tempor lorem adipiscing elit ut eiusmod tempor minim enim labore labore veniam quis quis sit quis magna ipsum ad adipiscing eiusmod dolor ut sed veniam minim elit ipsum do sit do aliqua amet ut tempor dolore dolor do dolor labore et consectetur elit aliqua lorem magna lorem adipiscing adipiscing eiusmod enim dolor aliqua incididunt ut dolore ad incididunt minim aliqua eiusmod incididunt labore do dolore tempor adipiscing amet magna ad do magna sit quis et tempor incididunt veniam consectetur minim ipsum dolor et minim ipsum incididunt amet aliqua quis amet consectetur dolore dolor quis incididunt magna adipiscing dolore incididunt tempor veniam aliqua ut consectetur ut aliqua sed elit quis aliqua tempor enim dolore lorem veniam do do dolore sed amet adipiscing labore ipsum sed sit quis minim dolor ipsum ad ad dolor et amet et labore enim incididunt elit minim ipsum ut consectetur ipsum do labore ipsum amet dolore ad ad adipiscing adipiscing ad veniam consectetur adipiscing amet lorem incididunt ad lorem incididunt enim tempor tempor eiusmod amet eiusmod eiusmod magna veniam eiusmod ad ipsum eiusmod labore consectetur dolor lorem quis lorem et minim sit adipiscing incididunt enim dolore ut enim sit sed dolore ut ipsum labore adipiscing ipsum magna lorem veniam quis do ut dolor eiusmod tempor aliqua incididunt ipsum enim minim sed amet adipiscing lorem consectetur labore ipsum enim aliqua ut veniam sit magna ipsum dolore consectetur veniam ad minim ad labore dolor lorem magna lorem amet elit lorem magna ipsum dolore ad aliqua minim elit enim veniam ut veniam sit et tempor eiusmod consectetur quis minim adipiscing elit dolor ad adipiscing consectetur veniam do dolor dolor veniam adipiscing amet quis dolor labore sed tempor elit amet consectetur aliqua elit ut dolor tempor dolore magna consectetur ipsum magna minim ipsum sed lorem magna quis aliqua et ut adipiscing aliqua sit tempor veniam eiusmod dolore dolore aliqua quis enim minim sed consectetur quis aliqua do do et dolore eiusmod dolore ad enim ut sit ipsum dolor dolor do enim ut ad incididunt tempor eiusmod aliqua dolor veniam amet magna aliqua quis labore dolore ut elit magna sed quis ut eiusmod ad do consectetur ipsum sit quis sit labore sit quis et veniam tempor sed sit eiusmod incididunt sit consectetur dolore quis magna labore quis dolore dolor et eiusmod aliqua sit eiusmod sit sit magna elit et elit et eiusmod ipsum consectetur ipsum lorem ut minim eiusmod do magna enim quis elit tempor amet minim quis dolor ad adipiscing ipsum consectetur veniam tempor ut minim sed adipiscing consectetur adipiscing incididunt dolore consectetur consectetur elit labore amet enim enim enim do aliqua eiusmod consectetur minim eiusmod magna aliqua enim do elit adipiscing consectetur do ipsum amet amet lorem ut ipsum tempor veniam labore amet ut adipiscing consectetur magna tempor quis consectetur quis dolor veniam sed tempor eiusmod ipsum dolore do minim amet quis enim et ad ipsum labore ad ut enim dolor lorem lorem ipsum lorem lorem adipiscing tempor adipiscing labore ipsum veniam ipsum elit do adipiscing magna consectetur adipiscing aliqua adipiscing tempor magna adipiscing quis amet aliqua veniam sit eiusmod consectetur magna ad labore minim et lorem magna et dolor lorem labore eiusmod aliqua tempor tempor ut amet veniam sit sit labore minim eiusmod consectetur ad dolor incididunt lorem dolore labore lorem minim enim amet do sed do ipsum et et ipsum aliqua amet lorem et enim ut ipsum elit sit quis incididunt minim magna dolore lorem aliqua do lorem lorem elit dolore veniam ad incididunt sed ad tempor quis lorem adipiscing enim quis ut adipiscing quis labore dolore ipsum amet magna enim sed ad ipsum sit incididunt sit ipsum et enim et amet sit veniam et sed consectetur ipsum sit magna labore dolor consectetur eiusmod labore magna consectetur veniam et quis tempor sed veniam do et consectetur minim do dolore lorem consectetur elit sit quis incididunt dolor sit do veniam sit sed minim elit consectetur minim tempor sit labore sit eiusmod dolore magna dolor labore aliqua ut dolor dolore enim sit labore enim et sed incididunt labore et incididunt incididunt sit incididunt eiusmod ad veniam lorem dolor consectetur et ut lorem dolor quis incididunt minim dolore enim eiusmod ipsum lorem dolore ad lorem labore quis dolore consectetur labore do veniam ut dolor dolore quis enim adipiscing ut eiusmod et ut ad incididunt minim ad lorem aliqua veniam quis dolore ad magna sit consectetur incididunt magna amet sed adipiscing et quis amet eiusmod quis quis magna ad sit consectetur enim veniam ad et lorem do ipsum minim magna sit sed et quis consectetur ut sed tempor do eiusmod sed consectetur dolore aliqua adipiscing enim enim magna sit enim consectetur sed sit adipiscing ipsum minim minim amet dolore ad aliqua minim ad quis minim labore quis ad magna sit magna magna elit consectetur ut ut enim consectetur ipsum eiusmod veniam lorem eiusmod veniam consectetur amet tempor elit minim aliqua ipsum veniam quis ut ad consectetur eiusmod aliqua adipiscing ad elit et do sed aliqua ad dolore dolore veniam aliqua dolore et elit consectetur veniam dolor aliqua elit labore amet incididunt consectetur lorem veniam sit quis ipsum ipsum magna ipsum enim et labore quis lorem et sed do sed quis incididunt et sit dolor do ad incididunt ut adipiscing elit dolore amet dolor veniam veniam quis do adipiscing sit tempor sed amet elit tempor tempor consectetur quis sit sit quis adipiscing do elit ad dolor ipsum eiusmod enim quis incididunt adipiscing tempor enim minim veniam dolor labore labore eiusmod minim do eiusmod minim dolore lorem dolore dolor amet consectetur lorem lorem elit adipiscing veniam minim quis quis ut do ad consectetur sit incididunt dolore dolore lorem enim adipiscing dolor adipiscing consectetur eiusmod adipiscing quis eiusmod elit sed tempor incididunt veniam eiusmod ipsum labore adipiscing minim sit labore amet incididunt incididunt adipiscing eiusmod eiusmod elit et labore incididunt quis lorem labore tempor ad ad et eiusmod ipsum labore incididunt minim enim veniam aliqua minim et et veniam minim do ipsum dolore labore elit dolor ad do ad consectetur labore adipiscing sed consectetur magna do quis incididunt lorem adipiscing aliqua enim et lorem do ad quis sed magna sed dolor incididunt ipsum aliqua magna veniam ipsum adipiscing veniam et adipiscing incididunt eiusmod do et enim dolore sed veniam sed enim consectetur incididunt incididunt et magna elit elit ut enim labore dolor veniam incididunt ipsum lorem veniam adipiscing tempor adipiscing sit veniam ipsum et adipiscing ipsum minim consectetur eiusmod ipsum minim dolore sed adipiscing adipiscing ut dolore dolor aliqua consectetur sed ipsum amet lorem veniam ipsum aliqua magna adipiscing quis consectetur eiusmod amet consectetur veniam incididunt aliqua lorem lorem aliqua eiusmod dolore ad lorem adipiscing dolor quis et labore dolor consectetur sed dolore lorem ut do aliqua magna aliqua adipiscing consectetur eiusmod sit quis aliqua do veniam do adipiscing aliqua dolore sit lorem sed adipiscing adipiscing elit magna adipiscing et eiusmod incididunt enim et quis sit tempor dolor labore sed et quis ipsum lorem eiusmod et veniam lorem elit magna amet ipsum incididunt sit elit ipsum do enim tempor sit sit sed sed quis amet elit magna quis enim amet et ipsum ut labore veniam lorem lorem eiusmod ad ut do et ipsum quis labore eiusmod ut ad lorem consectetur sed tempor elit dolor amet enim veniam eiusmod incididunt magna magna aliqua veniam do dolore eiusmod tempor et amet enim adipiscing ut adipiscing sit dolor consectetur lorem ad lorem dolor labore dolore aliqua dolor consectetur tempor dolore magna ad consectetur consectetur quis ut dolor labore sit lorem et ad tempor incididunt quis amet aliqua tempor amet enim elit incididunt eiusmod adipiscing dolore ad magna sit do labore adipiscing aliqua minim labore amet sed ipsum consectetur adipiscing veniam et magna adipiscing ipsum incididunt ad tempor et dolore ut elit adipiscing ad dolor lorem amet et enim veniam adipiscing et sed incididunt sit dolore dolor sit tempor consectetur adipiscing minim ut do ut sed dolore ad elit incididunt ut ipsum ipsum quis quis adipiscing tempor incididunt eiusmod ut sed labore veniam incididunt consectetur amet veniam ut tempor veniam minim tempor aliqua tempor dolore ut ipsum tempor sit eiusmod ipsum adipiscing quis enim tempor consectetur magna aliqua quis do et magna consectetur ut tempor tempor lorem consectetur consectetur enim tempor veniam veniam et ad labore minim magna adipiscing sit eiusmod ad quis lorem ut elit labore do ut sed dolor magna adipiscing labore sit ad ipsum veniam lorem magna aliqua elit elit ipsum enim et minim eiusmod adipiscing adipiscing sit lorem veniam do ad sed veniam sit amet tempor labore ut eiusmod veniam ipsum dolore do dolor labore elit consectetur aliqua aliqua aliqua adipiscing dolore do aliqua ad aliqua et do minim sed sit magna ad sed consectetur consectetur dolore quis enim consectetur ut veniam do incididunt incididunt elit consectetur ut consectetur magna magna eiusmod elit adipiscing amet do veniam minim dolor ad dolor veniam elit sit ad do lorem amet incididunt incididunt ad ipsum sit enim ipsum amet labore incididunt do elit consectetur et elit ad aliqua elit enim sed dolore ut labore aliqua aliqua veniam do amet ad minim dolore amet ipsum amet ad magna amet aliqua lorem dolore sed magna magna consectetur veniam ipsum tempor et magna enim consectetur elit eiusmod ad ad consectetur veniam adipiscing minim consectetur aliqua et minim quis elit amet adipiscing ipsum dolore eiusmod elit incididunt labore veniam sed veniam consectetur sit ipsum dolor ipsum do et ipsum sit ad do enim tempor tempor elit adipiscing sed adipiscing consectetur eiusmod sed minim quis eiusmod tempor ipsum dolor adipiscing consectetur incididunt ad labore adipiscing enim lorem labore incididunt incididunt tempor minim tempor et enim enim lorem ad sed quis dolor minim ipsum incididunt ut tempor veniam incididunt consectetur do ad adipiscing enim dolor do lorem ut ipsum labore lorem incididunt adipiscing magna enim et sed lorem enim veniam quis adipiscing elit minim ad amet enim veniam eiusmod elit ad sed eiusmod ipsum incididunt do lorem ad labore lorem ut lorem sit consectetur minim elit lorem incididunt enim labore amet dolor adipiscing adipiscing ut aliqua aliqua veniam tempor tempor dolor quis elit adipiscing sit amet enim sed tempor veniam quis eiusmod ut sed ut tempor minim elit dolor labore elit ad sed ad lorem dolore enim eiusmod adipiscing tempor aliqua minim do tempor veniam adipiscing minim tempor eiusmod magna magna sed ut dolor incididunt adipiscing quis labore quis aliqua adipiscing adipiscing eiusmod et labore lorem ipsum do amet dolore incididunt dolor do magna aliqua amet eiusmod eiusmod incididunt et ad minim aliqua amet sed elit elit incididunt veniam aliqua tempor enim enim magna quis ipsum do labore dolore veniam tempor ad lorem amet et et lorem ipsum incididunt ad veniam ut quis sit adipiscing minim ut quis tempor ut labore incididunt ut dolor et consectetur dolore minim adipiscing consectetur sit quis ut tempor elit consectetur incididunt veniam aliqua tempor veniam enim tempor amet magna minim consectetur elit sed magna elit ad dolor dolor adipiscing aliqua ut et ipsum eiusmod elit dolor ut dolor eiusmod consectetur et elit tempor quis aliqua aliqua adipiscing do consectetur labore quis sit minim lorem sit sed magna do sit quis do adipiscing labore quis elit quis lorem ut dolor eiusmod labore labore labore magna ad elit ut sed incididunt enim dolor aliqua incididunt minim incididunt sit sit tempor tempor tempor incididunt et et adipiscing ad adipiscing amet adipiscing sit quis lorem aliqua veniam consectetur et eiusmod sed do dolor adipiscing veniam enim magna amet minim sed veniam elit sit aliqua do dolore ut eiusmod aliqua magna tempor amet dolore labore dolore elit ad eiusmod adipiscing magna quis eiusmod amet magna amet incididunt veniam do ipsum lorem veniam ipsum ut tempor ipsum dolore labore aliqua quis minim labore ad dolore do magna incididunt incididunt minim eiusmod sed et dolor lorem amet eiusmod dolor ad tempor ipsum ipsum ad incididunt eiusmod adipiscing amet ut elit do eiusmod lorem elit adipiscing sed incididunt do et incididunt et enim labore sed lorem labore labore labore dolore ut quis enim adipiscing enim tempor ad ut consectetur consectetur minim aliqua labore magna tempor enim dolore lorem adipiscing quis sit tempor quis ipsum ad veniam labore dolor eiusmod ad sit dolor dolore tempor elit veniam dolor eiusmod amet elit tempor elit sed elit dolore incididunt aliqua ipsum lorem sed quis sed et sit et minim ut sed sit ipsum tempor et tempor magna enim sed adipiscing ut quis incididunt consectetur aliqua ad tempor dolor magna labore do et quis tempor adipiscing eiusmod incididunt tempor consectetur labore tempor sed magna quis amet elit quis consectetur eiusmod minim veniam lorem sit amet adipiscing amet magna dolore ipsum incididunt amet amet eiusmod et labore sit lorem incididunt amet incididunt dolor quis enim amet dolor dolore sed do amet aliqua quis quis eiusmod minim veniam sit aliqua labore dolor dolore ad lorem adipiscing dolore tempor veniam labore sit adipiscing lorem aliqua lorem minim magna sit do ad minim lorem ut ad magna consectetur magna enim enim sed quis consectetur ipsum lorem aliqua adipiscing adipiscing consectetur quis veniam sit ad tempor ipsum minim veniam minim minim do sit enim consectetur adipiscing lorem ipsum elit consectetur ut aliqua elit amet lorem dolore labore et ipsum amet et sed labore magna veniam tempor aliqua eiusmod enim minim labore ut elit quis tempor labore et et lorem adipiscing eiusmod adipiscing sit eiusmod labore ipsum veniam consectetur sed minim magna elit labore veniam ut amet consectetur aliqua ipsum dolore aliqua eiusmod et quis minim veniam do magna sed sed dolore dolore incididunt elit dolore elit eiusmod do sed aliqua eiusmod aliqua incididunt sed elit enim enim dolor ad et consectetur tempor magna minim aliqua consectetur magna enim dolor labore et minim tempor eiusmod dolor magna dolore adipiscing elit minim veniam amet tempor eiusmod magna dolore dolore magna consectetur consectetur ad adipiscing aliqua adipiscing adipiscing magna ipsum aliqua ad ut adipiscing labore ut eiusmod minim lorem eiusmod consectetur amet elit ut magna et consectetur dolore sit sit aliqua sit lorem enim labore consectetur dolor magna dolor amet veniam lorem ut sed adipiscing tempor ad labore ad et labore enim et labore ad aliqua sed sit eiusmod eiusmod dolor labore aliqua minim incididunt sed incididunt eiusmod dolor do amet sed ad minim lorem amet consectetur consectetur enim incididunt sit elit incididunt consectetur veniam do tempor enim dolore amet incididunt sit enim incididunt tempor elit lorem sit adipiscing veniam incididunt dolor lorem aliqua tempor tempor incididunt sit amet enim consectetur adipiscing adipiscing labore elit dolore consectetur labore sed et elit incididunt lorem lorem sit consectetur ipsum elit eiusmod eiusmod sit ut et amet ad ipsum sed aliqua tempor veniam adipiscing magna eiusmod et amet do quis do lorem tempor et lorem enim elit elit ipsum magna minim magna do consectetur et do magna dolor adipiscing sit consectetur aliqua lorem eiusmod amet dolore quis amet quis ipsum adipiscing consectetur elit amet minim elit magna ad elit elit veniam quis aliqua do dolore enim ut elit quis aliqua amet incididunt aliqua minim minim quis aliqua amet minim consectetur incididunt incididunt dolore amet minim sit aliqua dolore amet magna adipiscing minim consectetur et elit et dolor eiusmod ipsum et amet labore amet dolore magna incididunt incididunt sit lorem consectetur adipiscing enim aliqua elit sed enim incididunt sed ipsum ipsum et labore ad dolor ut amet ut adipiscing enim lorem lorem sed quis lorem elit amet veniam adipiscing minim et aliqua sed ad consectetur dolore quis adipiscing sed tempor incididunt enim lorem incididunt dolor magna quis ut do lorem do sit adipiscing et sit tempor ad elit minim enim consectetur enim lorem ad incididunt incididunt aliqua ipsum consectetur ad magna amet ad sed et enim quis incididunt amet sit tempor quis labore enim elit sed enim consectetur consectetur labore ad labore adipiscing incididunt ad dolor adipiscing veniam ut consectetur labore ipsum dolor ipsum minim amet amet ut adipiscing enim incididunt dolore sit eiusmod ut minim aliqua incididunt do veniam adipiscing ut ipsum ipsum eiusmod sed incididunt et do dolor eiusmod aliqua amet ipsum dolor ipsum consectetur et eiusmod ut quis ipsum labore sit quis et sed adipiscing incididunt consectetur ut elit quis tempor incididunt veniam sit veniam et enim incididunt eiusmod ad quis quis ad minim elit ipsum dolor sed quis ipsum aliqua adipiscing ut adipiscing magna enim quis adipiscing ipsum dolor do ad dolor enim lorem dolore minim lorem minim amet labore consectetur ipsum ad ipsum ad elit elit adipiscing magna lorem labore elit ut elit ad amet tempor ipsum dolore magna tempor ut ipsum tempor quis lorem elit et aliqua incididunt adipiscing veniam et sed consectetur tempor ad do sit lorem aliqua dolore magna incididunt magna incididunt enim aliqua aliqua ad sit amet quis consectetur sed ad tempor ipsum do adipiscing incididunt ad ad dolor labore ipsum amet minim ipsum amet amet labore consectetur amet consectetur aliqua amet eiusmod aliqua elit enim sit tempor sed sit ipsum consectetur sit ipsum enim veniam elit ipsum do amet magna lorem veniam minim consectetur labore ipsum ut lorem sit consectetur dolor ipsum ipsum eiusmod et enim labore sed quis et magna sit dolore minim magna enim elit elit do magna ut et lorem do aliqua veniam et labore adipiscing quis minim incididunt amet consectetur consectetur dolor eiusmod adipiscing et veniam lorem sit eiusmod quis lorem dolore eiusmod enim minim elit amet adipiscing enim dolore tempor adipiscing quis eiusmod consectetur ut labore veniam consectetur incididunt tempor tempor do sed adipiscing tempor sit tempor enim minim veniam consectetur quis aliqua amet sed consectetur dolore dolore sed aliqua elit elit ad labore adipiscing ad minim sed minim sed ad minim et eiusmod consectetur tempor do lorem ad lorem dolore enim incididunt ut do veniam tempor amet amet minim aliqua sit dolor aliqua aliqua enim dolor sit consectetur elit tempor ipsum elit tempor ut ut magna sed labore incididunt ad lorem quis magna minim veniam tempor labore veniam aliqua incididunt dolor tempor aliqua ad sit tempor labore do sit ut do minim et ut labore amet adipiscing tempor enim quis adipiscing incididunt amet dolore eiusmod ipsum consectetur dolore sit dolor ad enim veniam adipiscing lorem ad et eiusmod et ut consectetur enim eiusmod quis elit ipsum do dolor lorem ipsum lorem minim quis labore elit enim eiusmod eiusmod enim eiusmod sit amet do sed ad magna dolor enim incididunt eiusmod et ad eiusmod consectetur aliqua do ipsum do ut lorem magna magna enim adipiscing amet minim sit quis magna aliqua labore sed eiusmod sit sit tempor ut quis ad labore ut incididunt ipsum enim magna eiusmod lorem sit adipiscing incididunt elit veniam do et ut minim tempor incididunt labore labore ut dolor aliqua do et do et dolor amet minim dolor sit minim ad quis dolore incididunt consectetur tempor consectetur dolor ut dolore lorem elit ut aliqua consectetur dolore dolor labore ipsum adipiscing tempor eiusmod sit amet elit ad lorem et consectetur et do adipiscing aliqua sed enim aliqua sed labore ipsum do eiusmod dolor et labore et ipsum tempor labore et tempor lorem tempor adipiscing veniam amet dolor dolor do ut ut eiusmod sed minim minim dolore minim sed sit incididunt elit quis dolor et amet consectetur magna dolore magna tempor elit do dolor consectetur labore tempor labore adipiscing incididunt ipsum do sed lorem eiusmod ad consectetur do enim incididunt do adipiscing do veniam tempor veniam et do minim sed quis labore ad adipiscing adipiscing adipiscing do incididunt ipsum lorem magna ad sit tempor incididunt tempor elit minim dolor quis ipsum elit ad dolore ad magna quis tempor ut veniam eiusmod eiusmod magna do ipsum sed sed labore ad incididunt enim aliqua incididunt ipsum magna enim minim sed ipsum dolore minim elit sed ipsum quis incididunt minim adipiscing eiusmod labore sed incididunt do sit magna dolore minim adipiscing consectetur dolore labore sed lorem ut magna ipsum eiusmod consectetur eiusmod ipsum adipiscing ut et elit et magna minim ad dolor tempor veniam ut consectetur veniam aliqua magna minim tempor sit eiusmod dolor adipiscing ipsum sit amet sit adipiscing magna eiusmod enim amet labore incididunt do lorem labore amet tempor et magna labore ad et minim quis labore incididunt quis dolor ipsum magna magna tempor ad amet eiusmod et ut lorem tempor sit ipsum tempor elit adipiscing minim ipsum quis ad incididunt do quis dolore quis incididunt ad minim ipsum amet ipsum adipiscing veniam elit aliqua incididunt quis enim eiusmod tempor labore enim tempor ipsum ipsum sit dolor quis aliqua dolor amet ipsum lorem sit lorem ut eiusmod aliqua minim elit magna dolore elit adipiscing labore labore enim labore incididunt lorem ipsum do adipiscing do veniam elit sed eiusmod sed aliqua aliqua minim veniam tempor dolor sed magna adipiscing ut consectetur aliqua ut amet aliqua elit incididunt lorem eiusmod incididunt dolor veniam ut ad aliqua sit dolore et elit et dolor consectetur do aliqua minim veniam sed aliqua eiusmod tempor veniam minim elit magna enim incididunt sit do elit veniam sed incididunt magna aliqua labore sed magna adipiscing adipiscing quis consectetur magna adipiscing elit do ad dolor dolor quis sed elit adipiscing aliqua tempor adipiscing amet ad amet incididunt labore dolor dolore aliqua amet adipiscing adipiscing et labore amet eiusmod ipsum ipsum minim adipiscing dolore veniam amet adipiscing minim aliqua amet enim labore ipsum aliqua eiusmod labore elit adipiscing dolor incididunt sed dolor lorem tempor dolore veniam consectetur eiusmod do et et sed sit labore do tempor dolore adipiscing ut dolor quis do elit quis ut sed sit adipiscing aliqua adipiscing sed ut tempor lorem lorem ad et eiusmod sit tempor veniam elit magna veniam dolor sit sit ipsum ut do ipsum aliqua enim ipsum tempor consectetur eiusmod labore eiusmod lorem ad labore ipsum veniam dolore dolore ad ad ad ipsum incididunt sit ut ad minim dolore sit minim tempor incididunt ut sit amet do incididunt elit incididunt labore enim ad minim quis aliqua ad incididunt quis magna et ut consectetur sit ad quis minim ipsum elit sit ipsum et tempor consectetur quis elit aliqua ad ad et aliqua veniam ipsum ut labore tempor aliqua quis aliqua sed veniam consectetur adipiscing enim et elit labore eiusmod adipiscing sit consectetur quis consectetur ipsum sit veniam ut dolore sit minim adipiscing enim enim incididunt elit incididunt dolor ut tempor labore labore minim magna ut enim sit veniam labore lorem veniam magna minim ut ipsum ipsum incididunt minim ipsum ad labore ut eiusmod ipsum aliqua enim labore et sed minim ut minim quis et veniam consectetur aliqua aliqua dolor amet eiusmod minim dolor incididunt elit ipsum elit eiusmod enim do minim adipiscing tempor labore quis minim adipiscing dolore adipiscing sit sit sed ut ad ut ad minim do elit amet sed sed elit lorem sit minim ipsum minim eiusmod dolore amet sit enim minim quis labore enim eiusmod aliqua sed dolor enim elit do minim ut do consectetur consectetur ad do elit consectetur amet elit labore minim et tempor minim lorem aliqua eiusmod incididunt ipsum tempor quis elit eiusmod et lorem et tempor dolore dolor dolor amet ipsum labore dolor tempor veniam sed elit amet sed dolore quis ad tempor incididunt et ad consectetur et eiusmod magna quis ut adipiscing sed aliqua incididunt labore magna dolor lorem adipiscing tempor enim dolor ipsum consectetur enim et enim et incididunt ad elit ut et tempor quis labore elit lorem dolore consectetur ad consectetur labore consectetur aliqua elit sit ipsum incididunt ad dolore ipsum veniam adipiscing eiusmod amet aliqua veniam adipiscing minim quis amet aliqua incididunt dolor amet labore minim sed quis et tempor magna veniam magna elit veniam ipsum consectetur tempor sed magna amet dolore quis eiusmod dolor dolore et amet elit elit adipiscing quis tempor elit enim enim veniam eiusmod sit veniam eiusmod quis enim amet dolore sed amet labore tempor sed incididunt ipsum labore quis dolore sed ut enim eiusmod ipsum minim ad tempor do elit quis ipsum quis ad ipsum dolore minim adipiscing ad sed adipiscing sit tempor et aliqua sit magna lorem adipiscing adipiscing tempor incididunt sit adipiscing elit enim consectetur sit labore elit elit aliqua lorem tempor lorem tempor ipsum consectetur dolor et adipiscing magna do ipsum sed minim labore lorem enim elit consectetur dolore amet ut tempor aliqua consectetur ad et labore eiusmod enim dolor sit enim aliqua enim incididunt ipsum tempor sit adipiscing labore veniam ut ut minim adipiscing minim ipsum aliqua incididunt amet elit tempor ad ipsum quis tempor eiusmod do adipiscing ipsum eiusmod labore adipiscing do lorem et ipsum ut ipsum tempor magna do ut do ut dolore minim sed ipsum incididunt ad adipiscing ad ipsum quis adipiscing sit sit quis ipsum eiusmod quis adipiscing do quis ut aliqua et ipsum minim eiusmod ad sit dolor enim aliqua lorem veniam tempor magna tempor minim ipsum amet ut consectetur quis sit sed veniam ut amet lorem adipiscing aliqua ut ut do eiusmod ut consectetur magna veniam sed veniam enim sit amet ipsum ipsum labore dolor veniam dolore magna sed do enim veniam magna consectetur et elit consectetur lorem veniam do magna sed sit ipsum aliqua quis consectetur dolore lorem tempor ad magna dolor enim enim aliqua aliqua enim lorem tempor dolore amet dolore lorem dolore consectetur ut incididunt labore lorem ut dolore dolor dolor lorem consectetur eiusmod dolore incididunt do consectetur veniam elit lorem labore lorem ad adipiscing elit dolore minim amet aliqua ipsum dolor enim do adipiscing dolor do sit eiusmod et dolor ipsum enim lorem magna ut lorem consectetur ad amet magna magna sit do incididunt amet consectetur do quis incididunt consectetur amet do eiusmod dolore minim incididunt enim enim et sed dolore do ad labore do lorem lorem tempor sed consectetur incididunt ut ut et et dolore ipsum magna elit elit labore elit ipsum sit labore aliqua ut ut magna ad minim tempor sed minim ipsum tempor magna ut eiusmod incididunt ad incididunt lorem aliqua et ipsum amet ad aliqua eiusmod do lorem veniam incididunt dolor ut ad dolore incididunt minim quis dolor quis adipiscing eiusmod dolor dolor ipsum magna dolore veniam ipsum quis do eiusmod dolor minim veniam sed dolor sit ad lorem consectetur sed magna enim ipsum dolore dolore ipsum magna eiusmod consectetur aliqua adipiscing lorem sed enim ut ut quis incididunt ut adipiscing enim consectetur et consectetur dolor adipiscing aliqua elit dolore lorem ad magna adipiscing elit labore minim aliqua dolore consectetur et elit magna dolore labore dolor quis consectetur tempor eiusmod labore adipiscing dolor aliqua labore sit ipsum minim enim ipsum aliqua tempor sit do amet eiusmod tempor elit consectetur sit dolor eiusmod adipiscing dolor minim amet tempor consectetur ad sit elit veniam et labore consectetur et ad sit dolor et sit dolore minim tempor minim ut ut eiusmod tempor ipsum tempor dolore eiusmod labore ipsum consectetur consectetur amet sit consectetur do ad minim tempor elit minim ad elit enim tempor lorem aliqua eiusmod aliqua amet dolor dolor tempor aliqua ad dolore tempor et labore tempor ad dolor labore ad quis ut ipsum incididunt adipiscing quis magna do ipsum eiusmod elit minim incididunt quis lorem incididunt et ut do labore adipiscing ad incididunt aliqua sed dolor amet lorem elit et eiusmod eiusmod dolor do minim amet consectetur lorem dolore adipiscing dolore quis dolore ipsum sed et sit sed eiusmod do sed tempor ad elit minim magna adipiscing enim labore dolor magna aliqua veniam minim sed incididunt amet magna amet sit eiusmod ad sit do amet ipsum amet ad aliqua lorem veniam ad ut veniam veniam consectetur elit dolor adipiscing sed labore amet et consectetur ut tempor do lorem incididunt dolor sed amet aliqua et lorem do minim consectetur tempor consectetur dolor sed lorem amet eiusmod minim tempor dolore magna ad minim amet sit adipiscing labore sed minim ad adipiscing adipiscing labore adipiscing dolore dolor dolor ut ut ut enim magna minim labore consectetur et aliqua quis sed sit adipiscing do sit ad tempor do tempor dolor lorem adipiscing eiusmod sit enim adipiscing labore minim incididunt incididunt magna adipiscing elit ut ut amet tempor sed ad tempor sit ipsum veniam veniam ad incididunt veniam tempor et aliqua consectetur eiusmod dolor enim labore elit do quis magna ut magna aliqua veniam veniam enim aliqua magna incididunt incididunt amet adipiscing adipiscing lorem consectetur tempor amet do eiusmod dolor minim lorem ipsum ipsum veniam sed dolore adipiscing adipiscing magna elit eiusmod dolore aliqua incididunt adipiscing dolor do sit adipiscing sit sed quis tempor aliqua magna magna amet sed dolor adipiscing minim veniam eiusmod lorem tempor ut dolor adipiscing minim aliqua ipsum lorem labore do magna elit dolore lorem incididunt labore consectetur labore quis magna ipsum lorem amet do et enim et ad ad ad magna veniam ipsum quis labore elit adipiscing dolor lorem ut amet lorem ipsum magna sed eiusmod dolor elit lorem magna amet sit tempor ad adipiscing sed et consectetur quis minim labore enim amet magna eiusmod consectetur incididunt aliqua adipiscing do enim minim minim sed labore labore amet consectetur consectetur consectetur et ut quis eiusmod consectetur enim amet sed magna ad quis minim ad lorem incididunt magna sed ad consectetur magna tempor quis quis sit magna sed ipsum consectetur ad veniam ut lorem dolor ad lorem aliqua magna lorem labore magna ut tempor enim amet consectetur ipsum lorem tempor quis aliqua ad veniam dolor ipsum sit amet amet lorem sed elit aliqua quis aliqua adipiscing minim dolor tempor ut tempor quis et incididunt dolore adipiscing sed quis magna adipiscing quis ut elit incididunt adipiscing sit eiusmod consectetur incididunt minim elit eiusmod magna tempor ipsum adipiscing consectetur eiusmod do enim labore sit lorem consectetur veniam magna tempor adipiscing consectetur sed consectetur sit adipiscing incididunt magna ut do adipiscing dolor do et dolore labore elit enim quis ipsum sed eiusmod incididunt aliqua quis amet ad eiusmod eiusmod labore consectetur dolore sit labore amet amet lorem incididunt consectetur amet sit magna ad adipiscing ad sit ipsum aliqua et elit magna incididunt veniam tempor do dolor elit tempor quis lorem sit sed sed do magna do consectetur ut veniam et eiusmod incididunt sed magna incididunt adipiscing ut tempor dolor veniam magna labore do do incididunt tempor veniam minim lorem do amet sit quis eiusmod elit minim elit dolore aliqua minim eiusmod amet enim ipsum tempor consectetur aliqua sed dolore ad incididunt veniam ipsum quis enim elit do eiusmod eiusmod dolore quis enim quis ipsum lorem ut do lorem sit amet aliqua do sit ipsum sed ipsum enim et et ipsum adipiscing adipiscing quis ipsum tempor sed tempor dolore elit eiusmod eiusmod et ipsum aliqua ad amet amet aliqua adipiscing ad elit veniam ipsum dolor ipsum ipsum adipiscing tempor ut quis consectetur adipiscing adipiscing tempor minim elit elit lorem ut eiusmod magna ad incididunt amet eiusmod minim ad amet sit labore do quis incididunt incididunt enim sit adipiscing veniam ad eiusmod veniam aliqua tempor veniam incididunt incididunt labore do dolor et ipsum et quis sit eiusmod consectetur consectetur eiusmod ut amet aliqua consectetur veniam consectetur quis enim tempor incididunt dolor enim adipiscing enim quis enim quis quis enim amet quis quis et tempor sed veniam consectetur do et ipsum incididunt amet enim labore do eiusmod enim aliqua sit tempor ut elit sit lorem labore sit eiusmod enim et enim adipiscing sit dolore lorem magna do ut adipiscing eiusmod ut ad enim adipiscing consectetur quis consectetur ipsum et ut sit consectetur lorem minim aliqua ipsum dolor labore aliqua ut tempor adipiscing dolore ipsum tempor et dolor tempor consectetur incididunt elit veniam dolor dolore sed magna aliqua ipsum aliqua ut amet dolore sed ut elit eiusmod ut adipiscing magna sit adipiscing tempor magna et magna consectetur eiusmod incididunt sit elit quis incididunt ut labore incididunt enim do veniam amet adipiscing eiusmod lorem magna dolor ad dolor eiusmod ut ipsum et enim veniam dolore sit lorem ad labore minim elit et minim enim do incididunt tempor sed magna adipiscing veniam veniam veniam magna ipsum veniam magna ad sit minim sit magna magna sit ipsum dolor consectetur quis do ut ipsum dolor sit adipiscing enim amet labore lorem consectetur adipiscing adipiscing adipiscing consectetur quis lorem tempor dolore ad lorem elit ipsum enim amet consectetur sit elit ut amet adipiscing ad tempor ipsum dolor minim tempor do do ipsum adipiscing et lorem dolor dolore ipsum dolor et adipiscing sit ad sit lorem ipsum ad ut labore sit ipsum lorem magna lorem enim sed sit minim sed do consectetur tempor ipsum sit magna eiusmod eiusmod amet dolore magna ut dolor magna sed magna enim dolor labore sit sit ipsum veniam ipsum dolor ad ipsum amet adipiscing ut minim do ad magna magna quis elit do ad dolor dolore dolor enim sed dolore do labore et enim sed ut ut elit lorem tempor sit quis consectetur minim minim enim veniam amet dolore veniam amet labore consectetur enim lorem enim lorem ut incididunt eiusmod dolore et enim aliqua do lorem quis lorem lorem dolor quis amet veniam elit veniam et adipiscing sit dolor sed sit adipiscing quis amet do amet eiusmod amet magna amet quis sit aliqua veniam incididunt et elit ipsum labore elit magna magna veniam dolore et aliqua adipiscing quis do adipiscing tempor do quis lorem ad enim et dolore quis consectetur ad incididunt aliqua minim minim sed veniam amet minim sed labore incididunt consectetur aliqua enim lorem labore do ut ut aliqua ut ut incididunt consectetur quis magna enim incididunt adipiscing adipiscing dolor ad labore minim minim dolore aliqua eiusmod elit quis veniam incididunt dolor do sit sit incididunt lorem adipiscing enim incididunt magna labore incididunt sed dolor elit incididunt sit dolore do labore minim do sed ut dolore labore elit tempor eiusmod elit tempor minim lorem sed ad dolore sit et minim eiusmod do ipsum ipsum sed magna incididunt incididunt consectetur aliqua dolor eiusmod sed lorem eiusmod do elit dolore sit incididunt labore minim dolore tempor eiusmod sed et adipiscing dolore ad tempor ipsum incididunt ut magna minim eiusmod et lorem sit eiusmod enim labore labore veniam quis ad dolore sit sed amet adipiscing lorem minim minim minim quis labore magna lorem dolor amet lorem quis magna minim ipsum lorem enim dolor ad labore et quis incididunt tempor ut lorem adipiscing consectetur lorem amet aliqua dolor adipiscing adipiscing elit lorem et eiusmod elit aliqua amet ut incididunt dolore minim et adipiscing incididunt sed dolore ad do elit consectetur tempor lorem ut sed tempor sit veniam tempor tempor consectetur quis ut dolor dolor elit elit ad ad quis ipsum adipiscing sed amet eiusmod enim adipiscing minim minim ipsum et adipiscing enim veniam sit elit lorem dolore magna veniam sed lorem dolor et ipsum dolore incididunt sit ad ut incididunt incididunt aliqua tempor et tempor minim eiusmod labore quis ad sed dolore amet magna consectetur sit ut amet quis veniam dolor adipiscing veniam incididunt ut veniam aliqua do dolore minim labore ipsum eiusmod consectetur aliqua adipiscing aliqua eiusmod incididunt sed labore enim amet magna incididunt elit amet quis veniam quis eiusmod aliqua veniam adipiscing elit incididunt veniam lorem et veniam minim do amet quis minim aliqua adipiscing eiusmod eiusmod sed quis ipsum lorem dolore dolor elit incididunt aliqua quis consectetur dolore aliqua magna ipsum dolore adipiscing ad elit elit dolore eiusmod ut eiusmod ipsum veniam ad lorem magna ad enim labore eiusmod quis eiusmod consectetur quis elit et lorem incididunt ipsum do magna ut lorem do amet quis amet ad incididunt lorem ut et enim veniam amet adipiscing veniam sit eiusmod ad et ut dolor eiusmod tempor adipiscing dolor adipiscing enim ut sit aliqua ut magna amet dolore incididunt ut ut labore et enim elit enim ut aliqua elit minim dolor lorem eiusmod tempor elit sed ad ut eiusmod minim consectetur tempor elit adipiscing aliqua veniam amet et consectetur consectetur amet minim elit magna ipsum incididunt tempor eiusmod et magna tempor tempor quis quis elit et ut labore elit dolore sit minim amet adipiscing amet enim aliqua elit amet eiusmod ut labore ad labore labore sit minim adipiscing lorem labore incididunt et adipiscing aliqua enim labore ad dolor aliqua consectetur labore do ipsum incididunt enim veniam do consectetur consectetur labore do minim do lorem et et do tempor magna et eiusmod dolor dolor et magna consectetur labore minim ut adipiscing quis minim eiusmod sed quis veniam amet sed incididunt eiusmod lorem enim dolor labore magna quis veniam quis labore tempor quis et do incididunt do sit lorem veniam ipsum lorem amet lorem sed consectetur ipsum et veniam veniam ut aliqua ut eiusmod incididunt dolore adipiscing amet enim aliqua minim lorem ut ad eiusmod dolore incididunt minim ad elit elit adipiscing amet et adipiscing ad aliqua eiusmod ipsum consectetur dolor consectetur minim lorem ut do veniam ipsum minim ut enim adipiscing adipiscing et minim lorem dolore enim dolore aliqua veniam do minim ad enim elit sit eiusmod lorem et ut adipiscing elit labore consectetur consectetur amet magna consectetur labore tempor sit elit minim do enim ut ut labore minim lorem incididunt amet ut dolore sed incididunt enim tempor do quis ut et quis enim aliqua ad sit eiusmod sit consectetur amet do veniam minim dolore dolore veniam veniam consectetur dolor labore et ut enim sit dolore magna ad et incididunt magna incididunt tempor do do labore et quis labore do sed et elit eiusmod adipiscing minim dolore magna magna ut do sit magna ipsum eiusmod incididunt minim et sit dolor sit labore eiusmod do incididunt dolor tempor adipiscing et dolor dolor labore tempor eiusmod minim do sit incididunt ipsum adipiscing minim labore quis et sit do tempor elit sit et amet ut ipsum ipsum lorem ipsum sit sed veniam enim sit adipiscing sit sed aliqua lorem enim dolore magna dolore dolor do enim consectetur quis veniam labore amet consectetur quis quis enim ad minim adipiscing adipiscing incididunt aliqua labore ad enim minim dolor dolor minim amet et tempor sed ipsum sed adipiscing enim dolore consectetur dolore magna dolore consectetur labore consectetur magna ut veniam ut amet aliqua elit lorem do aliqua minim ipsum enim ipsum consectetur incididunt labore amet minim dolore enim adipiscing quis magna labore adipiscing sit amet magna sit minim sed do lorem magna minim aliqua tempor eiusmod minim quis do dolore dolore ipsum eiusmod lorem lorem incididunt labore consectetur minim enim enim incididunt adipiscing aliqua lorem quis adipiscing quis minim amet et ad ipsum tempor incididunt ut consectetur et veniam consectetur consectetur dolore enim consectetur labore veniam sit enim magna ad adipiscing lorem aliqua sed lorem tempor ad dolor eiusmod ut tempor aliqua et ut enim sed dolor ad d \ No newline at end of file diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_b.txt b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_b.txt new file mode 100644 index 00000000..4679c421 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/ppmd/solid_lorem_b.txt @@ -0,0 +1 @@ +ipsum dolor dolor tempor consectetur quis minim do sed enim adipiscing enim ipsum aliqua minim consectetur ut ad incididunt quis dolore tempor magna labore dolore sed ipsum lorem tempor labore eiusmod incididunt ut dolore consectetur magna consectetur elit elit lorem consectetur eiusmod consectetur amet dolore dolore tempor dolore minim magna consectetur labore ut quis dolore tempor aliqua tempor tempor labore consectetur incididunt veniam quis labore ad dolore elit et sed et dolore dolore tempor minim labore labore tempor aliqua quis magna quis labore et minim elit eiusmod veniam consectetur enim sed et do do veniam dolore magna dolore dolore ad enim aliqua ut do quis adipiscing et dolore tempor minim enim dolor eiusmod quis lorem adipiscing quis sit ipsum aliqua ad ipsum sed aliqua elit minim sit dolore amet sed elit adipiscing ipsum ut veniam ipsum ipsum tempor tempor consectetur elit minim lorem dolor sit dolor lorem ipsum quis lorem tempor sed amet consectetur quis consectetur dolore veniam lorem incididunt aliqua ipsum elit amet ipsum lorem tempor enim ad quis quis sit do eiusmod et lorem do labore magna enim quis ipsum sed incididunt enim veniam amet et elit dolor minim minim eiusmod sit lorem labore amet dolore aliqua incididunt et dolore eiusmod amet eiusmod sed sed enim ut ad lorem veniam magna amet minim ipsum sed ipsum amet consectetur consectetur sit labore ad elit dolore veniam ipsum elit elit veniam labore dolor sed dolor aliqua elit enim enim veniam tempor sed minim ut sed dolore lorem amet ipsum incididunt ut consectetur sit dolore quis dolor elit sit sit lorem consectetur elit sit adipiscing lorem dolore minim labore labore do magna ad incididunt adipiscing minim adipiscing quis ut ut dolore lorem aliqua aliqua ipsum ut dolore aliqua consectetur sit minim et tempor lorem dolore sit enim tempor do veniam tempor do lorem minim ut sit sit do adipiscing minim lorem labore ipsum ut ad et labore adipiscing aliqua enim dolor lorem do lorem tempor do quis dolor elit et adipiscing sit aliqua tempor incididunt veniam labore amet tempor incididunt sit sed sit sit dolor enim eiusmod ad incididunt adipiscing veniam sit lorem enim minim et ipsum quis veniam et do tempor labore amet tempor sed et dolore et quis quis ut et minim do incididunt elit consectetur et enim sed magna ut veniam minim veniam dolor aliqua quis aliqua sit dolor tempor consectetur magna amet ut dolor dolor minim ad ipsum amet do incididunt elit veniam minim minim eiusmod labore consectetur dolore do sit amet magna ut sit eiusmod dolore elit veniam dolore sed consectetur consectetur labore veniam elit incididunt tempor aliqua quis amet labore labore quis lorem enim incididunt quis consectetur incididunt dolore ipsum et sed incididunt sed veniam quis ut veniam ad et tempor magna eiusmod veniam quis minim dolor quis elit magna enim adipiscing incididunt minim incididunt ad lorem eiusmod labore dolore veniam labore ad consectetur sit lorem incididunt adipiscing quis aliqua enim incididunt adipiscing sit incididunt magna adipiscing sed quis aliqua aliqua adipiscing et enim amet lorem enim minim ut et sed dolore aliqua consectetur labore veniam adipiscing dolor tempor lorem et magna minim minim dolor aliqua et minim eiusmod labore sed dolore labore lorem dolor enim tempor consectetur incididunt sed minim ad quis amet ipsum consectetur et incididunt labore minim do amet lorem do magna labore lorem tempor ipsum magna incididunt aliqua labore adipiscing minim do et ad amet et veniam magna veniam do dolor sed eiusmod do eiusmod ad do ad ad incididunt dolore dolor dolore ad adipiscing incididunt enim dolore amet dolore ad dolor do ipsum elit labore magna elit dolore sed ipsum sit sit minim incididunt tempor adipiscing eiusmod tempor dolor eiusmod labore tempor consectetur et labore do labore amet veniam labore ad adipiscing sed eiusmod consectetur sit elit et adipiscing minim tempor consectetur tempor amet amet elit sed magna ad incididunt incididunt quis eiusmod sed quis enim dolore aliqua veniam quis eiusmod quis incididunt veniam veniam ad veniam do magna enim ad minim dolor tempor do incididunt et consectetur sed tempor labore et dolor consectetur eiusmod incididunt amet lorem sit tempor consectetur tempor dolor quis ad ut lorem magna eiusmod elit enim incididunt magna do et ad amet tempor eiusmod adipiscing et sit amet adipiscing eiusmod sed amet ut tempor sed dolor eiusmod adipiscing elit veniam elit quis enim ipsum eiusmod tempor ad enim ipsum amet consectetur dolor ut labore sed amet eiusmod dolore aliqua sit eiusmod ad veniam enim incididunt elit ipsum incididunt et et enim eiusmod magna enim enim dolor aliqua dolore magna minim et incididunt veniam labore consectetur ut incididunt dolore labore ipsum sit labore aliqua amet sit minim dolore consectetur dolor incididunt do labore veniam lorem sed sit minim tempor elit consectetur lorem amet ut minim dolor eiusmod ad labore ipsum et elit dolor et amet magna lorem amet veniam dolore magna ipsum ipsum adipiscing magna lorem dolore eiusmod minim dolore elit amet tempor et lorem amet magna sit elit sit labore adipiscing ipsum enim adipiscing ad incididunt eiusmod enim ad incididunt veniam dolore dolore minim consectetur dolore sit amet ad adipiscing consectetur incididunt adipiscing do eiusmod ut amet ut amet incididunt eiusmod do sit magna sit et sed do dolore et sed elit ut veniam amet veniam magna minim sit lorem enim magna adipiscing adipiscing adipiscing incididunt aliqua ipsum ad amet ad lorem quis sed veniam quis et magna ipsum quis elit amet enim eiusmod ipsum veniam adipiscing sit amet ad veniam magna consectetur dolor minim labore ad do adipiscing consectetur eiusmod veniam sed dolore aliqua dolor ut ut minim quis ipsum labore do minim sit ad veniam quis sed lorem adipiscing ut eiusmod sed magna quis incididunt aliqua dolore quis adipiscing ut amet veniam consectetur labore labore tempor incididunt et enim sed enim adipiscing aliqua et labore adipiscing et aliqua eiusmod do dolor consectetur tempor enim ad et elit enim ad minim aliqua amet minim do adipiscing magna do sit lorem lorem adipiscing eiusmod ipsum eiusmod magna sed quis minim eiusmod labore dolor ut et veniam lorem do aliqua aliqua amet adipiscing amet consectetur enim incididunt quis dolor ad aliqua labore sed ad dolor et et elit amet aliqua do elit adipiscing enim veniam eiusmod aliqua enim veniam incididunt dolore ut elit ad adipiscing magna ipsum sed minim elit amet enim quis incididunt ut sit labore incididunt incididunt et incididunt do adipiscing elit elit ipsum magna dolore dolor enim magna minim lorem ipsum incididunt veniam ut incididunt elit dolore sed sit tempor dolore tempor dolore et aliqua dolor veniam labore quis veniam elit sed lorem lorem et ipsum amet ad amet adipiscing eiusmod elit magna ipsum enim amet ad do sit ad magna magna dolor minim minim amet ut veniam amet ipsum do dolore minim sed et ipsum magna tempor eiusmod minim sit enim tempor sit enim tempor tempor ad sed et do dolore enim amet lorem ipsum eiusmod ut ad lorem tempor minim magna veniam ipsum minim dolor veniam magna dolore enim ut ut ut elit consectetur consectetur enim ipsum lorem aliqua quis tempor minim consectetur do lorem ipsum elit aliqua elit incididunt dolor tempor sit enim dolor elit elit magna adipiscing sit lorem veniam incididunt dolor dolore sed aliqua ad elit ipsum dolore dolore dolore incididunt ut amet amet ut amet labore quis tempor ipsum aliqua consectetur dolore labore ut enim ad labore consectetur et enim amet tempor amet lorem sed veniam consectetur amet ad ut aliqua ad sed labore et labore adipiscing ut ut sed elit tempor ad ipsum incididunt enim lorem ut do lorem magna et aliqua sed minim sed elit labore veniam labore tempor dolore enim labore minim elit magna magna consectetur labore do tempor ut sit dolore minim elit quis ad minim incididunt sit ut enim labore enim dolore labore dolor quis incididunt labore enim veniam veniam quis tempor magna tempor consectetur amet elit minim ad consectetur ut labore et veniam quis consectetur ut sed eiusmod aliqua incididunt do ad veniam sed minim eiusmod minim lorem incididunt aliqua ipsum adipiscing labore sit sit lorem tempor eiusmod enim eiusmod quis incididunt consectetur quis eiusmod dolor dolore enim et incididunt enim elit labore sit enim lorem tempor lorem do et amet veniam veniam ipsum lorem eiusmod incididunt et ad enim lorem et ad aliqua adipiscing elit quis enim eiusmod consectetur eiusmod do incididunt aliqua enim quis et labore sed dolor dolore adipiscing aliqua tempor elit tempor tempor consectetur elit magna ad quis enim elit adipiscing aliqua labore elit incididunt sed aliqua adipiscing dolore consectetur lorem incididunt et quis tempor ad consectetur minim adipiscing quis veniam enim consectetur et enim lorem quis amet adipiscing veniam adipiscing lorem enim dolor labore ad adipiscing quis consectetur sed incididunt enim lorem lorem tempor sit do ipsum aliqua tempor et incididunt sit dolor labore consectetur amet labore ad dolor sed amet et magna dolor dolore veniam do do lorem magna magna adipiscing dolor ut amet consectetur aliqua do labore adipiscing ipsum veniam eiusmod labore ipsum amet elit enim tempor ad do veniam ad sit adipiscing amet elit lorem eiusmod sit sed sit tempor dolor dolore veniam enim amet tempor amet ut quis quis adipiscing do magna lorem lorem eiusmod ad amet quis dolor magna ipsum amet quis et ut minim tempor et minim do do dolor ad amet quis sit lorem dolor amet tempor veniam amet do aliqua minim magna amet dolor elit aliqua quis quis elit eiusmod dolor consectetur minim ut adipiscing ut ad minim ipsum eiusmod ut et ad magna tempor consectetur dolore sit minim ipsum amet minim incididunt amet ut quis elit ad sed enim magna veniam sit dolor dolore aliqua quis enim consectetur adipiscing minim enim minim veniam dolor magna eiusmod amet dolore elit elit minim labore minim incididunt labore sit eiusmod elit ipsum tempor sit incididunt lorem aliqua sit quis sed tempor magna elit eiusmod ut elit ipsum amet consectetur amet quis consectetur incididunt amet sit ad do ut labore lorem sit ut lorem veniam sit ipsum adipiscing ut lorem adipiscing incididunt eiusmod amet consectetur sed sed sed aliqua elit dolore do do aliqua ut et et incididunt do incididunt consectetur ad ut do aliqua labore dolore ut aliqua veniam eiusmod magna dolor aliqua lorem sed ut aliqua labore quis dolor dolore magna et dolore ad sed consectetur adipiscing tempor sit quis elit adipiscing ut amet dolore adipiscing dolore incididunt consectetur dolor do labore amet dolore dolor quis tempor minim consectetur elit magna ipsum ut magna ipsum incididunt magna do elit consectetur quis incididunt elit adipiscing aliqua elit dolore sed magna sed enim sed consectetur lorem ad enim incididunt dolore veniam ipsum ipsum et adipiscing magna eiusmod do quis ad ipsum labore eiusmod consectetur labore ipsum adipiscing tempor sed quis labore sed minim dolore sed ipsum quis eiusmod lorem ut ad elit consectetur incididunt veniam minim et amet ut veniam do dolor minim consectetur ipsum ut dolor magna aliqua amet lorem lorem tempor adipiscing minim ad aliqua magna et ut minim enim veniam aliqua eiusmod sit lorem dolor adipiscing lorem quis dolore dolore lorem amet lorem do sed sit lorem ad aliqua lorem tempor sed sit incididunt minim minim ad minim consectetur ut lorem elit adipiscing consectetur enim veniam ut magna ipsum aliqua sed sit elit aliqua elit ipsum adipiscing minim elit minim consectetur enim lorem consectetur sit aliqua adipiscing ad elit do eiusmod veniam dolor ad adipiscing ad amet aliqua elit sit tempor et veniam consectetur adipiscing adipiscing incididunt do lorem dolor elit aliqua do ad tempor do magna do minim ipsum do dolor et dolore minim amet enim aliqua tempor do enim ut enim ut ad sit magna consectetur ad enim elit enim ad amet dolor labore dolor enim amet et lorem amet incididunt adipiscing et tempor dolore ad amet ut adipiscing sit eiusmod eiusmod do ut amet elit aliqua sed et eiusmod lorem quis ipsum lorem sit adipiscing do ipsum labore dolore elit adipiscing elit dolor ipsum lorem sit incididunt sit ut aliqua aliqua ut ad dolore lorem quis lorem consectetur sit adipiscing elit dolor veniam sed dolore magna sed sit consectetur enim do adipiscing quis enim dolor consectetur minim lorem lorem minim sit ad labore labore lorem ad aliqua lorem elit veniam eiusmod minim dolor elit veniam sed sit consectetur adipiscing dolor ut sed et sit sed enim enim amet eiusmod incididunt elit aliqua elit adipiscing et labore sit et incididunt ad eiusmod veniam ipsum labore ipsum ut labore quis minim veniam veniam elit magna ut magna ad ipsum minim dolore incididunt sed sit labore do do quis ut elit minim consectetur veniam elit sit lorem sed magna veniam amet incididunt ut aliqua quis ipsum minim minim amet veniam ad ipsum ipsum adipiscing ipsum veniam sed magna consectetur consectetur et tempor minim dolor veniam ut magna enim consectetur sit ut do elit lorem ad adipiscing sed ipsum elit adipiscing minim et dolore quis et labore lorem ipsum do ut dolore enim ad dolore adipiscing ut sit labore labore dolore minim consectetur magna consectetur do enim amet veniam magna sit dolore consectetur lorem eiusmod quis ipsum enim quis enim sed ad incididunt eiusmod enim enim aliqua ad amet dolor aliqua elit amet aliqua eiusmod veniam eiusmod ipsum adipiscing enim ipsum adipiscing tempor ipsum lorem minim et incididunt enim amet veniam ipsum enim ad ut dolor eiusmod consectetur dolore dolore elit sit sed sed eiusmod et quis minim sed labore quis adipiscing eiusmod magna lorem enim lorem quis enim quis aliqua sit ut ut ut enim labore aliqua sed ut lorem sed lorem lorem consectetur enim ad tempor adipiscing adipiscing dolor magna tempor do eiusmod ipsum sit eiusmod minim quis do consectetur minim amet sed sed et dolore magna magna sed do aliqua eiusmod dolore aliqua magna labore ut incididunt dolor incididunt dolor dolore amet sit eiusmod incididunt et minim aliqua dolor quis ut incididunt labore enim sed et lorem magna et magna tempor ad ut quis adipiscing enim dolor lorem consectetur minim sed veniam lorem do ipsum minim ut do incididunt veniam elit minim ut dolore sed enim incididunt incididunt sed lorem sed consectetur do lorem adipiscing lorem adipiscing consectetur eiusmod sed aliqua adipiscing minim veniam eiusmod incididunt aliqua amet lorem ipsum sit elit ut minim sit incididunt do amet sed adipiscing incididunt ipsum minim ut ut eiusmod dolor adipiscing labore amet veniam magna ad labore incididunt et veniam sed enim elit ut labore elit ad et ad sed adipiscing minim et incididunt lorem sed dolore sed do eiusmod adipiscing aliqua ad ut ipsum dolor sit consectetur consectetur eiusmod do magna elit ad adipiscing ad dolor sit dolore sed dolore labore eiusmod dolore amet adipiscing elit sit do dolore et et labore ad veniam dolore eiusmod do amet labore labore lorem ut dolore incididunt consectetur elit enim eiusmod dolore ut do labore amet sed tempor ad ut minim minim minim ipsum consectetur tempor veniam minim dolore aliqua adipiscing aliqua aliqua ut eiusmod magna adipiscing sed minim amet minim do aliqua enim elit ad aliqua dolor lorem minim magna veniam quis et lorem magna adipiscing lorem dolor magna ad eiusmod consectetur incididunt consectetur enim aliqua do ut eiusmod amet aliqua ad lorem minim dolore aliqua labore lorem incididunt quis consectetur consectetur elit minim sit labore adipiscing eiusmod elit dolor do ipsum sit sed ut sit veniam sit adipiscing veniam incididunt adipiscing ut aliqua veniam elit et ad ad adipiscing dolor amet magna dolor tempor quis adipiscing adipiscing tempor veniam et tempor sed consectetur labore ad dolore sed magna aliqua dolor lorem dolore magna amet eiusmod magna elit elit elit elit ut veniam ut do amet minim do minim lorem ut dolore minim ad labore amet do eiusmod dolore aliqua sit amet dolore veniam minim incididunt enim tempor ipsum veniam ut et incididunt quis dolor dolor et labore et veniam ipsum veniam minim consectetur elit quis tempor incididunt eiusmod minim enim eiusmod enim sed aliqua minim quis veniam magna labore aliqua ut ut veniam quis amet dolore enim amet adipiscing quis adipiscing ad adipiscing sit ipsum ipsum ut dolor incididunt magna labore consectetur eiusmod incididunt amet lorem lorem incididunt ut enim amet consectetur magna do amet sit sit consectetur adipiscing adipiscing veniam adipiscing sit eiusmod ipsum elit eiusmod ipsum dolore quis minim magna amet eiusmod ipsum dolore veniam do elit amet magna elit quis elit veniam labore ipsum magna dolore incididunt do veniam et dolore ipsum consectetur aliqua elit dolor tempor lorem et enim lorem ut sit elit incididunt eiusmod enim veniam et sit elit labore dolor enim ad dolore magna elit amet lorem et labore eiusmod enim labore et labore do amet enim enim do aliqua et do dolor sit lorem ut quis sit eiusmod ipsum do lorem adipiscing aliqua amet tempor ad ad tempor ad amet dolor sed enim sit dolor amet aliqua elit lorem do aliqua consectetur veniam ipsum incididunt tempor dolor do et ad labore consectetur aliqua ipsum elit incididunt quis sed veniam eiusmod consectetur aliqua aliqua labore eiusmod dolor do do adipiscing dolor dolor eiusmod dolore et magna lorem minim amet ad tempor tempor do et dolore lorem amet minim aliqua tempor veniam magna aliqua consectetur sed sed sed amet minim lorem ut amet incididunt incididunt quis sit dolore ad tempor ut eiusmod sed eiusmod et ipsum do incididunt do dolor dolor ad quis et amet consectetur minim sit ut magna sed dolore incididunt lorem ad labore quis ipsum amet adipiscing lorem amet labore quis et lorem elit quis magna quis quis quis ad quis elit ad dolore ad dolor veniam do aliqua amet adipiscing magna labore adipiscing do et quis dolor amet et ipsum elit sed sed enim lorem ipsum aliqua eiusmod dolore sed incididunt labore dolore veniam ad lorem tempor enim minim tempor elit sed lorem ipsum tempor incididunt lorem enim dolore elit labore sit ad labore lorem veniam magna labore eiusmod consectetur labore eiusmod enim do veniam enim eiusmod sed amet veniam magna magna incididunt do ipsum sed ad eiusmod dolore veniam magna ut magna do minim consectetur dolor minim amet do aliqua incididunt tempor magna et dolor enim sed minim labore do sit minim magna aliqua veniam sed do sit enim magna quis enim sit enim ut quis ad ad ipsum lorem aliqua ut ad adipiscing eiusmod adipiscing labore magna do veniam labore eiusmod tempor incididunt eiusmod lorem magna dolore ad minim et elit et quis adipiscing ad magna labore minim enim enim quis enim adipiscing sit incididunt magna amet incididunt aliqua incididunt consectetur aliqua minim incididunt eiusmod lorem incididunt ut ad do ipsum do sit elit magna quis sed do lorem quis ipsum eiusmod lorem tempor do veniam veniam incididunt veniam ut elit amet aliqua ipsum ad dolore et aliqua labore consectetur adipiscing ut et magna magna ipsum sit dolor ut do ut eiusmod sed magna adipiscing ad magna quis ut dolor ad sit minim adipiscing lorem veniam labore dolor ut enim consectetur minim enim aliqua minim dolor veniam tempor ut magna et enim aliqua incididunt sed lorem quis adipiscing lorem et magna ipsum amet aliqua dolore incididunt et ad ut tempor consectetur quis adipiscing do incididunt ut ipsum ut ut adipiscing incididunt dolore tempor magna amet et magna dolore adipiscing veniam eiusmod enim dolor tempor aliqua ipsum sit amet minim aliqua consectetur labore sed labore sit sit aliqua eiusmod lorem et aliqua do quis sed dolore adipiscing adipiscing do labore consectetur adipiscing quis incididunt quis sed magna veniam aliqua veniam enim ipsum eiusmod lorem tempor do ut do ad labore minim tempor veniam sed adipiscing ad aliqua incididunt consectetur do labore ad tempor sit labore incididunt amet quis tempor quis ad magna et lorem adipiscing quis do aliqua ipsum ad lorem minim dolor enim amet dolor lorem lorem adipiscing quis consectetur dolore lorem tempor magna tempor dolor dolor et minim veniam minim elit ut quis sed elit enim ut ipsum consectetur veniam tempor elit do ut incididunt ut adipiscing consectetur incididunt et sed consectetur incididunt quis incididunt elit adipiscing sit magna ut et sit ipsum sit elit et consectetur ad elit amet tempor ad ipsum tempor lorem magna do elit adipiscing do consectetur lorem sed et enim dolore aliqua et minim consectetur ad ut quis consectetur dolor ipsum adipiscing incididunt labore dolor eiusmod amet dolor enim ad do incididunt sed amet magna dolore sit magna incididunt consectetur tempor amet dolore eiusmod incididunt aliqua dolor consectetur sit veniam sed labore aliqua elit elit incididunt sed consectetur adipiscing incididunt ad dolore ad eiusmod dolor do veniam et ad sed lorem ut do do sed minim lorem minim veniam sed sed aliqua et ipsum enim minim minim incididunt adipiscing veniam dolor enim ut eiusmod sit sed dolore tempor dolore sit eiusmod do elit amet dolor aliqua quis magna dolor ut amet consectetur amet ut et aliqua tempor magna dolor minim ut eiusmod dolor enim dolor labore consectetur ut elit veniam magna eiusmod ut ad dolore et ad ad elit tempor minim et enim lorem sed dolore adipiscing ipsum eiusmod veniam aliqua do magna elit tempor ipsum labore do dolor tempor ut ad veniam enim consectetur amet sit dolore adipiscing elit dolore veniam aliqua elit labore do minim magna quis magna tempor adipiscing aliqua ipsum consectetur quis eiusmod magna tempor eiusmod ad ut tempor enim et consectetur aliqua veniam adipiscing do ut tempor adipiscing quis aliqua sed enim adipiscing dolore labore magna labore minim elit et ad enim eiusmod enim do eiusmod magna aliqua tempor lorem labore minim ut eiusmod lorem sed adipiscing incididunt lorem dolore adipiscing ipsum et veniam consectetur tempor labore incididunt aliqua et quis magna lorem adipiscing elit eiusmod sit adipiscing consectetur elit veniam elit do veniam sit magna amet enim enim ipsum amet lorem quis labore aliqua ipsum ad aliqua elit tempor tempor enim aliqua ipsum minim sed enim adipiscing ad aliqua magna et elit consectetur eiusmod incididunt magna elit quis minim quis amet minim consectetur ad do elit labore sed sed elit ut tempor adipiscing ut quis dolor dolor sit consectetur tempor incididunt ut labore consectetur lorem labore amet et ut dolor ut magna consectetur do elit veniam veniam sit dolor dolore elit aliqua et sed elit labore aliqua tempor eiusmod ut ut adipiscing consectetur sit labore lorem eiusmod do incididunt dolor et labore amet amet do adipiscing labore adipiscing ut eiusmod adipiscing elit veniam adipiscing dolore sed aliqua ut et dolore veniam et minim elit amet ipsum elit ad sed ipsum aliqua incididunt et tempor quis eiusmod elit eiusmod quis labore enim aliqua minim magna dolore eiusmod eiusmod consectetur labore quis ad incididunt adipiscing dolor labore do eiusmod consectetur et sit dolore enim lorem sit tempor eiusmod ut eiusmod sed consectetur magna sit consectetur eiusmod enim elit do quis do magna incididunt quis enim aliqua eiusmod labore elit ad sit dolore dolore tempor eiusmod aliqua sit quis dolor adipiscing eiusmod magna sed quis dolor ad labore sed do dolor aliqua minim ad sit consectetur lorem enim sit ad labore elit labore quis ad minim sit tempor et enim dolore veniam sed dolor sed amet minim eiusmod ut incididunt adipiscing et do aliqua ut sit ut incididunt dolor lorem minim et do adipiscing ipsum lorem do consectetur magna dolore eiusmod amet et tempor adipiscing magna sed lorem veniam aliqua minim magna dolore tempor eiusmod minim ut incididunt ut do ut lorem elit dolor do minim enim lorem do ad et incididunt et ad et sit tempor tempor aliqua veniam dolore elit minim tempor sit amet ad incididunt enim tempor ad et ipsum magna do dolor consectetur do dolore quis consectetur ad amet ipsum consectetur minim minim dolor adipiscing lorem sed magna ad tempor ipsum do dolor sit sed ut eiusmod adipiscing ut sit consectetur sit ipsum et amet et aliqua do incididunt et veniam sit elit incididunt tempor ipsum quis veniam tempor do minim labore veniam lorem lorem et sit quis consectetur et labore magna ut lorem elit quis ipsum dolor ad veniam et ad quis lorem sed enim et sed elit ut sit elit minim quis elit quis magna enim enim sit adipiscing dolor ipsum dolore aliqua enim minim do sit magna sed quis enim magna aliqua lorem lorem sed enim dolor dolore elit ad incididunt ad sed adipiscing amet et ut ipsum minim quis ut enim dolor elit sed sit do veniam do amet consectetur consectetur ipsum sit amet labore enim et amet aliqua quis quis lorem adipiscing aliqua enim aliqua adipiscing veniam ut magna adipiscing amet elit eiusmod veniam eiusmod tempor do dolor incididunt quis sit minim amet sed sit eiusmod incididunt et labore do dolor tempor tempor dolor et sit tempor enim magna et ad incididunt enim ad incididunt dolor aliqua enim incididunt adipiscing minim dolor sed lorem adipiscing quis et dolore aliqua elit amet eiusmod tempor magna magna tempor aliqua lorem eiusmod consectetur amet dolor eiusmod quis adipiscing veniam lorem quis quis ut enim veniam dolor dolore sed aliqua ut ut do veniam enim tempor magna eiusmod do et ut ut labore dolor sit eiusmod dolor ad dolore ipsum magna ad ipsum labore consectetur amet tempor adipiscing dolor dolor lorem sit adipiscing amet et ipsum dolore amet dolore dolore magna magna ut labore dolore sit incididunt magna adipiscing labore aliqua enim minim et dolor tempor magna ipsum elit labore ut dolor lorem magna elit labore aliqua dolor tempor magna labore minim sed quis do do ad dolor amet ipsum consectetur dolor ut adipiscing lorem sed labore ad sed lorem veniam ad magna consectetur consectetur sit ut sit lorem lorem labore do sit eiusmod sit sed labore tempor dolore consectetur sed amet minim do lorem elit veniam do ut lorem veniam et sit dolor elit ipsum ut ut labore sed elit dolor sit do minim magna et do quis incididunt quis labore et adipiscing dolor quis dolor consectetur incididunt tempor veniam lorem adipiscing dolore ut quis aliqua enim labore et lorem adipiscing dolor magna veniam enim amet eiusmod aliqua tempor labore consectetur incididunt et et tempor tempor aliqua ad eiusmod consectetur et lorem veniam do minim dolore lorem minim ad veniam sed adipiscing ipsum ad lorem ad do incididunt quis sit aliqua elit elit do ipsum dolor incididunt amet amet magna sit do magna sed minim quis ipsum aliqua minim elit labore lorem quis et veniam dolore labore consectetur minim magna amet lorem incididunt consectetur do eiusmod amet et tempor ad sed magna sed sit enim consectetur veniam quis eiusmod dolore tempor ad ad incididunt dolor quis ad tempor sed lorem elit dolor elit lorem ad adipiscing sit sed incididunt sed dolor adipiscing sit amet amet elit elit do lorem enim aliqua dolore dolore veniam minim enim ut eiusmod magna dolore amet do sed et incididunt ut labore aliqua incididunt sit labore tempor ut veniam dolor et magna ipsum consectetur aliqua elit ad dolore enim dolore sed magna ipsum amet dolore sed ipsum minim dolor labore do ut labore sed magna dolor do amet ut incididunt et quis minim elit magna consectetur veniam enim aliqua veniam lorem elit ut ut veniam sed do lorem do veniam dolore enim et elit amet amet quis adipiscing aliqua do veniam minim sed ad magna eiusmod tempor dolore eiusmod dolor labore eiusmod incididunt aliqua sed labore dolor dolor enim amet elit minim dolor et amet consectetur tempor adipiscing eiusmod quis enim ipsum eiusmod sit adipiscing amet et enim dolore incididunt dolore ipsum incididunt labore magna do veniam tempor elit veniam do ut lorem veniam ipsum incididunt sit quis veniam quis quis dolore ipsum sit minim ad veniam lorem consectetur quis ad tempor ut amet consectetur enim adipiscing consectetur lorem amet dolore dolore tempor labore dolore tempor amet magna dolore tempor do amet tempor veniam lorem aliqua veniam sit amet dolor veniam elit aliqua sed enim eiusmod incididunt labore ipsum dolor enim labore tempor et dolor aliqua et et sed enim ut magna minim consectetur consectetur amet ad quis ad consectetur ad sed veniam dolor ad sed eiusmod eiusmod adipiscing labore sed sed labore adipiscing quis quis incididunt sed quis ipsum aliqua consectetur sit et aliqua veniam quis dolor incididunt eiusmod quis et dolor enim adipiscing do magna et dolore quis dolor ipsum sed adipiscing enim aliqua sit ipsum lorem ipsum minim et incididunt ad labore aliqua dolor do ut eiusmod ipsum incididunt ad sed labore veniam magna elit sit ad sit ipsum quis ad et veniam elit quis aliqua enim sed incididunt enim tempor labore quis do sed incididunt enim dolor labore incididunt adipiscing ad labore magna ad tempor lorem ut elit quis magna dolor dolor labore aliqua tempor ipsum sit veniam adipiscing sit lorem ad minim magna et lorem et consectetur ut veniam sit sed enim sed magna veniam adipiscing labore sed enim tempor elit veniam ut eiusmod tempor minim veniam sit enim adipiscing minim lorem et elit quis elit sed incididunt lorem ut labore ipsum ut elit aliqua et ad eiusmod enim ipsum magna minim dolore adipiscing sit ipsum ipsum et adipiscing sit eiusmod ad tempor consectetur ut do elit ipsum adipiscing labore lorem aliqua ad labore ipsum labore veniam veniam ad magna ut tempor labore sed veniam dolor aliqua do dolor adipiscing tempor elit eiusmod sit lorem adipiscing dolore ut elit sit minim quis et do lorem quis magna veniam quis aliqua tempor eiusmod minim consectetur ipsum consectetur magna quis ad tempor consectetur dolor quis lorem consectetur et eiusmod do veniam dolor do sit do dolor lorem quis quis incididunt adipiscing aliqua labore consectetur amet elit labore quis dolore sit tempor dolor veniam sit adipiscing aliqua do labore dolore do quis dolor veniam et enim ad dolore ad et ad ut amet do ipsum lorem consectetur magna enim lorem adipiscing incididunt labore tempor amet incididunt magna do sit amet eiusmod eiusmod ipsum ipsum consectetur do do quis elit minim adipiscing ut ipsum do incididunt veniam dolor amet elit sed veniam sed ut veniam amet lorem minim tempor sit lorem aliqua sed adipiscing quis incididunt minim minim enim minim et adipiscing ad quis sed veniam elit incididunt eiusmod ipsum aliqua labore et veniam magna labore eiusmod minim et veniam quis incididunt do sit incididunt lorem dolor ipsum ipsum dolor veniam tempor tempor lorem aliqua et lorem dolor do et sit incididunt et lorem veniam ipsum dolor tempor lorem elit minim consectetur tempor dolor consectetur sit eiusmod magna eiusmod dolor incididunt minim amet do amet tempor veniam ipsum magna minim quis tempor aliqua minim magna labore ipsum quis ipsum quis amet aliqua eiusmod amet minim ad amet magna veniam ipsum eiusmod minim dolore quis ut minim sed adipiscing ad dolore minim et elit do dolor minim et labore veniam sed minim incididunt amet magna labore consectetur et sed tempor minim adipiscing veniam eiusmod tempor et veniam quis ut ad consectetur elit ad ipsum do adipiscing sit minim ut labore labore lorem consectetur quis dolor dolor lorem et do consectetur tempor adipiscing dolore do do sed do eiusmod quis sit lorem labore magna eiusmod et incididunt ad sit do et adipiscing minim sit lorem ut elit do et minim dolor ut ipsum sit dolore veniam dolor quis eiusmod tempor consectetur quis enim tempor sed tempor do adipiscing amet lorem elit ipsum sit magna ut et veniam tempor enim sed elit labore aliqua sit dolor veniam minim ipsum do veniam consectetur veniam labore ipsum incididunt veniam et sit tempor eiusmod lorem ut labore quis ut adipiscing incididunt dolor incididunt amet eiusmod elit enim ut minim consectetur quis aliqua et amet et aliqua ut et incididunt labore labore quis ad do et lorem do ad amet amet consectetur amet ad eiusmod do et elit lorem sit do sed et lorem incididunt veniam ipsum do enim veniam incididunt minim minim magna elit sed dolore enim amet incididunt do enim ut sit quis minim magna quis quis dolore incididunt veniam aliqua sit tempor sit dolore veniam dolore dolore sit magna quis ut sed dolor dolor quis ut sit eiusmod incididunt eiusmod et minim et lorem enim lorem dolor et elit et ut adipiscing magna ad aliqua magna ut enim sit incididunt eiusmod tempor minim eiusmod enim et aliqua ad elit quis veniam sed ipsum amet magna et et magna tempor elit quis dolor sed lorem sit labore adipiscing labore consectetur elit ut lorem ipsum sed eiusmod do lorem tempor ut sit ad incididunt dolore adipiscing sed veniam dolore lorem magna tempor adipiscing sit amet dolor amet elit eiusmod incididunt veniam adipiscing amet veniam lorem dolore sed sed tempor dolore incididunt incididunt et aliqua consectetur amet sit do tempor adipiscing elit minim sed elit et tempor sit dolore sit enim ad dolore ad tempor adipiscing do minim sed veniam sit quis adipiscing quis quis amet quis sed sit adipiscing enim labore dolore minim magna magna aliqua lorem amet dolor eiusmod dolor et tempor dolor amet tempor amet ad adipiscing minim et quis magna adipiscing labore veniam enim ut ad do magna eiusmod amet ut ipsum elit ad dolor ipsum sed enim quis do ipsum minim do ipsum et et et ad sed do sed sed quis ad aliqua ut incididunt enim labore quis enim adipiscing enim tempor minim ipsum amet ipsum et ut aliqua amet sed dolore consectetur elit incididunt quis eiusmod amet dolor veniam enim sit elit et consectetur enim eiusmod elit quis magna sit veniam sed elit aliqua minim adipiscing magna ipsum et ut ut incididunt et amet dolor sit minim ad sed sit sit ut incididunt amet incididunt ipsum tempor ad quis labore sed eiusmod dolor adipiscing elit enim dolor ipsum elit amet minim incididunt tempor ad consectetur dolor elit ut quis minim enim amet dolore elit veniam ad quis lorem ipsum consectetur minim veniam do incididunt et lorem consectetur do incididunt do do sed amet ut do amet consectetur tempor magna adipiscing tempor incididunt ut dolore enim aliqua enim magna lorem enim et elit ipsum dolore ad veniam elit eiusmod quis ipsum elit enim incididunt ut et adipiscing do lorem labore magna ut dolor sed aliqua sit ut elit eiusmod ipsum consectetur do quis incididunt amet incididunt incididunt ipsum veniam ad incididunt dolor sit consectetur minim eiusmod ut incididunt magna quis lorem sed do veniam tempor consectetur sed tempor enim do amet sed minim veniam lorem eiusmod enim tempor incididunt consectetur sed enim incididunt tempor dolore sit aliqua do quis quis do ut ad quis sed adipiscing quis sit enim magna sed eiusmod quis adipiscing lorem sed minim ipsum ipsum lorem veniam consectetur et tempor consectetur amet amet enim magna enim adipiscing dolor dolore incididunt magna incididunt enim lorem et ipsum aliqua consectetur labore adipiscing incididunt quis lorem ad ad elit ipsum incididunt lorem sed eiusmod ad tempor incididunt ut amet labore amet ipsum adipiscing veniam incididunt amet dolore adipiscing lorem dolore quis enim sit sed ut enim lorem labore amet consectetur dolor eiusmod sed ipsum aliqua tempor magna magna elit sit veniam quis do minim ipsum adipiscing sit aliqua ipsum enim do ad enim eiusmod ad magna enim ut magna quis dolor amet adipiscing veniam labore lorem ut enim sed sed eiusmod enim elit dolore ut consectetur quis labore elit elit dolor elit et tempor do veniam labore ut elit ipsum lorem adipiscing amet enim ad quis elit ad do minim sit enim et dolore ut do eiusmod aliqua eiusmod amet consectetur et eiusmod tempor quis consectetur dolor ut magna do dolore sed minim veniam ut et veniam elit magna do incididunt lorem sit dolore aliqua dolore et dolor minim sed ipsum consectetur aliqua minim magna do sit veniam adipiscing adipiscing veniam adipiscing et et do tempor veniam elit adipiscing aliqua magna dolor elit do dolor veniam elit dolor sed sed enim amet ut dolore et dolor veniam sit et tempor magna et adipiscing consectetur labore tempor labore veniam incididunt minim quis do veniam labore quis enim quis labore aliqua ad consectetur quis labore quis quis enim dolore enim minim magna veniam labore sed et labore veniam ut minim et lorem labore ipsum lorem do ad ipsum quis eiusmod enim et amet magna ad adipiscing elit eiusmod amet enim sed amet labore ipsum tempor dolore dolore dolore dolor ad elit dolore aliqua aliqua quis sit et ut labore tempor dolore dolore tempor dolor adipiscing do amet sit tempor dolore labore dolore do aliqua ut adipiscing aliqua tempor enim magna labore elit et sit et dolor tempor tempor adipiscing quis sed magna tempor ipsum dolor sed amet quis do sed quis elit elit incididunt quis veniam sit ad labore consectetur et et ipsum ipsum lorem ad sed quis quis adipiscing adipiscing lorem do minim elit tempor lorem elit quis et adipiscing ipsum do ipsum ipsum eiusmod ut aliqua tempor enim aliqua amet magna quis eiusmod incididunt tempor dolor enim sit eiusmod ad sed do consectetur consectetur dolore ut incididunt eiusmod dolor enim enim magna do veniam amet incididunt sit dolore quis incididunt lorem veniam aliqua et consectetur ut et magna ipsum ad veniam et do sed et et lorem ad minim ad lorem enim lorem ut magna amet incididunt sit quis dolore adipiscing minim lorem sit enim ipsum dolore ut magna lorem do sed quis eiusmod magna amet ut magna dolor amet quis tempor ipsum veniam eiusmod magna adipiscing sit quis magna adipiscing minim sit sit labore quis enim quis do do sed elit dolor eiusmod enim ad consectetur minim elit veniam minim et incididunt sed labore amet consectetur sed do eiusmod tempor sed dolore do ut enim tempor aliqua tempor eiusmod do consectetur dolor veniam adipiscing ad tempor dolor sit minim labore aliqua dolor ipsum ad incididunt tempor labore et quis elit enim labore ipsum quis eiusmod sit consectetur do do sed lorem sed adipiscing amet dolor labore dolore do sed incididunt tempor aliqua sed ad dolor ad eiusmod sit ut amet minim sed eiusmod aliqua sed dolor amet et tempor lorem incididunt ipsum et enim et ut ad ut dolor ut quis magna do incididunt consectetur tempor do elit amet quis minim aliqua magna ad veniam ut enim et dolore ad sed sed sit elit sed lorem sed ad ut et elit magna et aliqua amet eiusmod labore sit incididunt ad aliqua enim lorem sed ipsum sit veniam magna sed ipsum et quis dolore sit incididunt dolore ut enim ad ipsum veniam dolor labore et labore ipsum incididunt do et adipiscing tempor et labore quis elit minim do dolor tempor ipsum dolor quis enim ad amet do adipiscing dolore ipsum ut dolore dolor dolor do dolore consectetur eiusmod dolor et veniam dolore et lorem ad sit enim sit adipiscing quis elit dolore magna eiusmod veniam ipsum consectetur elit minim ipsum do lorem sit enim tempor ut ad amet lorem incididunt consectetur sed ipsum adipiscing enim incididunt veniam dolore enim labore consectetur consectetur ad do dolore incididunt sed aliqua ut tempor lorem enim veniam ipsum amet ipsum veniam enim enim sed ad tempor amet amet amet magna ipsum ad eiusmod amet magna amet et ad et et adipiscing incididunt amet veniam adipiscing lorem tempor consectetur do sit ad adipiscing do minim et labore incididunt adipiscing do quis do lorem amet do eiusmod sit ipsum quis lorem quis lorem do lorem incididunt eiusmod ipsum aliqua dolor dolore adipiscing elit lorem minim ut sit tempor amet lorem labore elit veniam quis do incididunt et ipsum amet ad ut quis ad et ad minim do incididunt incididunt tempor minim veniam dolor et ipsum eiusmod ipsum adipiscing veniam consectetur eiusmod sit tempor et do amet ipsum veniam dolor minim veniam dolor sed adipiscing sed lorem labore ad elit sit magna adipiscing tempor enim minim lorem sed veniam veniam sit magna ipsum consectetur incididunt amet amet veniam veniam magna sit elit tempor sit adipiscing labore minim elit aliqua labore aliqua do enim incididunt incididunt do incididunt enim ut tempor ad elit sit ut magna elit minim minim elit incididunt eiusmod aliqua quis enim amet magna sit incididunt magna ad eiusmod lorem amet dolore aliqua aliqua tempor et magna aliqua amet ipsum dolor eiusmod adipiscing sed veniam et quis elit eiusmod lorem tempor tempor labore do incididunt elit lorem dolor amet elit magna elit dolor adipiscing magna tempor magna labore tempor ipsum amet dolor sit incididunt ad adipiscing incididunt ipsum lorem ad ut incididunt sit adipiscing et magna minim ad eiusmod sit lorem sit labore minim lorem minim ad sed et ad adipiscing quis quis enim veniam dolore eiusmod consectetur incididunt consectetur dolor sit dolor lorem sit ut incididunt labore tempor dolore dolor aliqua consectetur et ipsum sed magna quis ut amet ad do dolore quis ut minim do ipsum quis ad ipsum ipsum minim eiusmod ipsum eiusmod ut incididunt tempor minim do adipiscing sit sit consectetur dolore magna dolor aliqua sit minim sed elit ut do lorem consectetur incididunt magna amet lorem ad enim tempor sit aliqua lorem amet amet do tempor dolore quis dolore adipiscing veniam quis incididunt sit lorem ipsum labore tempor amet enim do eiusmod dolore do magna enim ad veniam adipiscing magna minim do dolore consectetur do magna dolore dolor adipiscing eiusmod ut enim amet aliqua adipiscing eiusmod ipsum dolor lorem elit quis incididunt aliqua do consectetur sed adipiscing sed quis ipsum ipsum incididunt dolor dolore dolor elit tempor veniam minim incididunt minim ipsum tempor tempor eiusmod eiusmod ipsum do aliqua consectetur aliqua aliqua ad ipsum sed ad tempor magna ipsum minim ad aliqua eiusmod ipsum et amet enim adipiscing minim incididunt sed ad elit enim amet dolore veniam do dolor adipiscing do magna dolore labore elit tempor veniam eiusmod magna veniam consectetur dolor lorem quis amet ipsum ad enim quis labore ut ipsum veniam magna lorem enim enim tempor tempor dolore ad dolor dolor lorem dolore magna ut enim ipsum et lorem labore elit do magna quis ipsum minim sit sed amet aliqua sed consectetur consectetur et ad amet adipiscing elit consectetur incididunt ad enim magna adipiscing minim minim ut dolor adipiscing veniam incididunt enim et do amet ipsum ipsum ad ipsum ipsum adipiscing lorem ut magna incididunt ut et magna dolor sit eiusmod ipsum labore magna sed et adipiscing veniam do eiusmod veniam aliqua dolore incididunt labore adipiscing consectetur eiusmod minim eiusmod veniam minim et veniam veniam sit enim sit ipsum eiusmod dolore sit ut ipsum ipsum consectetur incididunt et enim ipsum consectetur lorem elit do adipiscing consectetur labore ut incididunt et labore do ipsum labore ipsum consectetur do labore amet ad minim magna ipsum veniam magna consectetur et sed minim tempor dolor quis et quis veniam ut labore labore dolore aliqua ut sed sit labore quis dolor labore incididunt eiusmod incididunt eiusmod quis aliqua do amet tempor enim elit ad tempor ad ad sed labore ut sed magna enim elit dolor adipiscing dolore sed ut aliqua tempor do lorem dolore et sit do amet lorem eiusmod ad minim quis dolore adipiscing minim amet incididunt ad sit quis enim ad minim consectetur ut magna lorem quis do magna eiusmod consectetur ad tempor ad labore ut dolor veniam tempor enim do veniam dolore sed eiusmod labore dolore veniam minim consectetur sed consectetur labore consectetur magna ut minim enim elit quis sit sit magna labore et veniam ad consectetur adipiscing aliqua sed do amet consectetur adipiscing sed sed consectetur minim adipiscing ut dolore elit minim ut amet tempor aliqua eiusmod tempor ad ipsum ut lorem aliqua elit adipiscing aliqua incididunt do lorem do aliqua labore dolore enim adipiscing lorem eiusmod tempor dolore do consectetur veniam eiusmod consectetur veniam ad dolore labore ipsum minim adipiscing tempor et consectetur sed enim minim aliqua adipiscing dolore sit dolore do adipiscing veniam incididunt dolor incididunt sit ad consectetur magna quis incididunt magna labore incididunt do aliqua adipiscing incididunt dolor ad adipiscing consectetur ut do sed ipsum labore ad eiusmod magna eiusmod enim sit adipiscing adipiscing adipiscing quis ut ipsum dolor sit veniam do labore do dolor enim sit eiusmod labore magna dolor adipiscing lorem ad sit do veniam ut minim et incididunt do labore quis et aliqua adipiscing incididunt lorem consectetur labore enim elit ipsum sit ut eiusmod amet dolore dolor magna veniam incididunt et ut aliqua ut eiusmod magna lorem lorem ad dolore ad incididunt adipiscing minim incididunt consectetur elit magna labore ipsum aliqua ipsum labore consectetur tempor lorem et ut labore consectetur et amet incididunt elit veniam amet quis elit enim aliqua ad adipiscing do veniam aliqua incididunt enim ad ut labore sit labore magna quis consectetur ut quis lorem ut dolor ad ad dolor do aliqua minim ut quis consectetur sed veniam minim ipsum dolore eiusmod magna adipiscing aliqua et sed do veniam minim dolor dolore lorem consectetur elit ad amet elit sed magna sit tempor elit sit enim do quis enim lorem do et et dolor magna do elit et veniam dolor minim do labore lorem consectetur lorem tempor ad sed ut incididunt do veniam ad lorem magna aliqua incididunt sed dolore quis dolore minim labore quis incididunt dolor consectetur do minim lorem consectetur dolore tempor ut et aliqua lorem ipsum aliqua do ad do veniam ipsum amet ad dolore labore labore dolore sit do dolor tempor amet aliqua aliqua enim ipsum amet lorem sed magna adipiscing et quis sit ipsum tempor quis ipsum eiusmod sit ad adipiscing minim tempor do amet dolor veniam ad lorem veniam ut consectetur lorem tempor eiusmod veniam quis ipsum incididunt adipiscing adipiscing et aliqua tempor ipsum dolor et ad ipsum labore adipiscing dolor adipiscing sit ad lorem quis minim dolor do consectetur quis ut ut enim minim dolore elit elit veniam et eiusmod minim adipiscing ad et sit quis quis minim do do sed consectetur adipiscing veniam minim do adipiscing ipsum tempor ut sed veniam magna adipiscing lorem dolor dolore eiusmod elit ad veniam sit ut labore lorem adipiscing incididunt tempor aliqua et ad consectetur minim enim magna ad magna magna dolore sed sed do labore dolor quis sed incididunt elit ut sed quis enim adipiscing amet labore adipiscing incididunt sit dolore ipsum veniam sed tempor labore lorem adipiscing adipiscing ut minim sit tempor incididunt eiusmod enim ipsum consectetur ut adipiscing sed labore quis do aliqua sit elit lorem lorem quis sit eiusmod elit sit magna incididunt ipsum quis elit sed et dolore tempor ipsum elit minim aliqua magna elit magna labore consectetur labore tempor lorem veniam dolor ad sit minim veniam ipsum incididunt adipiscing tempor dolor et minim minim sed sit ipsum elit sed labore enim minim labore ut ut consectetur eiusmod labore lorem enim dolor eiusmod labore minim aliqua magna veniam et dolore ad tempor lorem ut amet quis magna ipsum minim amet dolore minim do dolore lorem ad veniam lorem amet dolor consectetur elit dolor labore ipsum do do do ipsum sit dolor consectetur enim quis dolor minim lorem eiusmod minim minim amet labore sed aliqua adipiscing et sed labore dolor dolore aliqua adipiscing sed lorem quis adipiscing magna sit enim adipiscing veniam eiusmod veniam enim enim sed ipsum tempor lorem minim amet et ad dolore magna quis labore magna do ut adipiscing sit incididunt tempor et do amet dolor sed aliqua et labore lorem veniam do minim et ipsum et tempor ad adipiscing et sed et et dolor veniam dolor et lorem adipiscing sit dolor ut sed minim magna eiusmod ad ad do tempor lorem aliqua quis tempor sit tempor enim elit ut ad ipsum enim minim minim veniam dolor eiusmod lorem elit lorem ut sed adipiscing dolore sit consectetur aliqua consectetur adipiscing do enim amet dolor tempor ad do dolor dolore sed minim tempor do sit dolore ipsum sed amet magna minim dolor incididunt veniam consectetur aliqua dolor ad incididunt quis labore labore sit minim magna veniam quis lorem sit do quis consectetur adipiscing minim eiusmod labore aliqua et incididunt amet do magna amet enim consectetur ad adipiscing elit consectetur dolore sed incididunt lorem veniam aliqua quis ipsum sit sit dolor elit dolore labore ut minim dolor eiusmod veniam eiusmod minim ad enim ut adipiscing adipiscing ipsum eiusmod elit sed enim quis magna dolore labore ipsum minim ad lorem ad sit ut ad enim adipiscing dolore adipiscing amet labore minim veniam eiusmod enim minim incididunt ut enim dolor enim incididunt labore do do elit dolor incididunt lorem adipiscing tempor incididunt tempor labore consectetur amet ipsum enim magna incididunt labore dolore consectetur ipsum sed labore ad consectetur veniam aliqua dolor sed consectetur incididunt do et ut et eiusmod aliqua incididunt incididunt elit do ipsum sit sed magna minim veniam et sed amet magna aliqua amet labore dolor sed dolor veniam incididunt do minim incididunt incididunt incididunt amet dolor ut magna aliqua dolor ipsum ut ut tempor et ad labore minim ipsum ipsum dolore ad labore enim quis dolore minim aliqua sed sed elit quis sed labore sed veniam enim quis do et labore sit sed consectetur minim ad ad tempor veniam sed do quis amet dolor elit consectetur lorem amet labore veniam magna tempor ad incididunt aliqua consectetur eiusmod ad elit labore aliqua et ut aliqua veniam magna ad labore ipsum magna consectetur incididunt enim ut consectetur quis ad incididunt dolore minim et tempor dolore adipiscing minim enim do aliqua ipsum adipiscing consectetur dolor elit consectetur ad et eiusmod et incididunt incididunt ipsum lorem eiusmod ipsum ad amet tempor enim et eiusmod incididunt dolore ipsum minim et tempor tempor dolore quis sit minim dolor ut ut eiusmod veniam eiusmod dolor sit magna amet tempor do quis quis elit sit tempor do magna adipiscing veniam labore elit elit elit quis aliqua aliqua ad ad et tempor et enim ad dolore et ipsum adipiscing sit incididunt adipiscing elit enim et veniam dolor consectetur lorem magna amet labore ad aliqua consectetur amet lorem consectetur magna adipiscing do et sed et et veniam labore lorem veniam dolor minim elit ut ut adipiscing tempor dolore ut et elit magna veniam sed lorem elit sit eiusmod labore minim enim consectetur elit elit do incididunt et eiusmod incididunt enim quis labore ut lorem enim veniam sed enim quis do aliqua minim labore dolore lorem dolor elit eiusmod et eiusmod veniam sit ad eiusmod adipiscing lorem do adipiscing veniam veniam magna eiusmod ipsum et elit elit adipiscing amet ut consectetur elit incididunt ut quis amet ad dolore ad amet do enim quis eiusmod lorem labore ut et ipsum sed ut dolor aliqua sit elit do veniam tempor ad lorem ipsum eiusmod elit veniam adipiscing dolor ut quis veniam do lorem quis ad enim sed quis elit tempor adipiscing quis veniam elit veniam dolore ut incididunt sit aliqua aliqua sed incididunt minim veniam minim adipiscing incididunt sit labore labore dolore quis amet enim enim aliqua consectetur eiusmod magna sit lorem minim eiusmod ad dolor ad do tempor lorem quis quis quis minim sed dolore ad et do et minim sit eiusmod veniam lorem aliqua labore incididunt tempor sit ad aliqua ipsum incididunt sed incididunt consectetur do ad dolore amet et enim amet adipiscing veniam magna enim lorem consectetur enim amet amet quis dolor dolor consectetur elit quis amet adipiscing incididunt consectetur consectetur tempor minim lorem do consectetur do labore magna ipsum incididunt consectetur minim enim eiusmod elit lorem veniam amet lorem amet aliqua do ipsum adipiscing labore sit ad aliqua tempor sed dolor consectetur dolore veniam dolor enim do dolor tempor sed incididunt ipsum labore veniam amet quis consectetur lorem ipsum magna lorem adipiscing aliqua tempor ipsum dolor magna dolore eiusmod elit sed aliqua dolor eiusmod dolore tempor veniam aliqua ad sit tempor veniam amet dolor adipiscing consectetur aliqua et consectetur amet ad tempor incididunt lorem amet eiusmod lorem amet veniam tempor aliqua ut magna incididunt enim aliqua lorem eiusmod eiusmod enim amet dolore et sed sit lorem dolore sed do amet minim ut adipiscing dolor eiusmod labore do magna ad amet adipiscing sed tempor quis magna enim amet sed ut dolor quis quis ad adipiscing incididunt et incididunt amet lorem do ut ipsum ut elit eiusmod ut ipsum dolor eiusmod enim labore lorem tempor incididunt ipsum amet amet magna sit amet sit dolore dolor ipsum enim tempor amet minim et minim lorem dolore amet veniam labore eiusmod sit ut adipiscing minim dolore dolor minim aliqua aliqua sed sed tempor magna labore lorem et ipsum labore lorem tempor adipiscing eiusmod magna ipsum et amet dolor quis ut consectetur minim tempor ipsum lorem eiusmod amet sed incididunt ad labore tempor tempor sed veniam dolor aliqua quis enim et ad labore magna enim aliqua dolore sed et elit enim et adipiscing dolore adipiscing sit elit veniam ad dolore sit minim ut consectetur magna aliqua eiusmod elit elit veniam amet quis aliqua minim et enim minim amet aliqua veniam aliqua eiusmod labore dolore ad sed labore dolore tempor quis magna ipsum lorem magna eiusmod veniam ad ut enim incididunt sed adipiscing ut aliqua et dolor amet labore minim magna eiusmod lorem enim labore labore consectetur ut veniam tempor do adipiscing do dolor consectetur adipiscing ut ipsum do et dolore et sed dolore enim ipsum minim et dolor tempor incididunt quis aliqua ad sit lorem enim ut ipsum lorem tempor ipsum quis lorem veniam consectetur dolor dolore ad enim incididunt amet tempor labore tempor sed sed magna sit sit enim lorem do enim quis minim quis amet dolor aliqua ut veniam ad elit tempor dolore dolor incididunt incididunt enim do enim dolor adipiscing tempor ut tempor incididunt dolor sit et lorem amet consectetur ipsum magna dolor minim sit adipiscing adipiscing quis sit et tempor elit consectetur enim adipiscing tempor magna ut minim ipsum sit sed dolore consectetur enim ut elit enim sed ipsum minim lorem aliqua et sit ipsum magna ipsum sed ad labore aliqua aliqua tempor dolore sed sit et sit magna veniam adipiscing eiusmod dolore aliqua magna ut ad aliqua dolor sit magna dolor ipsum et magna sit enim sit tempor consectetur dolore elit et dolor eiusmod labore incididunt enim elit enim ipsum elit labore labore dolore consectetur veniam ut adipiscing ipsum aliqua et labore sit incididunt minim sit minim elit sed elit labore sed do sed et elit veniam magna do ut labore elit do ut aliqua magna incididunt labore ut aliqua veniam sed minim ad magna ad dolore ipsum ad magna sed quis ad magna ut adipiscing minim sed elit ad dolore ut aliqua et veniam ad aliqua ad lorem sed ut ipsum incididunt dolor labore aliqua tempor consectetur labore minim do incididunt sit ipsum incididunt magna magna veniam ipsum minim dolor amet elit sed elit consectetur dolore minim et ad enim labore amet aliqua incididunt veniam dolor adipiscing elit lorem enim sed ut do consectetur tempor incididunt enim et enim quis ipsum do adipiscing magna ad veniam adipiscing sit dolore do do do do sit aliqua enim veniam aliqua minim ad amet incididunt elit consectetur aliqua ad ipsum aliqua sed et adipiscing sit do sit enim sed ipsum veniam dolore amet et elit lorem ad tempor tempor eiusmod labore ut sed ut lorem sit dolor adipiscing enim veniam sit ut sed et et adipiscing labore ad ipsum eiusmod tempor sed adipiscing ad lorem sed ut magna quis do quis et ad consectetur sed dolor quis adipiscing ipsum amet tempor quis et aliqua consectetur dolore et enim amet adipiscing sed adipiscing labore ad amet magna tempor quis dolor incididunt aliqua ipsum minim eiusmod veniam et labore ipsum incididunt sed magna ad ipsum enim enim tempor elit labore et adipiscing consectetur dolore ut adipiscing do lorem sed do enim amet enim do labore aliqua lorem sit elit lorem adipiscing enim consectetur ipsum ut elit eiusmod labore elit enim sed ipsum lorem et tempor dolore lorem enim ut do lorem eiusmod et lorem lorem dolore minim sit tempor sit amet dolore et labore enim veniam tempor labore tempor minim minim ipsum incididunt lorem ipsum ut labore amet dolor enim lorem aliqua incididunt adipiscing amet minim amet aliqua enim adipiscing amet do magna quis ipsum sit labore elit incididunt minim sed amet aliqua adipiscing dolore et eiusmod aliqua ut adipiscing consectetur lorem ut eiusmod incididunt labore incididunt ut et eiusmod ut elit magna aliqua enim amet labore incididunt quis et incididunt amet aliqua quis enim magna labore lorem dolore ut ad ut enim eiusmod amet ad incididunt et sit dolore eiusmod elit quis magna amet enim sed ad lorem incididunt adipiscing sit eiusmod enim amet ipsum adipiscing elit labore elit adipiscing sed do ipsum lorem elit adipiscing et incididunt ut labore elit ad dolore minim minim ipsum enim amet quis ipsum eiusmod quis dolore consectetur sed enim veniam amet tempor labore eiusmod dolore eiusmod ad dolore labore tempor consectetur tempor do tempor aliqua incididunt quis sit lorem enim adipiscing ipsum magna ipsum consectetur incididunt dolore adipiscing dolore ut sed tempor et incididunt adipiscing incididunt incididunt do aliqua lorem tempor amet elit ad ut amet consectetur quis dolore amet enim magna et do ad lorem ad tempor adipiscing veniam et minim ad aliqua ipsum incididunt magna dolore dolore magna labore aliqua amet do elit do magna do ipsum adipiscing ipsum adipiscing sit ipsum enim ad dolor lorem tempor elit quis sed ut minim do dolor labore quis quis dolore adipiscing amet dolor quis minim enim adipiscing magna sit consectetur sed amet incididunt labore eiusmod veniam enim incididunt dolore eiusmod quis labore amet veniam dolore ipsum magna eiusmod adipiscing lorem amet ad tempor ipsum veniam ipsum do ipsum ipsum quis et magna enim ut consectetur sit aliqua ipsum et do ipsum dolore enim tempor lorem consectetur amet quis lorem ad veniam labore do tempor ad dolore consectetur dolor ad ad minim lorem ipsum elit sit tempor incididunt tempor incididunt tempor dolor dolor ad aliqua incididunt consectetur amet amet aliqua minim do minim amet ipsum amet sed ad tempor ut eiusmod tempor ut dolore incididunt ut quis quis incididunt tempor enim sit elit dolor dolore lorem elit magna amet dolor veniam consectetur lorem ipsum magna eiusmod sed minim minim adipiscing dolor sit labore sit adipiscing quis tempor tempor adipiscing ipsum eiusmod elit aliqua eiusmod dolore veniam ad tempor ad lorem dolore dolore eiusmod enim lorem aliqua dolore dolore sit lorem ad adipiscing dolore ipsum veniam elit quis ut sit adipiscing magna aliqua quis consectetur dolore veniam ipsum tempor sit magna aliqua et amet magna do magna ipsum quis elit lorem do dolore adipiscing consectetur eiusmod ut sed incididunt enim consectetur amet enim minim sit ipsum veniam lorem quis dolor sed tempor do amet quis ut adipiscing incididunt elit elit sed do ut tempor aliqua elit quis eiusmod dolore ad ad sed sit sed eiusmod do quis et consectetur sed sed labore tempor eiusmod enim amet tempor ut consectetur dolor consectetur dolor veniam elit eiusmod dolor consectetur do sit ut amet sed enim do ipsum dolor sed do incididunt incididunt sit sit labore magna consectetur magna lorem ipsum enim amet eiusmod veniam elit ipsum magna et dolor dolor dolor et magna aliqua enim magna magna incididunt minim adipiscing aliqua lorem eiusmod aliqua eiusmod aliqua incididunt elit eiusmod elit ipsum dolor ipsum enim sit do sit adipiscing eiusmod adipiscing ipsum incididunt eiusmod dolor magna dolore ut veniam sed sit sit eiusmod amet do minim eiusmod sed amet labore et eiusmod incididunt et tempor ad labore eiusmod ut minim labore veniam enim dolore magna quis eiusmod enim tempor do et quis tempor consectetur eiusmod eiusmod ut amet lorem sed eiusmod sit do magna incididunt do sit ad sit sit elit ut ad elit aliqua ipsum dolore enim lorem labore minim minim elit veniam ipsum amet magna et et amet eiusmod sed ut et tempor enim elit ut eiusmod ipsum dolor ad et sit do dolore amet amet enim do aliqua eiusmod ut sed amet enim aliqua labore magna sed quis incididunt sit ipsum aliqua adipiscing elit ad adipiscing quis ipsum enim tempor enim dolor eiusmod tempor dolore ad incididunt minim ut veniam dolor enim aliqua quis ipsum sed do lorem adipiscing ad incididunt do adipiscing tempor sit ut enim do dolor elit labore tempor magna dolore quis labore consectetur aliqua lorem aliqua tempor veniam et eiusmod labore et ut magna enim labore sit ipsum incididunt ut adipiscing ut sit et magna ut aliqua tempor elit consectetur tempor magna aliqua dolore dolore consectetur consectetur veniam amet ad aliqua labore consectetur eiusmod amet incididunt elit veniam minim adipiscing eiusmod quis labore sed sed lorem aliqua dolore ut et adipiscing eiusmod labore ut lorem minim dolor do sed sit ad quis do tempor et tempor sit labore ipsum eiusmod enim ut eiusmod tempor et labore lorem magna magna labore lorem dolore eiusmod veniam incididunt ad sit lorem ut labore lorem tempor incididunt veniam minim veniam minim eiusmod adipiscing consectetur sit sed ad et enim quis ipsum incididunt aliqua ipsum et enim ad magna minim consectetur dolor eiusmod ipsum ad dolore veniam aliqua veniam sit sed dolore dolore ipsum quis eiusmod dolore sit dolore amet adipiscing ut dolor eiusmod quis magna dolor et magna do quis amet ad incididunt ipsum sit eiusmod eiusmod ad labore consectetur quis enim minim ipsum quis elit veniam minim sit amet incididunt elit ipsum dolore ad minim lorem tempor ad do eiusmod eiusmod incididunt quis elit aliqua dolor incididunt sed sed et ut sit quis eiusmod aliqua do magna consectetur enim ad minim labore minim dolore ad do adipiscing eiusmod sit adipiscing labore elit sed amet dolore ipsum eiusmod ipsum sed amet quis dolore adipiscing enim ut tempor amet quis veniam lorem et do consectetur tempor sit eiusmod elit ad eiusmod quis incididunt ad elit incididunt ipsum ipsum do sed aliqua adipiscing magna et veniam ad labore ut lorem lorem ut amet sed aliqua quis consectetur tempor ut enim incididunt lorem quis ad labore consectetur do ad aliqua ad lorem minim elit quis tempor incididunt tempor sed do eiusmod dolor ut minim labore quis ut et sit sed eiusmod sit labore eiusmod ut dolor consectetur tempor adipiscing amet incididunt enim magna incididunt et dolor elit eiusmod dolor magna magna minim lorem ad ipsum labore enim sit adipiscing dolore magna aliqua dolor et et tempor ut tempor dolore dolore sit dolor ad labore ad dolore sed tempor aliqua labore quis sed elit labore tempor ut elit do sit lorem enim aliqua enim consectetur amet labore ad magna sed dolor consectetur sed et sit labore consectetur et amet incididunt quis dolor ut minim minim elit et quis magna veniam magna ut amet consectetur ad ut aliqua dolore lorem minim dolore quis minim magna et ipsum eiusmod lorem dolore magna magna quis lorem labore adipiscing et ut sed elit ipsum veniam dolore elit dolore ut quis et adipiscing enim amet sit magna do eiusmod amet ipsum magna quis sed consectetur dolor labore do et ut amet eiusmod consectetur dolore consectetur incididunt sed sit aliqua consectetur tempor enim enim tempor sit do aliqua et eiusmod enim enim ad eiusmod ad dolor do lorem amet sit magna minim elit sed sit veniam sed quis sit amet ad quis et quis adipiscing ad sit ad dolor sit adipiscing sit eiusmod incididunt eiusmod dolor incididunt sed adipiscing veniam sit sit elit minim veniam veniam aliqua ipsum lorem adipiscing sit tempor labore et quis magna ipsum ipsum minim do do ipsum ut dolor consectetur adipiscing magna tempor lorem quis enim dolore amet magna amet adipiscing aliqua ad consectetur amet sit enim veniam consectetur veniam elit aliqua do magna amet eiusmod do consectetur consectetur tempor minim tempor enim lorem eiusmod tempor sed quis sed elit tempor consectetur amet dolor do ut minim lorem incididunt lorem enim tempor dolor ipsum dolore magna ut et adipiscing lorem ut sit labore enim labore tempor minim veniam do amet et labore minim aliqua elit ut quis dolore consectetur elit et eiusmod dolor magna eiusmod ad amet enim labore incididunt tempor labore quis ipsum lorem ad elit tempor dolor et quis et elit dolor dolore amet amet magna labore dolore adipiscing ut consectetur sed consectetur adipiscing incididunt lorem veniam eiusmod magna incididunt veniam ad ipsum sit do dolore do do ut do ipsum lorem lorem dolor ut amet dolor magna adipiscing labore ipsum incididunt enim lorem lorem ad veniam incididunt sit consectetur ut tempor incididunt do adipiscing amet et minim elit ipsum et amet elit consectetur adipiscing enim et aliqua et et amet dolor dolor incididunt sed incididunt elit magna lorem ut enim ad adipiscing ut labore do consectetur do incididunt dolor minim veniam ut ad dolor incididunt ad minim consectetur tempor tempor incididunt sed tempor labore sit veniam consectetur ad ut minim sed quis eiusmod lorem adipiscing minim dolor do veniam labore tempor sit labore tempor quis ut quis ut adipiscing dolore minim enim enim ad magna ad aliqua quis consectetur aliqua sed tempor aliqua consectetur sed amet ipsum dolor ad minim adipiscing sit magna ipsum et ut enim elit dolore eiusmod aliqua magna dolore sit incididunt ad dolore sed consectetur elit lorem consectetur veniam enim incididunt et sit dolor ipsum elit tempor sit ad sit eiusmod ut ipsum minim do incididunt ad labore consectetur dolore ad incididunt do magna veniam adipiscing sed ipsum sit aliqua ad minim lorem elit sed dolor ut labore sit tempor elit ad tempor sed dolor incididunt veniam lorem veniam consectetur sit sed quis ut adipiscing labore lorem incididunt amet magna magna aliqua sit dolor lorem magna minim veniam do dolore ipsum enim dolor do dolor labore quis sit tempor incididunt enim lorem aliqua labore amet minim magna adipiscing magna et sit enim eiusmod ipsum do adipiscing lorem sed labore minim amet et magna dolor eiusmod dolor quis ad elit sit tempor elit sit eiusmod veniam sit lorem sit dolore enim aliqua dolore amet eiusmod magna amet dolore dolor ipsum adipiscing et adipiscing amet minim elit et ut ad eiusmod consectetur elit lorem consectetur labore do veniam incididunt et eiusmod adipiscing ut dolor veniam do ut tempor labore sed adipiscing ut adipiscing ipsum amet lorem ad sed do incididunt et consectetur quis minim consectetur quis consectetur sit sed ipsum amet veniam do labore minim eiusmod dolor do magna eiusmod ad incididunt magna ipsum ipsum incididunt ut do veniam ad elit eiusmod labore ipsum aliqua minim ipsum labore do quis sed ad ipsum minim veniam aliqua dolore enim ut quis incididunt incididunt adipiscing elit sed ut et eiusmod dolore tempor aliqua minim ipsum elit elit et quis magna quis dolore sed ipsum sed et tempor et ipsum sit amet dolore quis adipiscing sed adipiscing tempor labore sed ut amet dolor incididunt adipiscing dolor ut ipsum enim elit magna enim incididunt eiusmod aliqua dolore aliqua veniam sed veniam elit ipsum elit lorem veniam quis eiusmod eiusmod enim consectetur ad minim aliqua tempor minim et ut quis consectetur quis consectetur minim magna minim minim do consectetur et minim amet tempor minim labore amet quis dolore quis ut et ipsum dolore ad ut ipsum quis minim ipsum eiusmod elit ad minim adipiscing ipsum aliqua incididunt enim aliqua sed tempor tempor ad consectetur elit quis dolore amet dolore dolor do amet lorem do sit enim sed sed lorem lorem magna ipsum amet consectetur eiusmod veniam adipiscing amet dolor dolore eiusmod sed et sed labore dolore dolore ut dolor lorem adipiscing sed enim eiusmod et eiusmod et aliqua ut ad aliqua consectetur minim magna et elit dolore elit sed dolore quis enim magna elit adipiscing incididunt adipiscing incididunt labore sed eiusmod incididunt lorem adipiscing ipsum dolor sit do tempor dolore ut dolore et do lorem enim magna ad tempor tempor et ipsum sit ipsum incididunt quis sed ut labore ipsum magna lorem sed ut enim tempor dolore ad ut ipsum amet dolor sit et enim ad sed quis do eiusmod incididunt sed lorem lorem dolore et et lorem sit tempor sed labore veniam elit et consectetur eiusmod et tempor do sed sed incididunt eiusmod sed adipiscing amet elit labore magna et consectetur veniam et ut incididunt ipsum aliqua consectetur adipiscing incididunt dolor ipsum sed dolor quis labore tempor elit dolore dolor eiusmod veniam eiusmod do incididunt do consectetur elit sit aliqua veniam et ipsum amet tempor veniam incididunt dolore amet eiusmod minim do minim magna ut quis amet lorem magna enim enim lorem sit minim amet et dolor lorem ut ipsum eiusmod labore elit ipsum magna ut labore lorem ut labore amet adipiscing quis dolore do tempor elit enim dolor minim adipiscing et incididunt enim incididunt et sed tempor consectetur et sit aliqua minim sed quis labore et et lorem eiusmod ipsum consectetur tempor labore aliqua dolor ad amet do magna enim enim adipiscing lorem ad ipsum adipiscing sed aliqua quis dolor adipiscing ad minim adipiscing dolor veniam veniam dolor sed elit ipsum lorem dolor enim labore dolore dolore amet et magna magna ipsum enim sit veniam amet sit quis magna do eiusmod elit veniam minim do enim enim incididunt consectetur enim tempor dolor do ut dolore sed sit sit amet adipiscing ut enim lorem lorem enim ut dolor ad sit magna enim sed et ut amet sed adipiscing quis consectetur adipiscing eiusmod eiusmod aliqua labore magna incididunt ad incididunt incididunt tempor labore dolore sed dolore sed dolor adipiscing sed ipsum tempor magna elit labore labore lorem ut dolore consectetur labore tempor lorem ipsum veniam consectetur tempor ipsum ipsum eiusmod eiusmod quis veniam eiusmod magna ipsum dolore et sed sed amet magna elit elit tempor dolore lorem dolore et ut aliqua incididunt minim labore quis quis ad do ipsum ad ad labore aliqua veniam eiusmod sit dolore lorem ut quis ipsum veniam do eiusmod ad sed consectetur magna ipsum veniam consectetur dolor eiusmod et labore elit lorem veniam consectetur quis et incididunt dolor elit dolor do do quis minim ad sed consectetur aliqua labore adipiscing consectetur adipiscing quis consectetur aliqua ad minim adipiscing do sed magna enim labore magna ut quis enim dolore dolore minim quis enim consectetur dolor adipiscing consectetur magna quis ad amet sit quis minim enim elit tempor sit tempor quis et adipiscing adipiscing consectetur ut dolor ut minim dolore sed adipiscing consectetur sit elit adipiscing consectetur aliqua minim amet ipsum adipiscing ut lorem incididunt consectetur dolor ut do lorem ad consectetur lorem do sed dolor sed minim consectetur magna veniam eiusmod do ut labore dolor ipsum ipsum aliqua minim labore veniam ad adipiscing labore ut consectetur ut sit ipsum sed incididunt veniam lorem quis do adipiscing ad ut minim minim dolor veniam sit incididunt labore eiusmod eiusmod sed eiusmod adipiscing veniam elit dolor veniam adipiscing ad aliqua dolore adipiscing elit eiusmod amet adipiscing adipiscing do dolor consectetur eiusmod sit ipsum do sed quis veniam sit tempor sed sit adipiscing sit magna enim tempor aliqua enim elit lorem sit lorem enim eiusmod lorem veniam sed adipiscing enim elit et magna consectetur adipiscing lorem eiusmod incididunt veniam ut eiusmod enim aliqua veniam aliqua consectetur ut ipsum veniam tempor magna sed sed elit do sit consectetur elit consectetur et sed quis veniam aliqua sit adipiscing labore adipiscing do ad dolore do adipiscing dolore et eiusmod minim lorem quis dolor ipsum tempor labore dolor ipsum amet ad veniam enim adipiscing aliqua enim tempor lorem enim sed incididunt sed labore elit adipiscing tempor quis dolor magna magna dolor sit quis amet dolor do elit eiusmod amet dolor quis sit quis lorem labore aliqua amet consectetur do dolore et ut quis adipiscing enim aliqua elit elit elit tempor tempor eiusmod lorem dolore ipsum quis veniam elit dolor lorem labore minim incididunt lorem ad quis magna magna minim veniam sed minim ut ad labore dolor dolor ut dolor sit lorem eiusmod et ad tempor elit quis dolor quis et dolore elit enim minim magna aliqua dolore sit sed sit et amet amet dolore veniam labore aliqua minim sit enim ipsum ipsum lorem do magna quis amet labore et ipsum do lorem consectetur veniam tempor minim enim ipsum dolor do ad do veniam do magna ipsum ad ipsum ipsum veniam eiusmod do elit et ut sed enim enim labore aliqua ad veniam sed dolor ipsum dolore incididunt sit et dolor eiusmod dolore incididunt amet ut veniam incididunt ut incididunt et elit dolore labore amet amet eiusmod et dolore ut sit dolor magna labore quis labore adipiscing magna amet veniam dolore do adipiscing ut elit labore ipsum enim labore tempor do enim lorem aliqua ad ipsum incididunt quis aliqua magna et eiusmod tempor dolore elit lorem elit enim incididunt consectetur do enim ipsum ad et quis ipsum eiusmod do labore aliqua aliqua minim dolor do magna lorem enim lorem amet eiusmod amet magna sed adipiscing elit sed minim tempor eiusmod eiusmod lorem do enim ut dolor labore incididunt sit ut dolore labore veniam dolore adipiscing enim ipsum dolor eiusmod aliqua do sed amet lorem veniam consectetur enim do magna adipiscing dolor dolore aliqua incididunt dolore enim consectetur consectetur magna ut quis enim incididunt minim adipiscing quis magna incididunt ipsum sed consectetur ad magna ipsum ut enim dolor magna veniam et enim quis ipsum tempor tempor ad ad adipiscing incididunt tempor elit elit minim enim lorem lorem enim et quis ipsum magna lorem veniam do et lorem lorem ut eiusmod dolore sit dolor enim aliqua lorem do minim ad aliqua amet ut lorem quis veniam eiusmod eiusmod sed eiusmod eiusmod amet do enim minim consectetur tempor minim dolore incididunt et et amet eiusmod quis eiusmod eiusmod ipsum sit incididunt adipiscing ut aliqua dolore ipsum labore lorem do enim enim tempor minim adipiscing et ad ipsum dolore eiusmod amet sed adipiscing quis amet incididunt adipiscing magna amet sed do ipsum veniam labore dolore incididunt tempor elit et ut et sed ad dolor ut aliqua adipiscing eiusmod minim ut dolor ut eiusmod minim eiusmod ut ipsum minim amet adipiscing sit do tempor ad ipsum dolore do consectetur ipsum consectetur eiusmod incididunt ut magna dolore veniam veniam adipiscing sed dolore aliqua ut do quis enim consectetur sed incididunt veniam amet dolore labore aliqua eiusmod lorem lorem consectetur incididunt ad do consectetur ad dolor labore sit ad aliqua quis et ut elit ad ad aliqua do dolore sed eiusmod labore ad ut ad lorem ut veniam incididunt sit aliqua enim adipiscing labore adipiscing minim veniam sed consectetur quis amet magna veniam do eiusmod minim lorem sit veniam dolor amet adipiscing incididunt lorem minim tempor dolore amet veniam veniam et tempor eiusmod amet et enim sit quis lorem ut dolore lorem tempor lorem ipsum labore elit elit minim veniam sit eiusmod lorem minim labore ipsum et labore sit veniam veniam lorem et dolor elit magna incididunt eiusmod veniam aliqua lorem et lorem dolore incididunt tempor aliqua magna magna ad dolor do lorem do sit et do elit sed do ut dolore eiusmod aliqua consectetur do elit incididunt amet aliqua enim ad ad do magna consectetur ut et quis dolor veniam dolor elit consectetur eiusmod adipiscing incididunt amet dolore amet incididunt ad veniam elit eiusmod amet minim enim elit tempor elit sed ad veniam incididunt eiusmod elit dolore incididunt magna amet lorem veniam et adipiscing eiusmod aliqua ad adipiscing consectetur veniam minim minim ut do et sit dolor ut adipiscing elit minim ut adipiscing consectetur magna lorem et lorem eiusmod sit tempor magna eiusmod et adipiscing aliqua et aliqua quis magna sit incididunt eiusmod labore sed sit elit dolor ipsum amet labore ipsum elit adipiscing sed eiusmod sed consectetur minim sed adipiscing ad labore magna elit incididunt aliqua dolor eiusmod ipsum lorem adipiscing quis magna ad sit sed labore tempor do ipsum magna minim veniam eiusmod labore sed enim sed et sed incididunt adipiscing consectetur ipsum minim sit ut enim elit eiusmod minim eiusmod dolore dolore veniam incididunt incididunt magna incididunt ad do elit aliqua sed veniam adipiscing sit veniam elit dolore do et ad consectetur consectetur quis tempor dolore sit aliqua aliqua ut elit amet et quis et sit ut incididunt incididunt sit enim amet dolor incididunt sed ad consectetur ipsum ut eiusmod dolor adipiscing adipiscing ipsum magna adipiscing minim magna elit quis lorem enim elit sit dolore elit eiusmod magna quis magna sed amet elit eiusmod magna ut enim dolor eiusmod aliqua ad ipsum dolor elit eiusmod magna sed tempor enim incididunt ad sed aliqua lorem labore enim eiusmod et consectetur incididunt sed et ut aliqua adipiscing adipiscing elit eiusmod eiusmod elit adipiscing lorem et aliqua elit veniam sit dolore amet sed adipiscing aliqua ut sed dolor aliqua amet sed do veniam sit dolor incididunt amet sit amet incididunt dolore veniam tempor consectetur magna dolore tempor amet consectetur sit ad et minim adipiscing dolor adipiscing adipiscing et quis ut consectetur do quis eiusmod sed ipsum labore dolor lorem ipsum ad elit consectetur enim dolore veniam ut tempor elit ut sit ut enim magna veniam amet labore eiusmod incididunt dolor eiusmod incididunt veniam eiusmod veniam veniam labore magna elit minim et tempor dolore veniam et do consectetur lorem do ad aliqua amet adipiscing lorem ut ad amet ad aliqua ut enim adipiscing elit sed aliqua eiusmod labore enim sit do lorem eiusmod lorem ad enim eiusmod dolor minim labore sed ipsum incididunt consectetur quis elit amet adipiscing veniam et dolor lorem incididunt dolore sit elit sit sit ad ut dolor veniam dolor do sit magna sed sed aliqua ad adipiscing lorem magna consectetur ad magna dolor quis aliqua elit do tempor eiusmod aliqua dolore elit magna dolor dolor sit sed et minim ad dolore consectetur dolor consectetur et magna consectetur ipsum dolor elit ad et adipiscing incididunt dolor incididunt lorem sed aliqua elit dolor amet dolore et labore elit elit sit incididunt et quis tempor dolore ut sit consectetur enim quis incididunt minim veniam dolore minim tempor amet ad tempor ipsum quis labore enim aliqua eiusmod minim ut adipiscing dolore adipiscing lorem do incididunt labore dolor consectetur ut lorem dolore dolor elit amet labore veniam veniam do dolor minim amet minim dolore do magna elit minim ut tempor et dolore amet incididunt dolore dolor adipiscing enim sed aliqua minim veniam lorem sed enim ut veniam enim ad do sed sit magna amet incididunt ipsum do eiusmod dolore dolor do incididunt amet labore enim et ipsum ad ipsum magna enim ipsum elit ut quis consectetur do ad ad et dolore ut tempor dolor et elit incididunt ipsum lorem ad ut minim aliqua consectetur elit lorem aliqua do minim dolore aliqua eiusmod dolore aliqua minim amet sit labore enim sed labore sit amet quis dolor et quis quis aliqua quis do sit quis veniam labore magna sed adipiscing dolor eiusmod ad enim adipiscing consectetur elit incididunt veniam labore incididunt ut sed aliqua eiusmod incididunt lorem do ad labore do minim tempor aliqua labore minim minim eiusmod veniam veniam adipiscing sit incididunt eiusmod incididunt amet sit consectetur amet lorem elit veniam aliqua lorem lorem enim adipiscing tempor eiusmod elit eiusmod ad quis lorem ut dolore amet minim ad incididunt tempor tempor quis aliqua ut dolor ipsum dolore sit minim amet enim quis incididunt lorem tempor dolore aliqua magna sit et consectetur ut et elit dolore minim ut ad ut consectetur dolore ad enim ut ad magna amet dolor elit ut ut quis enim adipiscing lorem ad sed amet sit sed dolor lorem minim dolore enim veniam sed quis consectetur minim et magna dolore enim minim do veniam et quis tempor labore dolor consectetur sit amet dolore lorem lorem tempor minim incididunt eiusmod sed incididunt et quis tempor ipsum ipsum eiusmod enim incididunt elit ut sit do ut dolore ad eiusmod quis et enim adipiscing tempor dolor magna dolore incididunt dolor labore ut eiusmod et sed eiusmod amet aliqua dolore do sit labore dolore incididunt lorem et ipsum ut incididunt lorem ad aliqua enim incididunt ut adipiscing aliqua ipsum labore minim sit sed minim eiusmod aliqua tempor ad magna eiusmod magna amet enim veniam minim lorem enim lorem minim labore aliqua magna aliqua sed do lorem labore et aliqua consectetur dolore incididunt sit ad adipiscing adipiscing minim dolore eiusmod minim do incididunt magna sit minim enim dolore adipiscing amet ut quis enim minim ad magna enim ipsum incididunt adipiscing lorem minim magna magna quis veniam veniam elit ut do aliqua consectetur dolor enim quis lorem consectetur magna ad amet aliqua quis sed et incididunt elit labore aliqua ipsum ipsum labore aliqua consectetur sit ipsum sit veniam lorem consectetur ad aliqua ipsum quis tempor ipsum veniam adipiscing sit ad sed elit dolore aliqua elit veniam ut sed aliqua veniam eiusmod elit lorem labore aliqua tempor do adipiscing ut sed dolor ipsum ad enim ut minim sed consectetur incididunt ad tempor amet labore enim magna labore sit quis magna dolor magna sit eiusmod eiusmod adipiscing magna adipiscing amet sed eiusmod et amet tempor ipsum lorem ipsum dolore consectetur veniam consectetur dolor ipsum ut amet magna ut labore veniam consectetur eiusmod labore veniam incididunt magna do aliqua ad sed ipsum ut sit et incididunt dolor aliqua sed do amet eiusmod veniam quis dolore aliqua tempor do amet labore aliqua elit et quis tempor labore sit labore elit adipiscing minim ut amet elit sed ad elit dolor ad ad incididunt labore veniam do ut labore amet amet tempor adipiscing ad ad enim amet enim sit enim enim et lorem quis incididunt amet enim magna dolor lorem minim dolor dolor veniam elit tempor quis minim dolor magna lorem minim consectetur lorem elit aliqua ipsum amet dolor magna ipsum veniam quis aliqua dolore ipsum aliqua sed adipiscing sed sed tempor adipiscing amet lorem sed labore lorem lorem et sed eiusmod dolore dolor adipiscing eiusmod lorem ipsum sed magna quis ad incididunt et do sed ipsum enim lorem veniam lorem ipsum ad magna eiusmod quis amet veniam veniam minim ad sit sed incididunt enim ipsum sit dolore do incididunt amet et consectetur magna quis dolore magna elit et ipsum labore sed do amet quis dolor labore ad sit amet consectetur dolore adipiscing sed dolore ut ipsum aliqua elit veniam labore elit tempor ipsum aliqua elit elit ad dolor quis ad incididunt consectetur dolore ipsum incididunt ut elit minim elit tempor ad incididunt amet dolor elit dolore ad tempor minim magna labore amet incididunt quis labore minim do dolor enim ipsum dolore tempor sit quis dolore labore ut amet do amet sit sit eiusmod eiusmod enim adipiscing dolore aliqua dolore elit incididunt magna consectetur ipsum ipsum elit sit ut et sed ipsum magna et enim ad et lorem magna dolor et ad dolore sed veniam minim labore dolore dolor consectetur enim et enim lorem adipiscing consectetur minim enim dolor elit ipsum magna lorem dolor ut lorem ipsum tempor consectetur amet sed aliqua elit do enim sit minim aliqua sed veniam do aliqua consectetur veniam magna lorem do do veniam quis elit quis ad ipsum enim sit minim adipiscing aliqua minim adipiscing amet magna magna sit ut tempor eiusmod adipiscing eiusmod dolore do lorem dolore elit dolor quis eiusmod incididunt adipiscing incididunt et do tempor eiusmod labore magna lorem adipiscing lorem incididunt ad ut magna lorem dolor incididunt eiusmod dolor dolor sit ad eiusmod incididunt amet dolor quis veniam lorem ut amet lorem incididunt eiusmod adipiscing elit dolore dolor dolor adipiscing dolor quis incididunt tempor amet tempor adipiscing ut et ut magna dolor tempor labore et ut incididunt dolor sed amet ad dolore et et dolor sit adipiscing ut quis quis ad ut enim dolore do quis veniam ad et veniam dolore tempor ad dolore consectetur ut sit enim minim sed ipsum sit quis amet minim consectetur magna ad veniam minim sed aliqua sit sit sed consectetur adipiscing quis adipiscing et sit quis quis quis veniam enim adipiscing do dolore ad sit ipsum sed do quis eiusmod ut dolore ut enim magna amet eiusmod dolor magna veniam elit amet dolore sit do tempor magna enim ut aliqua minim sed amet ipsum dolor enim consectetur sit magna minim adipiscing et do ipsum sed adipiscing adipiscing adipiscing consectetur incididunt tempor incididunt tempor et dolor ipsum magna quis ut dolore do quis labore labore amet lorem consectetur quis lorem sit tempor ut veniam ut do adipiscing et et sit labore eiusmod incididunt magna sed lorem aliqua eiusmod elit do labore lorem eiusmod labore amet et amet quis enim do quis eiusmod veniam aliqua dolor consectetur dolore magna et quis incididunt minim incididunt aliqua eiusmod minim enim sed dolore elit ipsum et ipsum et ut ipsum quis magna ut lorem enim ad veniam consectetur sit dolore lorem ad tempor adipiscing dolore eiusmod ipsum consectetur et enim enim lorem ad sed quis dolore do sit sit magna consectetur dolore labore elit ad magna minim veniam ipsum sed quis tempor elit do do minim adipiscing ad do magna elit labore dolor tempor minim et ipsum elit sed adipiscing ut dolore do tempor ut incididunt enim elit minim aliqua ad labore labore et quis do lorem consectetur dolore sit veniam eiusmod et elit enim et sit labore et magna ad ut quis dolore amet do dolor do et et sed labore do minim consectetur do consectetur labore dolor sit labore eiusmod minim ut magna tempor minim amet aliqua quis sed veniam aliqua enim labore consectetur do eiusmod sit do quis minim enim dolore amet sed sit tempor incididunt labore enim minim magna magna veniam ipsum ad tempor veniam aliqua consectetur ut amet quis labore tempor elit eiusmod et dolor enim labore labore adipiscing magna labore tempor amet amet labore magna tempor aliqua quis dolor elit ipsum aliqua amet consectetur veniam dolore sed minim minim quis ut elit dolore ad sed amet eiusmod incididunt sed tempor sit tempor ad elit minim eiusmod veniam tempor sed lorem tempor magna ad ad adipiscing ad et ad sit consectetur incididunt quis magna consectetur lorem ad lorem tempor magna lorem labore labore eiusmod dolor ad sed do incididunt et veniam enim ad magna ipsum adipiscing incididunt ipsum elit veniam aliqua minim ipsum dolor dolore adipiscing aliqua ipsum sed et eiusmod dolor tempor lorem minim quis eiusmod enim sed lorem minim amet labore consectetur dolore tempor dolore tempor do enim incididunt aliqua ipsum aliqua eiusmod aliqua amet labore adipiscing labore sed et elit incididunt enim sit lorem dolor minim adipiscing lorem dolore ad magna labore dolor aliqua adipiscing labore dolor labore lorem ipsum ipsum quis sed quis eiusmod sit labore adipiscing sed labore aliqua elit veniam adipiscing elit lorem ad dolore et magna do ut et do adipiscing consectetur enim lorem elit enim enim ut sit veniam elit elit aliqua amet incididunt incididunt sed lorem sed aliqua magna adipiscing dolor dolore et ad aliqua consectetur sed et elit magna consectetur eiusmod sit aliqua ad amet ut elit enim ad ipsum quis consectetur tempor sed tempor consectetur ut minim dolore adipiscing aliqua magna tempor adipiscing ut eiusmod dolor et labore dolore ad do elit consectetur ad eiusmod do magna veniam sit dolore tempor adipiscing et aliqua amet minim enim lorem sit incididunt ad amet ut dolor labore incididunt ad lorem sed amet ipsum elit aliqua labore ut magna minim incididunt ipsum dolor dolore dolor magna elit incididunt lorem labore sed do et do eiusmod dolore dolore elit consectetur ad ad ipsum eiusmod adipiscing eiusmod et lorem aliqua enim veniam adipiscing incididunt eiusmod incididunt magna sed ad minim quis adipiscing eiusmod sit adipiscing do tempor consectetur adipiscing eiusmod ut sit elit labore ut magna magna incididunt enim tempor ut ipsum consectetur labore do dolor sit ipsum et sed enim et elit adipiscing ut ut do dolor ut eiusmod consectetur enim et magna amet labore sed dolor ipsum sed aliqua ad tempor elit veniam magna amet sed ad lorem lorem incididunt dolore magna eiusmod ut sed elit lorem magna ipsum amet dolor consectetur veniam consectetur adipiscing incididunt elit enim magna dolore enim magna do do veniam lorem aliqua eiusmod elit quis do lorem elit minim veniam enim adipiscing ipsum dolor minim incididunt aliqua eiusmod consectetur elit incididunt consectetur adipiscing tempor ut ipsum labore aliqua ut aliqua veniam minim adipiscing aliqua do ipsum sed ut labore elit et et labore amet sed labore do lorem do dolore sit ut tempor ipsum lorem sit elit ad consectetur tempor do dolore magna sit do sed magna dolore et labore do labore tempor veniam lorem ut magna incididunt labore lorem dolor dolore dolore eiusmod do labore et dolor adipiscing aliqua incididunt aliqua do quis consectetur veniam lorem adipiscing veniam minim amet dolor veniam consectetur aliqua dolor magna enim enim tempor dolor et incididunt aliqua dolore adipiscing amet magna elit tempor tempor aliqua adipiscing minim ipsum minim consectetur do dolor ipsum enim sit minim quis elit labore sed et eiusmod quis ipsum sit quis ipsum adipiscing ipsum labore eiusmod ipsum eiusmod labore enim enim ad ut dolore enim veniam consectetur minim minim ipsum adipiscing consectetur ad incididunt consectetur dolor quis do eiusmod minim quis ipsum minim ut consectetur ad ipsum adipiscing quis elit lorem dolore minim sit enim et enim veniam ad elit tempor dolor veniam incididunt et consectetur aliqua lorem minim et adipiscing dolor ut enim quis labore aliqua elit amet lorem eiusmod minim aliqua dolore consectetur minim do consectetur do ipsum eiusmod ad do incididunt ipsum enim adipiscing adipiscing amet lorem sit eiusmod dolor sed ut labore aliqua elit consectetur ipsum consectetur elit magna magna consectetur sed consectetur eiusmod veniam ad dolor ad ipsum dolore et ut dolor tempor eiusmod lorem lorem sit labore labore tempor dolor consectetur veniam minim ut lorem sit eiusmod veniam sit ad dolore enim magna sit quis amet do aliqua do elit aliqua do dolore dolor labore dolor labore magna consectetur labore lorem incididunt ut amet aliqua labore dolor aliqua aliqua dolore eiusmod tempor tempor ipsum quis magna tempor enim ipsum ad minim lorem lorem dolore incididunt labore labore ipsum et consectetur lorem tempor adipiscing et sit minim tempor minim amet dolore sit consectetur enim lorem eiusmod ad sed elit tempor do sed ut quis adipiscing enim ad labore veniam sed do adipiscing tempor tempor lorem veniam amet do quis do lorem incididunt magna dolore incididunt incididunt amet eiusmod dolor tempor lorem magna eiusmod do ipsum magna ad dolor sit veniam lorem ipsum et quis magna dolor veniam dolor dolore ad incididunt dolor do elit ad minim consectetur enim quis ut labore adipiscing quis do elit elit sed sit elit adipiscing ipsum amet sit eiusmod lorem ipsum quis amet dolore labore elit magna aliqua lorem dolore sed sed sed ut eiusmod labore sed veniam aliqua quis ipsum aliqua sed consectetur dolor consectetur dolor amet magna tempor ipsum incididunt ipsum et et quis quis enim adipiscing do enim elit lorem sit lorem dolor adipiscing lorem consectetur consectetur lorem dolor sed ipsum enim do sed elit sit et minim ipsum do eiusmod ad amet lorem do amet amet eiusmod ut tempor et lorem magna dolor aliqua aliqua et amet ad sit do eiusmod magna aliqua consectetur quis sit ipsum do eiusmod do veniam consectetur adipiscing dolor do incididunt sit incididunt magna veniam amet lorem quis amet lorem sed do et labore ut ad elit enim ad et do lorem enim dolor incididunt et minim consectetur eiusmod labore sed dolor amet quis ipsum sed eiusmod lorem ad do incididunt amet ipsum ad sed eiusmod sed ipsum quis ipsum eiusmod incididunt do et enim quis tempor consectetur et elit ut ad sed dolor sed aliqua magna adipiscing labore minim quis dolore lorem dolore ut do consectetur lorem amet ad lorem incididunt quis et labore amet ad sit enim tempor dolore sit eiusmod elit amet labore elit sit dolore minim quis sit dolore quis ut dolore ut minim ut dolore ipsum sed dolor labore amet labore quis et quis consectetur incididunt do tempor ut ad magna adipiscing adipiscing ipsum minim minim aliqua eiusmod consectetur adipiscing dolor aliqua tempor lorem aliqua tempor minim enim aliqua minim minim dolore magna dolore quis quis ut magna dolore aliqua enim incididunt consectetur elit veniam et amet amet amet et dolore lorem adipiscing sed magna tempor minim veniam ad do incididunt adipiscing incididunt ut sit elit sit enim minim dolore aliqua enim incididunt sed eiusmod incididunt sed dolore dolore ad sed elit amet ipsum do sit ut veniam aliqua adipiscing et do tempor amet sed aliqua incididunt dolor elit enim ipsum elit eiusmod ut do dolore quis veniam dolore enim ipsum veniam quis adipiscing sed consectetur enim ipsum ut sit labore consectetur magna consectetur quis sit dolor lorem magna dolor do enim sit amet aliqua ipsum et ad ipsum lorem tempor magna magna incididunt incididunt ipsum consectetur consectetur tempor ut enim ut enim et do sit adipiscing ut magna labore magna labore ipsum dolore dolor et et aliqua do aliqua ut lorem tempor elit quis ut dolor dolor ut enim ipsum ipsum ad ad minim dolor elit ipsum sed aliqua labore et consectetur ut do aliqua ipsum amet do ut dolor ut ad incididunt quis aliqua eiusmod ipsum veniam ut incididunt veniam aliqua et ipsum lorem magna veniam tempor eiusmod dolor enim incididunt dolore dolor quis enim do aliqua dolor amet sit incididunt quis enim incididunt sed labore incididunt tempor labore dolore do ut ipsum quis eiusmod dolore incididunt sit eiusmod dolor ad incididunt et sed labore sit consectetur aliqua eiusmod consectetur dolor elit adipiscing ad incididunt ipsum et sit elit dolor lorem ipsum dolore adipiscing enim minim minim ad adipiscing minim tempor ipsum magna tempor et amet dolore dolore enim ipsum dolor incididunt ipsum eiusmod quis veniam sed ipsum dolor ipsum do adipiscing ut ipsum adipiscing aliqua eiusmod consectetur ipsum incididunt adipiscing tempor sed ad consectetur ipsum incididunt et enim aliqua do lorem minim sit tempor adipiscing magna quis ut enim adipiscing lorem veniam labore sed amet elit adipiscing sit labore ipsum enim labore do ad tempor magna minim et elit lorem veniam adipiscing aliqua quis lorem sit elit tempor ad ipsum sed ipsum magna minim ipsum aliqua ipsum lorem ut ad incididunt minim do quis adipiscing ut magna adipiscing magna tempor et magna ipsum adipiscing magna adipiscing minim eiusmod dolore lorem minim elit adipiscing consectetur lorem labore quis ad minim eiusmod aliqua quis consectetur veniam sed sed consectetur do et magna incididunt lorem minim adipiscing dolore dolor veniam lorem amet amet aliqua et minim amet dolore labore enim lorem ipsum do incididunt eiusmod adipiscing consectetur magna ad quis enim adipiscing ad consectetur incididunt veniam labore tempor quis lorem tempor consectetur magna ut lorem ad adipiscing quis adipiscing ut do lorem labore minim enim ut dolor et ad aliqua sed sed quis sed ut sit lorem ad quis minim dolore dolore adipiscing enim sit elit ut incididunt enim labore labore magna quis enim eiusmod incididunt adipiscing ut dolore do adipiscing sed lorem incididunt magna elit dolore consectetur labore labore eiusmod do elit dolor ad aliqua eiusmod sit enim do incididunt sit adipiscing dolor adipiscing ad veniam magna dolor sed ad eiusmod aliqua quis minim sit do sed sit et minim tempor consectetur adipiscing veniam enim tempor et veniam veniam sit tempor labore do sed ut aliqua dolore tempor ipsum amet sit incididunt sed quis lorem quis do do ipsum aliqua ipsum tempor eiusmod minim aliqua dolor ipsum et aliqua labore dolor labore et do consectetur ut incididunt adipiscing veniam amet do consectetur quis ut sed dolore ipsum consectetur veniam sit et et sit et adipiscing tempor et veniam elit quis eiusmod et et quis ad sed minim eiusmod sit magna dolor consectetur adipiscing adipiscing labore aliqua sed adipiscing et veniam adipiscing et adipiscing ut dolore amet minim veniam minim enim ipsum aliqua minim aliqua veniam ad et labore et magna eiusmod sed consectetur et ipsum enim eiusmod aliqua dolor et dolor dolore et veniam ut et minim incididunt amet tempor incididunt tempor dolore enim dolor do aliqua adipiscing sed aliqua quis sed ad ad labore elit ad labore eiusmod dolore adipiscing et do magna magna veniam elit lorem sed veniam adipiscing et dolor do amet incididunt ipsum elit lorem tempor aliqua minim dolore veniam minim quis incididunt ad eiusmod dolor ad magna minim dolor dolor quis ut tempor sit ut labore enim veniam aliqua quis enim ipsum sit elit ipsum consectetur aliqua tempor veniam do enim sit elit ut minim enim consectetur minim et ad ipsum amet incididunt ipsum aliqua ad dolor quis dolor tempor sed ad tempor et minim ut eiusmod et sit veniam quis magna minim et enim enim adipiscing et minim ipsum elit et consectetur veniam dolor do dolore eiusmod sit enim dolor ut ipsum do sit consectetur amet sit aliqua minim labore et amet consectetur ipsum quis ad adipiscing do ad amet ad tempor magna adipiscing ut ipsum amet elit enim quis adipiscing do ut tempor amet dolore ad dolore minim eiusmod labore ipsum sed do sed et labore labore sit quis quis ipsum labore elit magna minim magna elit minim ipsum amet adipiscing amet et amet enim lorem magna dolor lorem eiusmod veniam dolore minim veniam et ut incididunt magna dolore ad et dolor consectetur elit sed dolor adipiscing elit consectetur tempor sed do sed ipsum incididunt dolore adipiscing magna dolore ut elit tempor et consectetur tempor ipsum enim incididunt consectetur incididunt ad elit magna magna eiusmod sed sit labore dolor tempor magna consectetur elit ad ut aliqua ad lorem sed ut sed et ad ipsum ad aliqua dolore consectetur do minim quis enim minim ipsum lorem labore amet veniam eiusmod do sed lorem veniam amet ipsum dolor sed magna adipiscing incididunt ut dolor dolor ipsum sit veniam tempor aliqua labore amet ad labore enim minim quis aliqua ad sed labore enim veniam sit sed adipiscing adipiscing ut incididunt dolor labore tempor incididunt lorem elit adipiscing ut aliqua veniam ipsum ut sed do ipsum adipiscing magna aliqua ut ipsum labore sed quis ut labore enim incididunt tempor tempor ipsum sit ut eiusmod ut eiusmod magna sit do adipiscing incididunt ipsum quis dolore amet ad do ut ad consectetur elit eiusmod magna minim ad veniam ut adipiscing sed elit sed dolor adipiscing sed quis elit eiusmod enim ipsum consectetur ad magna ut do minim dolor adipiscing adipiscing lorem ad amet magna labore consectetur sed enim dolor ut ut ad do elit s \ No newline at end of file diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/README.md b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/README.md new file mode 100644 index 00000000..36ce0d09 --- /dev/null +++ b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/README.md @@ -0,0 +1,17 @@ +# RAR 1.54 Unpack15 Fixtures + +Copied from the spec repository's `fixtures/1.54/` directory. +`expected/README.md` is the byte-for-byte payload expected from the +single-file README fixtures. + +| Fixture | Purpose | +|---|---| +| `readme_154_normal.rar` | Single-file compressed `README.md`, method `0x33`, `UNP_VER = 15`. | +| `readme_154_password.rar` | Same payload patched to set `FHD_PASSWORD` and encrypt the packed stream with CRYPT_RAR15, password `password`; validated by RAR 3.93. | +| `readme_154_store_solid.rar` | Single-file solid-archive flag variant; same payload. | +| `doc_154_best.rar` | Multi-file compressed text corpus, 17 entries. | +| `audio_win_names_unpack15.rar` | Audio-shaped WAV payload with Windows long names. | +| `audio_dos_names_unpack15.rar` | Same audio-shaped payload with DOS 8.3 names. | +| `random.rar` + `.r00` + `.r01` | Old-numbered multi-volume archive. | + +Expected `README.md` CRC32 is `0x509e5e3c`. diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_dos_names_unpack15.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_dos_names_unpack15.rar new file mode 100644 index 0000000000000000000000000000000000000000..4c07c78b2915636f8a13be9c0bf1ebf9f0359a71 GIT binary patch literal 42948 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�{zB-6lpR=e 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

uTgKs6^p*2lz)LV3 zKwb8I+_KjZi~7IljRTW2c^9z|Oo7vFf#=;>H^2EI-dYsCM%;mdlZh zT%-}^5XfH2e`YQbwF4EnWH%L&Y^k8r95y51Kym}gp5-knOY}c=ss;7m`gm6ZdjIjx zxQfgR!%hn}BdWI5q!jtbOO5S;#pU?DNxJ`FVk;?R`ZH%uFat^?t4K!0K6yWSEzyRv zHOKKuT77*5NLbDA?6|DY2QvF6)yHzOeeVglnDH5XF!@K_Ad_Sf1_ySk@>*Y)0pwTBjp?}_M zocfa@@a)QkDMJaj7rOyBPid-=@uPs>w%US?w(smOvtyI%_#J4{H+ygqfJgfg8{5*B zTRGuKG#TzpT~%rt7#Xp#Lu^GXMfZZWi@195eK#n7Nx`;QX{0ldPG9kSiHKw7 zstTcz!h7%azsXP3n~ks@9l8Snm(0Xj6ZtkLDrcDVfZzau8uan zBKA>Aoz)~JS{dQp?}B_P77uix{V|4PK$A^IL z0m&P3)P9!t=}SolOU~}gLN-i2vSK+gVvp)2cxIp9Rnn|>ldJy1iSY>hUUzb=>#D=u zCVxK(+zjISBFOTKfeYZ)rR=QH0}df}xK`rgg*;t5*J%5OTdve}8roww9p zv?OE_D1K#{DTp)UNM?rbxIq+K)i}T*T(uqp!r>rs8mjK{6Dm~;omzU0bSI4)X+^c))^`M5_bGGp^im(PYUltQa6u^Rjai%51;Bw-p) z{i!j+8$&wYX>1tNz+5#0k.mZYs5x&#Cd`#Vd~4eweAmn8c9s-u4%u^nxNJ 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

YGJMpkA)X&>;Q8^wd5lmK%+ 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

% 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 &cj@ROU8Mf@*f|^bK!che1s!##&e=NSW~T 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 &wo>Xx&QII00lSKgZor^7!rE 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

h!Q(XH=DJM5wUDWe{w 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 Co1m%y literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.r01 b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.r01 new file mode 100644 index 0000000000000000000000000000000000000000..7b898d053b89b46e080e6f58f8dcdc3e717421ba GIT binary patch literal 639168 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�rI)SZ^ZzkP*&$Sn$4c}1f*thW?qAIn4ExN+TbZH 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.~(sJMWt4a6slZnUxX-FN94Z3GDTmKfO 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]MBr2)|k##J0FeyNFn5R6i7< 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⪼1`oH>46D8)p>gpoZao;YS%j$_ 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%0A14gA!wDdy1L&A~-mYFOtbR4xYs` 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
!)Q#n2>z%|b)if8aQ9 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

eU8*2H`>sQ+{U59~%Y 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

jIybH*0Yt@+fNQTFdmPCTj6LQsONISy=M0{k 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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/random.rar new file mode 100644 index 0000000000000000000000000000000000000000..e04c44883dba8e7f5747f1d467d43a102bf1350f GIT binary patch literal 730112 zcmV(zK<2+vVR9iF2LSQ=a{&Mi000000002iX>+Wa46?E9`> zZ?b)NUU$6Qwle`1@Xjtn9q{4De5C65Qab0+#NjO?=8L>FgyzQ^Ir>^y>=wfk^HomK# zyl+(wU!8}#N@BeY*^A6vxm1mG0#1Vf1-*`L>?uy~UsDv6qe)8LrnIGhH-s z&bv0U=lZnu+?m!-dpel>Cu?h%jdlF?E9RSW{#|6eHQxfb*J^dUhDSdRl+W3nv^-fU z%OLSzmMvpI8_8@=ikkg?k87)v=*l*&TI!w7)TIXZztQivbfXVpNR zwbQn-WO~n5TYcO{CBy2T@#^6f>rXuv?YD6lnz*!8Bf-UW_$lXIM*jZe;O4rf2|ZC7 zI+yv{Y_jsK{gYEM770A&zum9e#QD4Gk|TMmJSL_UlS$&E8yI^`Lz|RVzX^i$tV?_sEw_oyuZ-Bp+Ey z(mX*&ss}?C!*w1<8sm^Pe`fJPqPo z(qdRo+{tC63DYZ_wYyLIp)Mo3ZIIq=U61JXORQ!u?oBzLEK7H7_;5wSq$%~1zqI}W zS0t9Enn#o^M)L;7du{)FzU(j2L!PI73+3&ygX}9krQ&zt_KP5SQ!gv+#%M7^v$JA9 zNy}JO8GXTIuDdf42|oF`vt+u%S0xRiS=+@;x%spjldPn2@w2b!Emmyomh}EP^qo(t z4F)U`l&&m4zm?tUdZ(~n%gmpkBaOfXkIxCwfY%Ta21Zjn74k60C)J~Y7A)D9{Vm3wEjldCNut+3|BGp(t1&Dz*eq!g zLn{KwmPq#+UHzP^<&(;{HZi=JpC&dkBliZ;=j30UeGyg0+f-O76(5n!SnzT1p1>IF zZ1-d)+;8m@L&J{SXMF$meB3_I=c)MM)Cy4Z-3#L-By-@N^x5y%P`MrSWnX4$z+`eovep z`}j@w$mm)R#F#a!E9<2c0xAO$x(-*>STxQ8aZe}nq1vjEQ#0QEN>IHk$PJm{NsO_R zvb-kv{OpYvEVm2CZ}$AIlo93XW+KCSbK;qHOO{rU8csNxB~P0ZHz0tPU-s+15{a$L z$4+b}M2pfTt0(QUX?TC$9f&@zrIk0Lz^HnCuOftRq1zWNYq`SLE!xLFkYftlX%Wga zBkhn?cwhGoH4^Nru_K79T8F;yt7@h{@H_>x$4dT#s#HZBJK5XE`~GDsV7vdJ)+Y2g zG8i8R-$3+lJ=Lv=h}7R2>+1S`wm%^^cZq(q z2T3Yct?8#SQx22Me2Rp$@cfH?GSIj?93*#4uH5?awVTr~K4mhyH-~$mx~&5GK{*OI zysQ#husP>4l(z*!6;Em0WW=u4MxJ;Kxu(d~sgLU5&~!oOIZSbnOUH%*gR*`hg`NzM z5)no~qqIZ}B}F$^&iD1>FF`nEDR)EYeh50&% zsBrvJ<`(~jgCQ_7^%etTlV$J!fWd_t*RciTPO?3l-HrbdoG4+`%4!>cmi8W#IJURD zqa~({`Z3r`hO{kxxb0|dnnsU`=%?jAz9^V$Rw1 zM6~giTSh4KGGBq2x{62FXmqmrGy5mxGBAcu91qmy5MZx2`@TZGpB%E z;d~573mPwSHdGq0s|KlD3m^933rb0)1|etn*%)n^f1*|lFow^a0hT3V%gq1N7fk$( zURWh*i3?5*oP%N3mkJZ#=#M={w&Olfc@dj@S#)eQh*8dD{es}_fPN3-hL>+nNF5wz z88J`zv|KO$JO0=!)nJTqtjoExb8n=+H~2ROX@0))6u?jLB};Mo{Ma8E&c(g9;n};6 z6yLW+<9%t}D8wD(2@@Clj)oY#KtpoGuMyZ63-XBt%};q*rRHn&OrdesqT;%GO9{pO5($+7aW8-(1fNwI zc?B4Awvc`JFK`0NO*?2EC70vQJD24J10XDd#p>}WcO9I^lTtpz6B)Y*)%J6f+AJxl zR1=1OtC6yM+}x%>hujlOJy&`thb{Svj;L7zPbg31N-mNd&QaLA85lWuBlTIGja@*O zip1WWNOj1sWT`Fu?%MuAbX*pGnfaPSjs2ITI+7h@Ye&|1h_qPyJ|Ov^dO+gvW_+3~ zUMmLlH|t2pi9$yC$Eb}bR@w)5m*`k*PWZNlILuviBmX4H4Y|R&e>?t`H1Xyu#we4g z+<^TTO~x}bH3D(gCYxH|9exloY@f*bGx<=IU7`tkWHHPouS{UtbYrHI*l+x}cr^`l z(1D^#DLjSj)eZc>DOvv!6{nqfc{atk_aRs|Vt(=NMLLlXe4{7BgtUBll1HBB2d5eA0Cre~+66xCWQ7|AwS+3!w%{Xx<;QE%Y>>2)z znRra^zT@#vK&Ou^iMcl)mu83|z~CGybo9$`7NBq(Ksey-l*!b|*nh0vN2&m-Hd-0~ z4n#UPV2Yj?-E#Yzops^g;{2B-4+QBc5V$SlPxh_T!b}F*%YdMGygH4f#`4_U1KC@% z?L(p!U&Cj}a~<)+#OnC3wLrgCX_`izKy~Se!vbxi7642vM+dLCog?6RiN)$UIgUF4 zy%+sL8@$jWuEkIMTuq10V-7PN8cF+nKM?7@Rt@<)E2~TtMP=N8d!6t`AC@}R>%_>Q zWWH&E>v#Av`T{~@^K+{ziY@<8A<#wK$$&&bciUy5NIJZ(G9JLBJOr6E7jVxXHs>0X z@{j-A!HpWdzMd32M7}8ymoJrL{D?*>YnqxjWJyPR5=LXgfB08YOo#917yf9_sVCK$vuVmnMm4SwJ z?o%fZkG)7(Rzuz@%O!_cz0y9JIROp48~sU*M1K|>X9K7u--LbhMCgK`P=CNkotJHD zcrDeB_R0uLX=)S_kGc{?XnKSZexi`xwa8EsU6k=WCLFa1T9hxX$hRKSVz1=)uyV)T z`|~^B=bS_-E;<5r-8k0H<(<|B6SWJsxRJ}I**ST9yWCw~t7MG)VhFBqy2pED9gC^? z)&Z_=VfXi36B)FwEZY@i0}dA;uWBNY@{KvdVgD-sXqCG{uOD)m*pu?7yd*-i8k`)? zT%(d|l>)v&Ea`-_AEO_g09f%W5BMCd0I7GEe$s7u89EHv%B-%we{&E&9JQ6r!LS{I zx&k{wLy{PbtrA4qiFB0+yu?mKaZunNh)f6h2PnJ5H(xKxU5fOt(#KWh{WJW0wCq2a zh2OopE1J1_B?oHMw-6<;aE&q29WEi`Js0pWi7aGI+!~BgX*;T;u0YKl zpDAZOvLbw&D;yippu})KtP@wEHt8c?lC9FECTJ%XuDag#tI2pxO1X4c$xtvj>+YjCD8CC|Hd z&LKQjdEGz`6(_PsQ3K{L0ov?J!Zl5L8%j7cSau!@vZ)d~ClHM9Dft}smW~f$=R7-K6 z{OMA?gWSbOYD#3zuIn&=@#CXHo`V1Eyy&~UjDd4fC>{}%I!8@(ThIh{?{j zi9>oM9M1GBI7!_=&6Jk!TqEGW{EaL@ez)ug0Nfp&aS}_kWM#ocfTsu7GTd_&iplb} z2`jG{NwZx4Sm5`wBXaT~>e#@l=wRJttc8jAfD)@+T#TLm8(-W*UWlU-y8FdCManG8 zQZYsYDBL=o*#ACah__qhh@jATXOyi1Un$CN#*;^;4m;!Q_|L$U1z*n^xyZ=5Btb*G zkvf1$(L}q3=4@-r>@-O5L6`cYiRQo=R~V3Y>>Cu7KHf|h`>B+(19~`Q&aqvn)<1^{ zw`|n;0a7)=E6T+MM4nhpQLPFb`X!_|8=w8LdsI=GhN7c_Yx+mF5~prZW*EdLW1d$Q zi0;xZAx$==^1In{BfbCiDKI_Is(rYBgdn5Vkw$BX3hb7rnODXZ9N6N~sXTfWtKRh~ zW82u6%UuSnu83%ZbYR#vDIZn^$M8(;qx1Ad<0@tq+fG>4O}navP&)oEMdvGN0azfz zxKOArTUQR0Mgz(_OtO`LY!t@_ihEIDs*!Apn#YAHXe4C#35p<==lCXar7|xb8??Tp z%RxWHAGMysh>kW8+u<*O$5?%(DyEk-DP9gM(Y)175FIbKwH{}b1bTxsqzLIf#5~+lZ=XF`3E8Jt-uj&z6`{_m^ z*yhV3$JRs@+BfG4F~bRn-VQghmohl^fadede zRj$ox{%sH@2pe=gR!%R123GC}4CF@hxpm?9^SSe#-OyW-Z>lYY>{Z~~Tn9*CxoDCy ze=Mfkib&}BGd*=3Gk33MLp89us#>{5c@z$f@E`ero-<)KvuqFbPo3WRe0(^`)c1id zKaOGQ5Cb97CGm#BeoYtM%Hg{`2f;UXR5Ln)@TlM>2s1^tnDZ_Mo?E7_!e_If^B351 zo}R$>6^~4Vt9YJG;@cHX`G_){)t<|qQiB?_=8T7wgWsTFi2H`JcBxw(heP?;!tQd) zYSVsqz5Te>vsYGR0_#KL_=r6ZNOIA0)i~vPr^=(tmZ2Bq1O=nk1;dUu5yP$&<@tJ} ze5Rn+ljW{Tn)d{tn6BPJZ+j_!MV1p!3qJ_6Nj?O({$x5P*pZ&!BmO*AGu)`&md(d1 zTA4lzc}W|JXu2i0O_;aYd4!ylHdHslWDd%x)j*%6y?K)pd6G5R?NK8vbvI7HwM_IT zLiYCaX#x^}R|(CvXWQsjO}iTG%aC1QHV}HtKyUhjAQHdToPNV}K$pns>S(rr%HA!o z=|f;qUm@#v91PfBKKQPIEqN5*JeQ5*j9)>&!6(ndDaQpzz~4KY8KJ4C~N z4)c*TZ~VVZT_!KPTj?Tf@~JgXOqSPG1f7Dic$)Ix>r zBrod+mDtF2svkc6gjJ2)UaHgbNa@_u=z2fEEyWYHI1>PR(1tI!_%&m`Mw(cGE6)Dd zxV|D7TGBj9&i#j1!65jKLS3pw4?k4uXl2y8e7Zo!_dE%tdOl0DW=4oWuDcO4BB#MLEe z|CIES(6A{`)T`+Ji)b>rMg=o^@!xtIP&mY(j6#Z5jwy%E>=aKzlej}gf1xjrWw@FD z2jE->b2xgkH`Xedo4-J}?Avm=O6uBi%qBgUJO0r5&1^oAs51TM+m4XNNvw<1&)*_d zoTB?B2Fhtb1elIx5_dM)Nf~5gn9OH+CPy;Ex}cbb*dsl@^{G?gqL@4mh8_A-qzLd1Nq}ii-q$%&q#99f2?hFt`LUWwM+dM@|{W_ z1|vHMg(KPYK68BL{tani;x_?L8xTuQ=e2pq$VH(N)}3^`LF`i)U}He!M1hfkYCFm&bS&+Y(w7i0^zs- zJ3E=U#OBBXJ0A_JZi&xtG)jMP8pzWW(uGD3>?IF35bOfelTnagA1J@bx!2PFApC4~ z{<$CMDSYt1WP=k3KTCR4>IGR5Y+i+8L;4dBPRKx3;^ice? zqmH_NC`^-TYU9$H%I#p>3+!uF>d#g&pb)D42p@Xj34ldXu@5rqgfp_06+owOE`QD< z&71K+NyJhW3u1jow=^*Lg#9WTpif#sqUot=XZ=uEr&RwQgTGEwMEzUKZp}Us5yNEu5a#D){l zo4=pG+s^RoqkeVRa3)7(8~ae9w*Q)*_}ZLHqazi&cJ z*20?`Ori2`q)kv4uB63Q4=*f`XJIoKGX6uNgn#+oR@k7sYunvUum#$QlR+EoU}F(E zRdQ{EU!i-@K*ODk(IT39Bxe=LaaTuQM9DGF`atQq?E{EksROX@^AYk|6HeVn5K%je z>dj60S%P@ZUXbpu%eg4=UA$*3J+pufe#%Ap~KU3xi<<{>=N{wEsZf1^>GCN;1uJ z)?fZVITFx?V!N1o#fI=PE7+?l0O1vC^Ytc&T6`znXJ^?d?0o2XZIv@dA3@0UHm63* z5n>!zp3~1a=&e!*Q3xx?N*xKftc@&v0n+^PH$lXsDpqRdn$)MV{}7CrMS>;bsy``V z8vMoTYyQRlVPk=LTZM$GzvY?+CX?@vSs&2NeCj?H2^dcbkJ%hTL}0Ska_XnL;)mEx zfeGKL4G$t=xem=)jIYPKpW^G|Pk$zUqdwg1p#@*~s4|Sj7NQI4g26-Xe8KV76b)VY zQ75f9bp(<$*E=~NcEeE(6h<5?mWneWO#3+^2T)roWCJ6X!*>2BI90GfE53^x8T`A~_|LH6KbSbqiv%0R(XDDL9@`;de zA1)TqFx4sJbHB6eo@kj$IKDrYD*S&RjXZ`N;2_VOjb=uBlOT>C9BLlAW{mO&S%%N>4yW)lOCSDKR+vU78{;D3b%3X_5yguv1rHV+sErecgl{ zxr##j)%H=83*f0gdJwV#^FOwy@)b|5O3`H7Fk63%8B@eX?`;Hp1Uj#M<7E>0b5{-9 zZp)`uiD;tMy8kNoW&d^c*`5aqtfMr+DBOw6CB-s+rt{0Ao`r_=^bsd(Bri7{T3WGC}pES$?CtRY23f23izg-^pn z1$T@hYLL+_mVX0%#$Us}TFWs|*S2C&gRnFjIX>HGp@;*|5PX zs7MR@=r$d@@n?vpx_l~6$`Uz~n9$|h#gqpMh%mg33!+GO`I4u|@k{;%@K|KTM(R7` z{A0gS2Ixs$Fli%F-Lo)+B+p{5fnK8k=&xMW*qq*^`O+F1h3A_VCB-V-L+wiC%*`Fj zaWB*mBw(i|F{rT_y87*f2ofO$4QMB5U(#eZqJ~yU)%);){Us0iEowBZezzkFL7p1b z9;Ar=HI$}#j}o)&2NCK~UJbnLOhW}Uzb~jDSnm?2t1R$Dh%m6`^u5}!H#^%|{Z69e zogANA%h@BwL&ED80_Feny*ycD6;?H^uTAx{y_!DWrQuk*nV8!9%;+T|ST9cBv5OAq zyw~RHNz|+o)-R0MJp9Ur^BsF>@t#mTAzAmLcF07t4%sTXF5|2n*rhJtq=c zg%mR5^VLVgY2|6>DCnlgC9@i>(p*Agg{E{6fg`qBsnt~MmiYIZBFWID2G z#zV4vI7+B4kB1kxUGMSBh~1N^hs@sAdNVIUKO8CH!dLNge>WAcuCS|;!+qhEx3AQP zZZ(-E9e3*B5=~I17I8Gm>`(^0)?VRz=Ynm&=DDw%(0xt6b(JFH^fv%9*F_gyoQe3i zB?D3bLLV~kOiz|+*`a0|>df$;H=q5Mws+(gpRR|f+_C^%0ePb8y zzTSpi`?$VsWrdRF*wCZ>iEboqD}(kJh$A^wt0(7PkboBj9H=3{Q8Dp8!v)UxjQs7(!QOZ zLA(3eyjld|+>b6y+M6`MtSS*WENaRV^UaD!AayeZ7#$NT*!Ro zdk@fTVjQiUOT*I8DH4#HhT@OWA4Wc04a!boaZ1S{L6858rHC>A>@{1e^?k?jXCWf< z?6~;9sMV5@RL%y^NVK9>Q(W?x<1=e1>>9lJt7FpNCwjQ?x{JOUeCCo7=utero+|2h z&3KO_=!zQhi_4L4Zj~<90$#=$XeoCaHBe|`wal(1WRlgAdU zYZRX?;->>PNmwmDG5+WBVw+3Rd)v5ta>-yakCe|f zoGNiR4dRiwCxX%^QNWG)!Vv9_7Zjd%wGgmz6RU!Mrf)44$UxP$-0?dSO(1|7Z;5u3Op))h7U7Jdu>X?Bn{jxk*W`IQVA;vtZS3?1wKF z5#gf6m)Y5yCP1xf)OqKixOH4}UeVWe^ z6U^lnlxt5@QkHREMO_CKDP2{9(dIKyj_i8@snzesN)#dV?^4RZU?$=>t7DCwLdRDD& z`aX(;EA`S|se9*T#%^;xnlQwnxY;5K#w4HVN{}%I2 zNa7h+K9oq~DJk^&Y%sqKAO|_iaoWadrfji7?9`?YSGY>lig;5C^y!=|JL=Q0xUm9k z%nG2*ph;P($zke85y}kQ0J6)MXZKkUqGw>XC`432=m{8V=PyX&PslYvM&NP@HqNP8 zS}BGdGTg?I(TQe~{O}K!pnd}gM+l~_ z9yPfZS+=lC%xkv9Kie=}x9a5r(W^Kr(P&AcwaL_VEC-DW?z0r+(=1YYppS@hWJ=6E z*+vQpYn^Xpk@-=x7W{1!Lk2>a{Q0u?{3i%Y>ePwknX?ilUA+YP(*kH6*o8Nf{JJ06 zdm_r#xDm1oZfK8Fzs_|(TVso)9h zQGOwFfBD+HT05fg)P%n2bd}i=U4%9e0S{$Z`ujEMBSx7*r8<#%mZs42ghI}ke)J`GOMN^SRHIFNw0`7q;J-+-8~-c`j1p^UE?8xuP_RF zp%Yh3z|s74kP#n#{<0&#OZG}%hCF@RmJs*T4P4e1i5VI z{RLSEyii14&kiap<c+Hw-M*vr_FLwqe7$^vIN!DTB6_KO)+jIYb-5 z2)R}TYN!$52^sWkRCyUEqGg6tnq<04;=0tP3DV5ePvEO>xA5=yy)0Wf#K9MN){K%E zVp=PPXB<09zN?Lm+|ER}diij33aR=%b-q~cjJGiz`EltM^uW*&ZT~h@dl4e(=%J`Q zgwc}0BeM)tW`m7{3MhTK;ouk*CMQ}V4r$u`jSQK^{HVu12B^oW$?Sis2wRh1$GiuY zkDi&R+l@vHx4E}|qX2QW4TsIEq}s_|Un1lPdtWgO&W&%MK2@DR3a2qfE>pkU8e&y| zq%pyj1(asVj+K5r4622*x077o0>dfr&f>a`w~*`u^=+2>+z+IffqkmO_$Ov6bnzsN zwlO9Ex$uL{WhSWcZ0iY&BjD{Nen6HCNVt?=NcO88e!+x>%fwLe@MEcV@u+1*a=>Jo z=CmxB0}=c-Die5u%-yJV6yH#FQHV;F0}WpWzUkOx7Q05EXsdwGLMjnAQ1gs3MAi zzC_DMMQptaaf6rLTZ?vpqb~Do_Z`_gJb+ZuxEXY4Wm9CXVved0tdhw{3$%*|1uhGD z{=<#@@pK!72p{pYKrUO^ABT=zwvC>iYreKPbSuwnG^`p#83t4F0FDH-Vx!$-_9Dqz|pCIx)abK z@$;kz7j%$)fy=dp{q3iDR0F@I2-`&*rZTvsgcuDMyu0HY z9CZW{5-fw>?{$_bs}Sg!=YW@Z`KN*4V}e^BNIvC4R}viI|FjItZfF;c(D3r+hnPoe z|MnMi72W>Cql_Tiv9Lg~@PTewh-bcA`&Yr}TT z+tc5VLm&pgQ6p~OOBl1EQtxo8=l+v{ymDCvDDzLWW@HK6d&N4@Sr^REh z?3*x6XW4kee2_{PDA-B$cbbQnbqi%q;e zL2|NUdFSWCXoAT5v*$veC*_gPO7L}XTOiTrBUTQXwQbXc3{Rn199v&3Bn!xU`>K+; zL)_+t{OybX%36eI{Mt9H;>(Z6|CH8${n!o@jJckBFMZnN-IibYsw9M-bo~rV+#}5r zDru7itg^EpW)5cujcbROYIC2^gj=#(5wy7nqFFYf_u@#}afr6=#+J_QUP%3_tm1CJ1dFf|X4_db)? zM9E}mOL7DF2z0dr0=*JS1VO&ch@W`4=GpGy&UjIKaIi_iBfcMlJ8lP;=YgnKJ7?}o zZ_A*mrTuO^x2Sv;_Eu46ee+IHkngG3CZ;kCW$@HN;%0G@`WuWQ6h*WTUXsGT3`nvz zuElx6VZBIUnAbPC;WAdcMB4>Lv;~~er0_MKrv9ZwC;BXfNR#A3qs8j%8~B=B2Y>SB z^_ozyTL~&pY}YuY$2*x|=^*%4~T^08WpYrv=v1>N~n>xN13@_+~{ z+-ZRs5JXq3_tiL&4b{aJ{ZAD5D1+VuxuZIce6T%_*puY^=%y2tMekjZ zRkl4IkGs?WX`t`P!k;u)N@%)UysY;D{fq6_mfGa=O`!cKxG`>Us~uWK$_!mTlXn>j z-mzkZP_7Her!tYzqh=H^spttb*y~9Oj!ydIC0BiT1IE~^T$37MXc(ZQF2A7y@$|_H znFHC?*%GZK((N-{4NsA>c=!d?oqO^tfPJ)5C3uyc!^Y!(>qr#*iTyi*XzRovWSj47 z-F1G{%)rMq*{PrjDQI}k|RLLN;@#YlqnAUj53x?<# z@0*CRiobC98QQ9SOPK}Yv{wzJ#z5f0^OK2A7#vDYhSnM?6Y?BaKw88rV8vsslC7k< zS+}Lf+m}G3eCTVZiFG%;;P81_ye!rm#LPu7TsI=!Tn^^l%Fo16$qxLmQWjs-Zk7(5 z{lgnf#wSfrCj5c{$73BIZvkY&3J}e7t`Z+8TB4_0tpwb7UiF};jzWcUJ^2%(e!0e(@(AB}i>SXLgzY_y_e1CHiwis55r3xqj78E9Q@e2E zaP<$aY0kxZ;mfTNYGrcig6jh`H^CF?_ko$JMCvN?kV5Eo=>(%`J`7lH%OK*x_2m5BVQ~T#t9_8=I#@85^ zQqg>?YNRCy=)!e^irko;{ldT+KnGlxvIXgUMWJYy{d!+HFCIkw$3hiz-y#oawfi?_ zKY%tCHgnFzdj3oW|H`Fyxk^Pzg!GeVw?li8dJosN0^>`U8fSmUE#FVeKvz8_Qv6}l zN))KZhu-^`^x@{IHOQFY2{3)ReVP?!oGPJe@l~40ll&Bki z{P2UmNMW`r4ds(jlPQFkL_UCl11%kN!KF8|Lu$qFN2|rpFp=opKhP-G1e4~HcRoDj zwGo?hf%rh|3Vt+Yr`{YeCyJ|sk&;4$)3lLBh~2`3V^F9L`aVTqya*BD80lUNyv8y? z?t7*=Nw9?fg+2j?#SF4V>3J$e%PdwMAG~BB=umR?H`L=Z_u-_6NJL{tTc3cbZ^p9q zW-f{5b|{Lh3d_XXR=M7s9MBRMUML|ClEk6Pu+>;3iro6GfS4e1A*`HGuehyol6B$* zk|y+5o{fs|+9E7t`Qi71xkI8#YR98($=w39R|5e6@#r(7a-?2Wo-w5feeg^iA(%r(z;7_WJ68kjE*EjRd&LohJ&{g(H~BG=py&Ax3L6TYl!x)MlEi1 zaOx=v<(<;|VW?NhSea%aJ}}EjLvAQYFZ>)9H0thb!t#qW-hC|}p|Af`ypRrt~d6dtGYBFnM$Mz_D8vpxxp>9t<-YlWG`Eteygc)`n%Cvm^GtV{l0Z~XM zeD$iF*9t@kkZRz8}JP#$TKtJ-SY#~>x|B%3F%h=^8 zNEcboa7NnfbP+hzg(B}FI+2`eS$Q27oH>1&MLh&Imfsao7gK7vGZ_-T@?rHOR%NSIb4m zHo8=l@vtV)<53$)D|?ThdwRAoD=+s4?ETt7S@ox@wdVM%+`!>N!}7JkejL-9_0Up; z{}IYb=0%xht$r90U4bgKTYRUqabi zvV;R&X}EOLWDlSek!6;%50YC?9Mo$|)E>2ZEx#8L7VL&W6IgW31)PC7EV9trCTRTS z{NV){4SI<42NG)y5EJRF0Zum>||2s=pK6Nhj0;T3Zf4K;GV2|s2fZcmjlq&y#N6J0(B#NZzvWW&hJSC5vK z_^m;iCzJ{=z}crvRa)S01D`-eLrNbezDZTGG!Bz!9(Cu16EGJd0w%P4)9wd}(divZ zSJWyu*-0918Ipa!PPi%na={(I?+$L~7Y=ahX+!mp#B}{^-oYctb3;ejQpgh429>aa zdKl#5!pyH}J2OrS3fsF!lYy9xnE}2PCgVt~=U>D9bV+Di_;(Q05f*-H_8DWs`Kngt9#py-krNtCMJpNB zOK!szxMv_!$5z@=VgtH@zb3%B8vH%_bxPdnrroD9tOkFMbfqb_{q33-|G^DDX>mX~ zi-PdD8&I;NgkF;EecWF?C=b3zliZBPs2r_ zUd_Bk>79AX-E_M%(AiM?UT~Oy2YlR%AdO?a^#5cLR_0dx|4hMXoaevJyoY}r<&BfSpd^oMbiC=^stlP_*Ga*ch6wqJ6 zmS1Ar6G3!|2&BEX2g(?`^>%4-Y6jMLobD?saV7DaT-{1cNS-o8T4edF*#dS{qU(e{ zDkP>}W3q6n;(ucHr|#;nBJY?@og3xmq&OJ_+WUxK>Vllgm*43*XRbqVdC7JOGpno| zO3$Y4P;Y)wCA-GlJ@(3^Rs{h7jsUAG=uPLTXOVSDgX~13Fe$%6gX#<@sa73ATY+zW z53y`eN_a^dW87h5g1`T)JTHlmspY)yv8qy(>e<+-9x9k7BQkx+(X*7jCvM@%#Dv-1 zl=jF1<$lc%>{@f%7Ot~ruTa6y8Z3(UHH)hOUvFhHp?)9u&7ct$X9KL4cdTN%W3tUJ zX}=5sqmY6_F=G`H3w6unavxgl*7FcZH&?0HF8>lLV!nk&Hj6hHN?^Fc6WfR$OA~@a zFxf>?0S3V*{adroy;>MlI=??*1DYoHvIKE(t4D;+=~y>)bih_F?2 zZq34-mbeoc?#1)j*ZDuMH#tP1!L+ru4=p%wvzA0>$r3WZ7Y!fEElcqjB*cN3XQNu-R+wv?re>Wm5t^xH_Lhc^NuBKa=0l$~)HR z7ND;s&eOr5r01*Z#=F@Y-HHD6!q~|K7e3Lba2>LPJ{vWhAN=d3LxGdF<`RJjOF@I8 zLtpsLZ;;QrhoUo`m*O`d4<_8()$`yG+tKaU$FG-la{ONE=vGuTo;$1A9L1PXxzXrb zN~iH5U^Q$1E+5b{{k&5)Si4b;nvmCa`7b~d>0vWdIS!`!^*9B1KJ=l<8f^=XK?P%? zd+@#?lN4F^af=lqpSPObL7rse-t`&vDqV`&3d(p>5pOcHl}Qd<$j&h>df>j4cu`Zu zoaa)-XUq^~_4mahBkPiqNClUoamRh+(qRxwS111m$HaBJN9!35Z582ca0O-3b<@k! z`^-PoeM+*bsIO*sgPhLrI?BrmAkC4s?d#PzKFYn9YeYWYgaRF(Z~>>cf8di2Y~Ev_ zcIb|~CV1MK2@9oss$7{yZ0Wwp{8Ta;Ct3d;aPC27lzASHQ>2xt99%vfEoJ%m(>+=P z0W;_57%K=jOn6Aa6hoYH7O1JaQ#TO~88_xdY3%R}sA}|&o-!%;0=u=x(P2E5MUhoH z;Ge^^EF$0NmmP?Wd`Y+=`r9WipOLSAl(Wr; z*YB?cb-`)Ui|K*dYy&r4oJ7fwXcq4JNf03}b4JqA(H&mkALynIk1-Uj23sh#*+IE) zqB$O+Rt(s?JZ>3uvxTZPuWVNpvP zP(@kKQ?O#2Potx4Yx@q2E8!*2{CBShfy7Hc`xJ>-78LJhFyuiekJHETb!FHcJ`h%l zsTLGisp%~KW@5b?tXm?20EFom3{Tx2R|xlTy(mx7>o#cL%o03$%$zpeII(bIe&TDQcT zRdJa@)^Z#FnKLmc>;+F!iOC4qnRi~UbHX!!l0PV&NP05!8Ax>vdpu)hpf0dG_k^Q~ z)R8sDcOF(Z7wfwSf#fmHxx?*kpZtO1SCISSC1%g0O)tC0;{03s^n0K@#aKKQI+VYA z;!w0ljtTq;cC_%(UMdG2d+&954mxUEcVp^xtkq&fU3GSp>#2f|AtN-7VcN^uI?#S~ zf=wup?&$ldsiQhg9tV9Nry)wj9q}C@F>vu#54wZ_cDnSFxU2#=oiptm_cU!T>4L^e zTwRr@N)OY2JIjjK(}}1jP^HHP#x}Dp~f&e@*L1&c^|k^^6jT(Gzcpq z1pOk!^5~PjHlHsZu>J0II%Z4Sdylh%7s+s(R$8JmKdHhk1>7FwU!DIkz?-J`SODsa zu^tM6=z1#(sFGi=Pie>dR_5|cl+w=~{-7TIo(l}TXxC^{3%iBNJ08g zvmEg#ZoK4dw2ot;eS@tdFPnk!$2co8apQwi@MQ$?t&IfO6Z`wC`1I5KXBElhdyO_F zVxnbFVdEjfjn zqp>p5ZTdJP&SO2Ol{Q!WP1@vIWW7u*=-x{E3;A^DKZIK+J3J!mgl&U7n>79S7Zlu4 z%yoUB9%yW@KP8y~Y`wyRC14n!<<2}JiZyd_$G(0w|B&4)hmMCt(|i$x{69`ac=<|W zF+-kgzGPODE zbVXC249XT`|MqG79a&7uL|P)D*`(9Zat|;{Mx)Mm3!j78n((q&BYvXC0z0;+D<0hr znRs59HwHmvVMx~7{f%0kwr>@w#G^UNsF0ox`aaU#?}@d9IyY&~8%1wA-xU*z+TsGSZy_8N2sOT}Swp@!E?Dex!;%nVNeziW7K1RREi$I~a( z&k%%qYsTA)B*0BK^8Jv}bf+?tckV>y=Iy=Kmt-aS`0<9)Xdp#Va^uBS@#M3T#_G22 z30BG9c)1VYvnB=U)~Lx&2zF>W)%GMI#9U^Il3&BrA(R%_tqiD*4tjkP7D1M*xl>(W z>C2;m#Qkir14qt};99#973f(@{fUH{h)aVrJhGIwG@LtVomHr|zDUYJLr~1JA6`A`BeVQC8<6k{X2xqdXa} zn6e|j{BJ+g<4KY##O=fr+JEGZojX=hYrL% zd>A$bMj;g)+^rLYR0*LzcLM%%0`}#{#X){cTf)*(Roa9b22p5V7UaKS-Dw*JA)u!^ zGIMTp3*&<(Zem9cCEE=?$ih@TIMaJOz7rnXGrQ55J}U{P3~gOuuX&-cRzrrROCQZk z9*+0B|4pbN-Y}TYoyjd<(C5ysSN}()U|_cZyC`4Jkz#kFGe(^64R&Lisgiw29S1iz zaVTJV9FEnsj)Aegh1bNv%>h>a$QRMk4H__5^lM@r61X=q`S~QG-flz z*Orgx>wk~H-|O6mg@e@6yqybVn52vo?!~!{q%Y%%-gN)s1JZ)=YLq&iyZ|0<_~}-g z!WtmfWOxZ~(SQD&Tx%jO!q2@nK63x5BLDdp6;0Wa+rwKCrh$*&x`&F)8wiHSnt@(7 z=#Ilds-F1GAwEbJs43Jm6(3tDq}2QR z4CjTh_5H6Apwx$utxMf2YiPPpR|CnqL6M)Ec~@~pX>@C1#cjPo6#BAt(}hHI*n?xS zw&u$XZ;^wl+88;1#q$A=X$havmVyF$y_{((&!#H3SIDnK&KE!C{Z6*QA z*uG5(E?QhCLldw#m3z#q6V-fSTgtLvG6E5f)ebb9%BSl|ImRx%pzX!q=urP=DTASz zMP1R>aWc(#^TP_I<5m%7Gc*WaZI5PvwB~t7YO~lT1hmi*48`D6&RD(m_x_9?Oif0n~QemTx&ez)bF z4=+3Qd*sql#@`2l&rt-P5yyLBwq~8*XnHV1pdT6#7JhSCjsUt?&Jr##js)LVC4vW(nViv%gF3O3EQ zvC=7QsZZFp$)Uib{)=!aUf#KvsVEAtU3csrXw%#$yY*l);C6~MVh8enTuCho9q{?u zbE67$k8+IyL496qFZ_m)9e4PjcC(axeK|4Ck#K-k(lDC5zBh@;rbnFqyG z8d>RjpPLo%xa5{QnU2wMlTn!^WWlQw68F{jbbnc4PUT8kv)W{J!t9Y0gOopj}4h8Hq z;Z&$v(HOMuM$i>cZIUhh?d+_(@+nu^Ur*-&66Ip3?IRa3U_0C3wVtwmO@T_BX2ko=1x9}loCMPlh8$@uTgXm*)fUY2rz(~5-t&D z<7z!z{_;|Av}%=Bn$#f}jKiga_j6=c?3zEV#Sg{uO&D>_Wuo@?#`5Tt{QfiG;H&{w zBj#9eYY@=eAz+T+{901gLJlcl%A-gWK{5>yoZ|!T$s(31_g2j(iBTV!Ab@>DFEQI$ zdeCR8@r2fs(-|Y^QhwBRu-&y#483a3%0OWdPg@oni1iL+@=uY@W-hTY4e90003S1`o6WGYr!1<5(^d?~g{O2&i32JC%{-)4k zlC<_sWP_&`QGh^^vuwO9?;^*^!FCMskP|s6>Sl@%(c)?OhUzXI zW|d*8X%oWZU*a|P)ja6NJWg@up`gZ{yi#90;{v9-+XLQ*;;_?rkBqDn#Q#-`Oa0Am zGitpI$Z7>vxlZ6TP?D-Q*#cPTlE+9(kSu@0;t)A3s+b5QxQZBvt~*H<%~bwe{_(fe zN#8EVa%T=|aW;V;&)kvDXienGbpRI`%z61X(+lARN8m)VqDF$hxXCZ>B& z(q4q-UWnbaL6ff+{NaSQeiIg$q&fcRpBu;|{ek{1qSz5mX$~N5LW<>A=}?#mL?w>m zfZxg989!A28BCFe4zJoG^uG;WV;5QUj6oMQezyJ~|Ksau#>`F;D-acR9KTbU)u_fI zE883VpMopP7?G};o?6J55#VU(8D~$qQMgo0Ml92q0zB zeh9O4Ls8M*FH%o+)EIZcuW0!Xzoug@9Hcp7;dornL-^n;2`^(6plql;6bY@QcS1}T zvTf^)s#J;o`8h%lUg5(rJl2^4S&#aSvXImP?z1nl{}_1_O9q}A4CGGfjil5Ex(^0f z*I5uV6mqk1_*~g7!}Px68>HFK=1&Tj>XrUdV$0%}y)-dnYJ6z{Ec9QLAol?7i4h}l zEX_i$O=%c0j8QmMw|O5xjsNf&9&1C{r!5F;9*$${w87%-l{~*eh9Q z3;XAa&s09WZ#9#f$ZvFg`YM&M8i1MCJd&dMi(?}Nwv(FyxA-+sJgCZTiGCd*5g z_?nj-UNH2U-6`G;1WZlB(3`RwLJjYkG6(A)Us`p&?o4+1^;}=wBOR{qWg|pV_P?lN zU?1i5=HOArMtru#WDty52bD`v|JOWZn0@rg;kI*i(vy*9MgQ%tvh*qa3Sbx+0_Wy{kd~J+^r$OTd1W=}{;Xeop)4^R4FGAK zLgPsP4hMAJA>PGmPfGee3<=$W)cilXbQ47?Oe z2lPTz6Nd;6+xL34ZknaP@Y>v1KISZk2Yi;ermF}@qzo`H6jq22D628qc zNOi9E-HpVYI2E6`)T@KoOds*0{`*Fg&>}~;^hr88*u3#a->7x1EL`d(Yr_ZQv`?Ms z`&K+Co0p~)sg~7gP)0RAl!ApFOGbJBqCYWD86-VMg5fvQW7d=%$@(OA+zQ5eV|l2K z2#>EuZZ#izUhJ0P1Xt z^CLK)9P%T}w3oJ6t$b?cOZzZ+G`*acFqtS$i!&eEv;x3cwEG7%it`=Ni0mX9%!3h1 zZHeRZ%25@%FCc+RMbf`jGec363U%QZ>$64tu4R6z5BiztlGMqnD51Et8FAQW{Tv-a zL7=9$^G%-)Ie5Dw)i>hnc-WEKxU2cp43kq?4S%1R$)H=X&Y4U8k|QkAi9lb4?}in1 zj->m#?K%-%hpgIss7;a3?<*t|Cn&X)R%Bv$M>8uE5A`OS%Mm>&r!?a=>W1o@EDrMN z6TPF{Iiy1c8E^Ec8VqjHP`ht$H`ucgn(s0He*A>z4Ii5rvjtzR;=usHWM{heZIKHTZF7Bqp@(t)rGKJ4YSQkpCVI^w1_$j$WcGg8Nt=JZPe;@^Kz(He&wmTwMG6xt?2$e+=Vbu z4JLsEh1dI*yk2?>6h&g@FYf+oIb;uq*FwDkcfU;)ehxK=-YGlZ^fN&trrI z4>D_)o$R&6TH5dIz{Tq|Z)Wxb(5bD@1~7YE{Ux#xzmt~4Ct96;B)a)lYW(!DFdS{q z%sj%yPuc?59&DnI*f@MhF1^8Gij^*TL3r(((pXVM$g{3twUCpaKCXKaMBxYoeX@y+ z6zCKgT+{16=?sf5ZT{iG7Mtd#SV@>8Y$;ZF;No)iYkCWn*&d`j?QwRrG-JqxA+5rS zmxk08_Tl=o(Q*!wPNgKn+P8`RO z>MF}HJv_5-l;=_E9Cpd3QRr}+grEP=`iY8xy(}GxcN7$DpVcxUXjK6bdtc~!sUSs?KGqhx}akx?ECX{l|WNi*A^#K*b z8O7XE_<*6?+lTk(Dy(ZY!T5r<0DF&L-pQ&YXd9Fe(*DM)(Q-eUs8*B)@eLccRmHVH z&!<};E6RplTZ|0JTDYUX{Lz!!#w+y?3jB|vYOfFP02QN4Imj&;+a@d9vJ4$d7yhc@ zqkbg-9gYeqvpnJjEb%7WX@y!^KCBhXRhf$$h>1v9-(>@`CLWe9qSnzq;4QU}CEp|HL=e(gLK|vpwF+%DLz*9naZA96vxezC z8@)A!(y~FOY~e>`(~-Z`;A`jp6MOmi!-(bbrs|T`74{UZ2cxQ?`5bw-kI)n-WWn7# zNBnHgctIa!OWULY>1L1Re>$<0%lqNl<#CRlxwJp4^!);hmn!!si6gc>IA9T=4 zPlixE(mJ46)W_nwCBk7-YB>YQ#N832HPJ_S2mwzGFIv8urTT7)Mqdi^QhK4*$*5d9 z!AEi+qZOk!#&YQC{Jq6KRHZ@c{H0KeaypAnqLBo5XkL6Djfo#4Dn}*JC&jpcuz9== zOEtW3w;i~1gY-cy8#8JoP{`n+WAFDetoh}o&H2_QO&)emzlLkQ+d79gO}8uI+@cPE zo0&p~)YGZhAKuj1Hpw&E$VRqik6MrJ)v^m(6Z}`NpeZ&#^34`l5)Vf?-`EC0hr&Drtj55oK^I(vnX9k$Ols1arSj`Yp zA<@4f)-IZ#^)mBje~q|+K?Tv)D%JjbL~~K%@UA9mVksQ`6X!wkA{tKJ2dQ4<%Lsqe z`ee@u0;Yn>>rkZ4BE3!bY}He_`oS2NXU;BXFbr@`Ue?f7QLX~U{Nep(z907jrwP~> zAX2PxwR{{AO(Eell;{+U(A(YM z9fUuf@m?0P;wW7~+tP{)9%}>$&O_88P-}+U5F5$n>m!b$vG26Qh)g51>7#Fgc=;?W zvP#d|O?88s&v3n@4b`z<5pFj%k)Eo1p2bMdq8MhNT$SacW*MdF^FE*~%agCMgL6rb zI>&8Aj{Qp7vRvqiclqJT3BtS;44hjG>e{`gw`$jnZMAyuy2(1NWP5E--KK) zn&^5S+x@mQFlrr?esFaI=?+De2eAexNI(#k&V3d?5{1hmhulb;_G=s-{&IEALPnOY zJhz8CPP*cV{=QPU2A>9@2MIk|Txc97H9$5Unr$8aZF}7wUOD^4f5oA_Jvorh5P+0x zc)v29X8<6OQKQ1ob;&ef7Gi+6gMqfYBBc;&p# z6rjXvuD{`8Y3%{#OU(T1qjb~SWPq@^sK%blCf5_L@(<=znb!wk?+0x(#zt(YwCeDn zZv#+b1L@oKM|gt0M3Iu4LxV1J~?o|FtRYlFWHY&ids z;f#i|Bpfjv3PdO7T*o*6$|~2pW)2!Gh#f<2oqC zx<77W(o1=CaCHq3Upo`A+_+$U{BKvdG#-;kaSAdxm4Al9s+iBj%Bzu*jOl+uGZerah@>^W?*N`b?Y}-Ec4=aD~c2ko8 zv@@1^u{F=gR#5eQD+t#EBFtg?zX`zn)1z7+vdE|y)bb% z{~v~3)+Sd_YJM*uJ*_>$m;+G7jxQSwfT2-lyHiSBGL{LGvrl1y7>TlH^R!+cSwx07 z3Fb?RTDQ;OVI!hp%KKwpZ=t_Z}y2gmG=Vl2=;XC?l*%D+j`@vjj#R2;I>bO~V`dO^weo;stEh>Uug8{XKecqW%L0 zE%SH3#*=$J0g1-XJaKY^ZdaZUXp~=GxON8^q3bGtQXFY-{3DKjUmwAq`Ia`2sUlc7 ziQW;0t22+-$)l4|1`ww}sLoVlz-~06_O65M?eYMf_^?O-xFck*y*Frk8t7L9a znXHY~MbPDGA>fn6ZrRb{gKtFF2J1WBBTz;CK^usOB^Cb}YUI<~2m0&_Z!|1%-^_OR zEa%SldJ;7~Iq_1P_k|xS!;Q2pnv`a>d6xgcH>ys!DCXl4{ z^$O{VJ!8;oSZETMl(pc~O-29}bA?a{u1@f4X)}aQ8jSb`P2gB7*HBb4|CsyHC=I6W zbp3F&Yvj`(NDTs{$>Fqb=edx+b2tc>=ac8%Ym4<_Sr1`px4doqPeKWL8>gp@{E$A9 zbuR0{s7x&|*J4Pai22~G8k)ESak8muNkiqHZtFv!x|rhaW)c3(&5hT0W2@aC(I`Hfx|2;tF}2jiry_Z>I_ww3S0zB*3D4fXS2!B^*+X$UZ+8qvq_7+^s*#_GhAT3n~qL9h! z)1*}gILuEOd5KWMkfXyH4v80#ST%&E5+s^~qNj0ZUrmglbSn-; zBTb@Lp=TI((2~}luE#+bUj-XG9uR@mf|OLn*~cUXL%?i@sdm=VVCn|W-M^qWLhbag z2^tws+C~Bm_!e>LBSVt11hnC($P!0{qVL)@iG_yBq6?%Aqo_RV=mHSNGw{b8&$&6i zG*F^)`2YFHq0DV!3g>cm$pC2M`o+(QkoCaBGms3#XdD;xrRJ>@54M|x&nX34XJ9jn zd0y-B(v-oI?;Qq9`}+>cvC=@$K2@Kqi$U4YC!3r-QKpJW^Xel&#WUH(bpsye+;e3# z%B!dC$WE?*vPn&BgP1FbuJ=Ud#D6o z^Cbj+EWtsHZn4?}sB|$_ElHqN29&cZCN$5Dyt&))uA3O^Y7 zl+8f-vQOH>G5;ExPJvX4=~`+YTrMvq9C@b2PxK7rIRw&pqIRX4;I$=N>i4`0 zoYHEb-Z<1&7JqgDQbQ*~Rfw`sLd_clKXYqtW8?(Cr0hGMaa#;N{kw^#cQ?dl2gx-R zq;$Xj^sFx{0)cEP-mYU@SDZ|G2Hc>z(r^Y=o5%S6O6wxHRP|j^2`9E+nKVgcq5AZZ z^t#sajm?2L$YKRnfk?D|p`F|x9B|Zw*)6|kX$}WiG&)KnT6)(SO0T(bs?v9~3iB^l zyy14{mlX0}uq5%YG$;BaqL*)+r=13IlkNoKadDg^mnI4;k2g%>Lg|6)ifCC9LVa~J zmpCH3!PsTjGQ1t@^&a=04^DGViB2CHsgqX)_X|nj?DwZQ%}{b-@WG!lKJlbQjJ2xSE+>kMcav1bQ~t)n`BtEeCO-C4{Uvi1{S2bi_4sjUDkvz6ecP}$Ux&tf_Z*rS4NYR9Am}O7q_7$2Gd`QO$w_{q$~su!owYO z@d`$g&S%Fkps$s(aNX~TkaRV;4~~C9_H5oI`hamSC~~_@cpVy+CNfHLfjY{2^{)iC zR&#%unw=b|C4^3<%xpztNX>3kjR)osb7D775HF!XtVR(=JkLD|xGwGD4b`L`6PXY> zUCV>8QIW98hU+(q*04jaZe%OSvYO2QMk;%S0_sL%7?`Vz zM(eAWgF^0I>%-m5D}`-%Fz#q$2y*6sVWiM&mCZimw5~_(DbO`7LeVA$jG@Y(Cmqlw zE)B;o^KU3Yh{J8bCuo$YPGR{{nqxmBU4CRIxzM(7Fs8o?L=8$e-#|URIU}L=t;>Pb zCoqU5r6U{Vz{7!FAG)}lpRP=KG=i$gT$OJ}93P}yDOn(rA)wY*A{B>;5eEQp;fDMtE2 z9x4Ro#*%;ZIqsZu`k8mYS@BmD(rjX{$6yAcYFepP4COHUW0NC%HlYU&4ZD;oWf+uJ zUO*C_mEPnveH*iu=`{~89KNsQl<}1P9!436WF3Jk`szgl{67##%_#r$t7^g7?tgaE zQfnn*w&}CfQ_{HyyW7vuMMJ>mIxSzk%JLNMU7;Q3SlE_m=IGS2MfqexG<2qmhsdJkaxW?)OeAyc9# zl(a?cnb^zH=~5{i#pL#MX^9J0ywX;-S3<5fmA{~-7B;<@bqVR52?%wfwyq%{879S!mU zIks0gYIy4oD16tfwvVQfsd96^zj&k{_$JGsLbELK^w#6iP-FjY%DeXIVH%gGCC2yf zEVwjg37xQlzEw=mN@rzK;6*Z5jD)_q(EP$1yNm(qf^N^Prq6N}*hE3FB>i)m10I=5 z)ty{n(G`ElPm(3N6Dt?^&QNd3%CE!j+FIb^CEH*@dPJsC-DE5WnU*BTT9a0RH?~*{ zLKJF(i@F=T+s6a7{JAYemNIY-+vqPg>RqPs+#h%_g(iCL8HSqWJ)bSfVLH8(15MKu z8^dW@FY*6gq+~g|ZQ!V%T^xZ!LH3ih@H!1H@ztWbmJV=cq37&NiHxo_&fN=bN|!wO zK0_$oENJ?AgQv?AWm@s{nkmEGa&i~&)JNE~r@!Jx>!)YtLnp3(N5H)t^KJ#K1M*~; zFU=+#C?|DWDyWG;XbSY0T9GaP=k7BzBhG5hzfk5BnCk2dq_Br7_r&hE1qkR})K1n5RR8(s-a|A~UK+lcM2uDlZt&pO6+X>A->$ehq zU4%Sfs_&cjBiLAVQUzB5Qb(3^I5iZ7K@)BUelLOS?s8YyEVQ_6t1O0_p z#d_*mB*-y5zAkE#_FrK#I92q33m$w>qa_nD9m8{(zpqg5jZum%d-cVQ8`` z>;)5Z%z@El;a@c$C#ljy=8$+xnn;a(Kstef-hE+irCI|Ya(@d%k+kbHJg zGu6sjF-zwQf5=pJsXYiu;-XaWC|5gOB5Pbun*6J*h5jsIf)SHx3!A_!X~b|^yz;y+ z=4uQBxZEb~FsT31?l&f?RQfPIbk+vID)OCzXtn zagoUOfHbaAJfi1mcuX8G4WPh_c>M16F^}y0Msyi(ru2GTu#!3qsHHZ?7}-60Ysx@v zv=Bsrr-+ksgNw?R2XV+^R9v42g2vY4FZsJgMACPT^Kr!m`m6xmcims9ug1XYW8Fd% zscnAOU?L+UP}sTflMX39?YY>kC!{;Sn}JEY84kmt*^KN%RcB2ub~kZSygT<+{TwZ zU*RwH1WJwI%Lq4vK&2j~DTP%)Bi24b)0AHPe6V^Z7bc2#-K@t>5ew-ylm za~1vLr7s$;iz)YAl{EYZ{*brEBw^qrkj{{ZqNE&vGONIBmtAx<-OBhhg%Bau&)q?0Q~amC zVF7_Q{z;;9f<^a+97vWC0D55{Jl#>2xg?z;c< z8W&^?btYpu?0|CbSXx0eA$I9SPtb3pK;iII0t2*AehoV~=x?d|cMZ9n!OcZ$L91V7+YE)eW%ht&HYz1`ss#BoH5nf2 zi!b-JsOu`x62-A9?G->8D#rt2%|u1GCbJRed3tlL2y~uiX+JtO?KwwiX2Xg6rEV6u zb27Z3YDl+(M-;T(gRa1rpiX}>-_}~uiwY70bFL36f$-%P${w*3ix4!!N6Y4RCG)wr zwX0dDgzp3YJ)MLI9aYg2#=~9|6KPr>Z5#dAW$K->j6yh*7BRGufE=0i=xDRsz6=*c z$tVHmi}M<#X0z;*1}6i0%$J!ob&xYB#@?~;Q={@v|GmobTKo$k7C1T~ZWZuDs(+Sg zRqRhy{nX~-ajKt6ROZ^s{lV$cJzN#iG%;kjCRU#Kv$SrUTj+kD_chHQ$K*S{7Wd<) zZkG1N&wy+hQxbtr)c^A|W}jLWTjh55%A0Yu;DMEERQUt@(Ka|~dO z{!3?WZ>dPEs~L@rf3*r_8~m4T1Irg~d2vsYiq2Ow%Qq?AT{$fDrWNtnB07*yc*HZo zK${7W6BSrnbrR~bVgZJ@KPa{QTjr)IuI7{E9@$~d%+3!39;fV4!Z(fj1Vbm!`F}8Z z;lFlkn*2@?oSajwJ6=@;t{)U4xE7A|kO9{gha0NE%l-W^NpJLdxUc&Ed_8DJKfM_b z5a)yit!j}*Hy)}(V;8Db1um4H3Q+&QHW&j?egL(hJ7f$_R`2XDfs5OBp^L3v%E``D zN{K!QJ8^iKzvB+Xjma;jI>(%iJ8=RdiF*F8E_*=X%!TfCg!R`SQr&t)P#i>zp5L$a zE6r}L3yvuG^?}E#nLxG5Xud_M)a2Y>Xn$4hC+w+-=pQRd6-f4C0O1e#vrP#ET*`eq z;j`B~sAq5ARBAD5Hs#lP;AX4z`3;tfu)>v@ri)qIx|n<-&lWeK)rfGl4?$hQO$Uy==M6H-We(CG>LeGuICZFm`Svk{8FI_m)t(#ks0#vk&Xyr zjZwOdBl%>5W$>p$NT+BJ$KU8HD|yLx=>ZflRTF9UnJ`o^A&Tx~u4@#hSl)S1DNs;wXN=rwk4-xF#W&whEFWd3AbINL>M{-K09~RJqbvzJFtIoaH zETztbbCL~Bh}BMRW?aJhQ@27CO)23BLDvts@-cFY%)YA2ORSn(1rf`AxFK6=_s~#Q zc!CxU^8Bn#J(>Tjq#l*z;-Dy0sDf%(4GUvBU=Y#_=TJY+U3K)B`IdYm5_xM`G*d5u zTtn1CZo`UQV$khBp2Cux$_}P&+e6-e_^Tr(qE)L&X_(FX_fIP@3grJpx*=GnPa)+G z-LJIXw$LA_=}T{}pCUG_G*9>cigU1eWWz((X}4!ppfPO1ryVm0-GnmON$AQXN?Rw5nk%m!BR(8XrGUm0S+Q1X zvn>6mB(UMOSMLlFPPqYe8d3Zb44v%*I$-uT8fXS($2tH1FL*FH78DH{)hlgjKX5;9ULLcI-_YV|_wB3C8EFU1&Qi^oGB~ez9-sTW%Y%yVg_l?7R}6SaDiGrT}}Lni$rH1hbqyvF<}V5 zfo>qQ=i(2E`BNWGtsjytb3io+MT>BsC1g8W>=SIY&YUr^@lr$cw5&AP`yj*VR9`4a zwDjKh-FiJ$<@WB%aXQ9P7a;G6p0ScGQzg3zyTQo4~+@OsC3VIng`*?C|gyLp9b2?&(`Nu(=RY`S3Z_Q z{mzVL_)Rtl;(AR}By`@TawjLNbKFtl8kipoV3IO>9(zis39GbViI_L{<}pA*LNB!y z)-~4!i<8rJDAs8UYEvJ_B25U{%yDchK-@WIAh`TP8iEf)d>1AJc%;1PmZDolgTy1N zAa;}M`o?wK2ld06fbg9e(t^FNRsx~@1g({nZJS8WfSprNk&2Jm)5-4FNEC;OmIYki zyQ_$2(x6-aoZ_L9d?_L*sJsW>d1w#BNG8)Y`xlK%EoHv!$p19vzLD!o=>}~p+(mq< z!YElcr5dA)^&fRn;N+GkK>B;B;oVWu)J!kGMG7*`AMkqM6$^_%NC3W{^qm|Of4ND8 z3ugJiH0v+ z-V9dDCz7m39Y{W`S#nf>kAlZYW)=|Fy`znil)%v@-z1nBy||qSC<+hc=jxc{gw(=o z=mUGZrOB%Eg2B8^ZG^L`uHbKLi6lxU=1zm_xaj}EpXVk_LJ(!*7fn>>@3fi<-WeaE zVy{X&3a>NR?RpmAdus;oXp~iXOrX57%08j1$-?5{Fj(8T+AOWXiXdNb(A3FU}h#kfPY~&B+ zibUj&LM93?-t%CI$>`!9kz3=36@OX*6(t4!Vcp4?y9g%flCQK^1>!wB>Y!y=lM*O2 z;FC1ysApk12J_kG*gEfBglLeY_5W16D+1%N@uQ@_Ut$Y`%sDga@f%P6>iC_p6NXD1 z#QpLY$C1&s`iGAe?DLg2gIR_S%yYht+n^mX_njMGarQlmG9UOp*9dcJtHXkVfWIYFi;%C87l2fuvPy(VYu%h@~e0xJshmeB!XGh z<*T46-dMYP@VbWr{5u7rOQHYBaGyi|kEq^Z$XhmV#o#WghhiN7C#refa}3Qqy@_S{ z)HPrh#O%4%w%m1;*&HiV!%Xb|TJ#yp!*#XSdfE~nD|J&rxY=Y(|zy zk<&_%XZ!~f!H62(Ngi4QSXj-7$<~aJ5mz-wdDqGo%m2AWsQp7If`mnF`~tuu1e+oH zXX!>Zm>5?Rnr@IZ9ayzuCU7&>$}gaxu!BsGxoBm!GxfZteR5s{{18h@vK*nVUgwSkpopMR{V%wN0a^Gotucw0mFmZQX5b{tEzPcW-eP zPfA5F)4Duj>=#ZR{RheglF|ceZ5XUI1*bBu5Ci2ZSqj>}ixvP*306)tQ)$vh+_$Xw z`I%I^zqDbZV_uhhxZ|j8I?DM+u4h(pb(P zzVo-B#bti_^sv3_-II{!pP{mXnE4OYvxk<*;uND6ZHQkk5a^{ss+67o=-9iRyzVaL z=t>qH6o-}}3Mh2+5x*Pnq|jV3yTdX`HQ8-gH+@B9s(LC#CJw2!?R6Fm7KneuTh2TW z+Bz-w216^t8o(tz?hzOMG=*e2p4-~IR_H%SoJzmY)-b*Yyk!HP<1gsBcA7*3nCQZ$ zi3_e-5swR{h~bJEA?iQ+kH{1(Wb9mN@}sm_!Wh;jk5rJI!q>_0U4*eWm0y{gA*HGC z+9f08oq>hJv7<9@`AQmHIm(&!bL5?PGPck(+GHC@P%Z^l$excO zbnlAn|HqA`D|nL#I??dR^INQRXH#J;tr6r2gkZhVZcKMX&CaT7Ox%?P0X~p?lnmFq zPO)Z@2v9;t=fvvA?%Bq#fL1F*#M=&P)qqNif9z*|v6svs_rVmwu5G^RE38_Q(&9Q* zk2o+2k|89kD@y)4E~AP>nCa_g<89WB*8tl`toNlAGY(bF;b*F+JA~tAN=QJ3|HluW)nR7w=&2dL=FtOuz6tp_g}g6CEU+ev-xL zc$iqNpvOVSFpp321)+7vJ}%wsP!H~hp=pFeU;Mei(I9I!(qR9?KVK_EOCxLLCJI&% z>aJmu!0XZDPB6z6YBlGPY}5$ASu(sanZyhrL;mXwD2aXECQf(a?=q#$4YHbr6H+X& z$#pjtmFw3%q!pxqcbskSQb*V*r(Z)-4yz0JJz18VSD~&BZYzBtnVrZ(0se!vN|7&~ z;NS3ZAfVfHQtOP^!?q6ZEpBD86Mnh(k7bpM3k_yop?oEJWM7D|tM6skU@RXJ<;jGa z`-3&@45OR3BkD-rGit~Kg1AdG@Jai~;`+;Om!W%jd6s%#greSN0@|Kz=kt^jlYGRb zY^SvDg4UVNXOkh%=m=2UcO#)w$Hz=Y!Qjc7ux))p$}4S9Fe^GNU;JW1$+Q(@?`3^_EZ?!Nz{GjHBK_|ZaKK?59w z@k;9fscQ9l^Ul7qhUeu*MaMt~Bi8-!B4WzJ`6>SCWbc?Ki44uf*$~I#TX|HZ|Mxdm zOE(yDq3I0|PJb$%Xd=zg>Eg-#^(5zq{2afsdXqEraWliS;If*s{pGdu>jhpO&^%U>oo0Ppr;RI%yXyW z|IQ;8G51+`iV|J5HtviH!z+@zH~+ zvB>&^o8C59`x-X})*fdcC;yqnD`4jZG;u1v!375ZWcHA=YPD^w6{u5clV&>|Whob5 z7ran1`cn{2TezBuZYJMri_lPAc-}pyuq{|^OLx*t&>#G8N;l;fcOZhpOukKFQB=f` z1=V@kTeuni`pf)+Qfgla>nUJn`p}_xUs7V8t{Dqct2~H8d@)oVh@4H04Nu9_sHXId z;9@`e5wb(tTWB<|m)ofIK8$mq1zZKfsQPc9HJ8cBz%x!gcZ$nmYca<1j4BKA|JqU~ zYTVoxOQqsm0&HThO!h7t7P-+RLyqZkTMz;?n7C2@5k^*+O3PM!2DitLNbJ?OVY zKCxZdVDd7ve)3UN4BKzq9ruWfYUjrf;uT?9Y7zuf*Q_8vTfOy_OH~HN#r4vhy+iM) z6M`Xpk9Idywb&wDXr%%i_Tn~glK5_iI+(f;V}oVPW`{ZvFX`4@`cW9bAqgRf=stH2 zeJQHUQ0C6RHRouwZ;Vcht3|mdM{+bIWNefv zwA|Dkj^}{@BPV#%sL5CiLdh<>-O4{fV7op;X%#)77T zo(=qAM4NHwS1NN-jF-^t&Vo10tW+JLG>7iO(NyDzvkl08Xw(*_<5Fo+6^sV<%alP{ zE!VjlyB7ODLdZspJSa5s6&SQse3iWAU_SZ$5$~PXxh&KV>q^*BUW0uPQ$k|^*4?>* zx!nielEqUqgj+IG-`B?L%m$ffn6zq~@cEye1x0?R;x2R^qPNYtH-FEH03p{r=Fh6V zU4>EUwIno?3so}$q#*wRmrPP)Rqj(;co{2bzvLi~*$EISa2MP;d)M-*ytnmNr$rkb z&61%e>bs&c(#v5`w!j$`3157S$3y&DW8U7PKpUqrx3`%gsk$te&uGwVihMkQ#FnCI zGdt{kMM}^8Y5^12>&NoVnW|S>kQe!Xg~PapF@NAnq)k%wx}IgevXsOHcTAx`uVYCG zQnrI(uE(P4baO)RmYVe)+_E{F$q`r1p-154V{O?T#mZp6!_CuUOf!yTg3eK7)3-U6LzEbTYW1wQ zm}nW2A0a5)76LPArDRlk8~xnkCJRm)2&TSZCz)&aju=doN>=fNEcn`^u!!f5&o-5R z2IE@b^p%;u;#Zv4Po2t;ny!`ZMKFVDC|!1(jfrv>p(nu0wJfx(j2MWZMEQfL@8@LM zL_NOFlVU)j{=Vilg%glhpJi0Hgugp=2J2YIP52?7&6I6Lz;#PE+E~a+zbsGEv-vOu z@1V3>MW?kB+rnfR9{(2sa=A`iQyfdenXR$jc`Nz&?AvdizBf;JW4RwUo#1=ae$sGj z(6*FnlC2C=?+gyi^fC7c_R0GZ`pz{+BaPkg9Csz1;bhEK#zR=@Z&;LUp?xv8#=SPq zeWa^Vv^VC3R=WXzmJV#Rb7v3P!B)5G7X#^_n_jup0Kr_lj#nYxi{F+W1*foo;Mc;q z^y4zrNL(jehkD_1gf{L%z+8z0D?@=_3M@)k#1d1BSG``* zc7MYt-LXV?(jqRxDEhZWOQp~o7@ZNC2=qc_SL=`NR6}~|tknu)$S!0q_2m7<5{RQn z6W}t#-Cyc1R(??Vg(ME>f={Vd2tJQje1jbm)S>gNNq(lJ#Jn63&@WEK|I-GfC-?qkTe{M}CutzKMo17UT~KkB zvjKd{>YMOIlus7@LIonR1~Gffp~*D#dz}6Kf3-Wq5oRQbXV(|yRuY1|yDrv4Q#!RD zv5s>olJLu&C8?8!p;$8wZZTc&t!u^0xT?p)mCA_lK%H?}S`gT8`@KqdF~^{LGH+U7e_&{5IgG+ zgM+3y0*oEGe!K^iLS|1A>!l^)U_WDt7IGULDVx|-D1m`>k7!Dsv(y@vf^J~XSc~UU zR%X`f0~$t9{afuDeLEYcpR(3tE`gy6yt!2IYWJ6MVOwj*jWHa{O*kl#e7?bSy$36~ zcar_EhLU_IO+m9c>Osj#x^O9v0KcE5g?sK64heqzuKw(>4k`x^?&tILMxkge0sqoC zUm^DTi#G?&o`KU#B~GNF*9!|}#AKQtqSW*He{K%0&84CO9@dbLKOA0AxkWyEM5$7ouA#wXk1j7Ff+ zyrvS(?iIbIf;HIKjOQoN{6BQL z=cCW^qN#pIuKBQwA>XD&mb8`Mh~ncbSRSQn>xUoMjx3i9gUaqB_yUBU*v_s+_hc!3DJp1F1*huSZM> z)F}UBh|Zv>5KQqeK^_sZ%AP*V-3Qz{!yeu!2f(+rX=hVVDqLN*;y7G1%$ViV&7@5X zp^AOhZvAX3jT2%Cke0o-*U$^VxA+&SQ!<1E7W1YXHhz1IZP$CC-mB?Z_-9inJz@N{JvVl&Nww{M@){8roPp*cz?@A`5|CKVsoU<= zYEH%rJ{kh$xP?BuJeXTIK!`$-L@?=MO~P?;>J1#RDWB1tgd*OHRr}e1mEq;r$CvX$ z-ns7^7u{5fsQ_Gc1N9Ev6Ss_i?bzvAQ*9=eG7}jwkiPMNo~Hy= zVa-be1@vZsJ7bs;f$vyu!My@b-o$U(FIpDer8fuSUEPs9%IOD(8Se`di1v>>b5;+5 zaz;8eijAqKaD z&~XQce#CfCRV2%~!?Vi-nSk`RRW)0PjE}r}X27H+zM~Qs!;0lD!v1cF>5rm%S73+QMH;ESlC}u4+G6l#rd&p%iMU`Szw;D4=}ROJ+=$z$O@_a5qxcJF+l4lAtYt_5Ey8CRW~cnUGb#RITB6vNkVJTKek6veCi zMcN|6gmB!3)NGM29bGFuHL`)vDWI#>eXxiN9C8M=r^qO!mm4QDRhgo?JQeoiCaUDs zgkD3(u+SF1-P;Dk>RJLfmvyg_ma(x>wdX_e*rK=NV54K?Co%0VK3>z(S;Ha2TxsnX zX_<%`;YMU-<*(vKtcq)0i@AgRSax}{vMTySCy{(IVdAjZ!Hu1>7#;U0pVQ^N;z^_v zX{60!{T#c%M2*FNa6T{*KVo!w`b1P0*ALZV7>kn9^tN+&O=$}@$$IkaVY!4@Q*}TG zdGo80EaeGG&1vNE{^7dfrRoOoBzM;l199zfbsAQe7Er_-YHV}2Y^HYKk8FW}Rw;48 zhejK@UBV3pcdEBkZWgADKD(RP74qS$CQDZTPi4LtJtx2O^%ss+$$^gYI6DvPXZln~ zmS~B{ZgiExUBYcQB#>Ff?>*l@{M45&t&?M_;P%@|9oD!k%ub}x%v`t1+vGty1_Vrc z3>WO>Z8I9O(9CN=|2q3aMV$$V)DnN~VhoZbOx^Kz2}&SARn&iKMI)~h`@Zt=@N+wA?rGI}ubU-V}} zlf@n}iEh7&1B^f5=;MwyrpLRykDBnIK;fE1U3qoH1Q~abN|REvi#9y{yV>u_MA9?+ zpa@L>zTLO^MXYXBP!1+w%y@EysL9)n@XB654*0{q`eNX%hv7R(y(7Iu5Mtcnrj}6e zwkXU%4LL=4Fl$r38#zP=wvM7;u;>z7M>!x!-&DWNzUUfcBt};&8}FSJQ$4 z*kDZ$hAKRofRc$Jp-U41yl^$gNnjj-zlu0=0G~pfDqR^ z9Y#|^^H1k?lwmn}&P#kPej7#}5ytT4s{{+>rhGN?n4e0C?eoP1l!@{(FW|Nm)2xq8~h6(=jwk-Nl5zJX(*m$P(<05rw&x%oi`2`;aJbg0bs zm8)1CfsB8DP8hgB_H0L0Pszp;3jc|T@>&(P$QFW!Ey8`d)tIS4ctx!5-T?d^q?h$% zN`E>6M@eL$cgAwn(0kfFp<>d1Z_fzZOmb4pv~;*xNHynQw~-yFq2YCf9V|qgHtU9o zO%^-RC=2DQyWSPVZeZM416yBFLRG)AY3)q%8L^#_Z>-KWRJ$;$DnKYP^xE<(^w*xc zWS{>}Kyqo5K#@M^`~Vds4cO#f8j-eB5MbRx!ZV`1bA_%uN|wetlLc?q=7Hp|-Q>)d+niO6MmVmlv-i6c454CsA&Xf>`o-^DOO2c)C`}-`0MT&^=kI z$DHB6QH=f8}(q(#xRLH+KwUFf91?fzt@Mnl#Vc zq}T<=rc0HXh>^Y4C@sRdJ-D)mU(b1#5p0AGr>A#aG!&THFAnhUu3spxhQ&oI-E2w^yNrxRROckX+l zC+FJ7f$nmzbQeU$k1Nlz@t2O|_Dx!#{}{pRm80Uh)}u>9E;D zEM7$-o3=eOUxzKN6)4necDg}8$*-cI7J^l0Znup6z?G#Mrx$^!e~8yC8yrxki8e#4 zGrS?|U=JsySHB87aeeN!uaWto?%Ug=qqmz45rIjt*{m~6I+FrLyEfp*i-MYOZdnd| zldqcDZN)sxoTsX8ZKwGb6>nVe&rfH6*uDtKUTuI<^C0mu`EuFaqM(k7ni81E`EzML zq}xfyq=@SPS`Zc9bj>{`AK(&PxWvju6p|nIOhzV4mxvV0BN+ssrN(izv7CW&K3dFt zuaq?J6NCh2h>nt41TQaKI(m|Rx!0H>IKH{4t|K$M4aw(a3f3Ku!7VQJkf)|hru!Jn21X(C^GzMF3J*6@Do*oLBy_k4 zlEQT|uTeUtN$QoHrY#P;zGoE4jLB*5*$36}Gn^<@0 ztrZwH!a}}!_uMqtw+>mpG8wQ|T1E^h4x_naiVy{nJ>bUWcn-4WC(rQq%MuVn~|WsmTTh7;e!K29mky%RZmn5hy%@45>Y zJpbK%f>{QNvaNLiQ<|z-H+;?M#VW*JZ`Q%e9^k?n)K*GO=RoSo>l+mCMW^A49{Yhx z!s7&~KF0pm$5))`Yj-}QX~}k6+Qx3| z-`qgZ-U(Vh8e+5|VX;<-@`tE?vt zsb*{_O7I|Ll8!=aB^Ru(GD1-~d}~kbU0DJR$bw-%J*1(6T&bG;&g0$C|IJ7)uhs{a z({7@VV(hwEjJMpU`{Q^DNM&QewAdE_U5Rd-));BiDe?Z^)~>OKNOBosbVSg&{IPy% zoN``$g58PJXKv~TD45hBTow9fQoV0ht;NK&A!Mj`Dc}DDNAS=~aVqI(QTgvrgehcP z?kgZh0t}Qt*?(T2j^MwcgNvV_t#%=+a>CQ3E+*H&2Km22r8H44sSOHh>>OIwoT}Ju zhb_G=m4ETIc%>QU*q-q(C-nb;0U%k}r>(-*5$E@lnDA^wg=aV~{oPD zo0h7=4}p$r@2u~x*zxP;NkmHn7le3wr1}V_I_Hf4D14VBIM-aR(c{&a(|NXWl6L>V zc)#YA4IyfRO`lijUK5+dVhI8C)w0bW#(_@hEVTOMY}~}SGgEvJQ0qx&TrPub#aGP< zR(v2=vSDQ$&)TW8JU~$E=O(no`l8YQ|Gx^s0i{#byKKq?;&IuyYO-l)uG5neg|}fh zkDa=e^ZV+q5a{%&*Y{inF%Fd1_L#cg#!uE_j>CQ)U|Y%>?+rDTkLFHD1v^mNybA2> z5(q+nw2WY$!8Fm59*X_MebP%(W$ZJ!{1T8G6?XH-qL!uhM6nbQB#yO{;=s41FJY&X zSN?%Q!|g!K*^yYZGYLkuH)NF;$=gnWl~g{!7B9*3k{(s8))0NVcXg=yTK^~c{eolnJl`6#g^*r|0n?n z2DRRM*oVnJdHTCPl`xQ7PJQ=M_$U2yE;P`@i!|0oWB)VTM0-gP_qF!{>7qo0K#)#} z!0+Z;P93o$PT{qr?T1Z|yC4@(%R|tVD3hkDBc*=!qhAAA#q{b~jF(hH_h@Uck}FNo z(OIGEmFEcgNCfqkQhlNp^w8^=jVns7z7E4nR(J_PfnrIZ795i2FFfC{-G^-qh}v(l z#3yB7wo*7#hboT%xC!-kSqQLd?)^f>)*>`%d^>2*0yt@qC4KiLY@>9k&@nW69RK-6 zNuays>c#4KrlpZkQ3AIO@Ya%0K+28Xo|-ZENONAbk)09637Vk)eI%#RFB zHy>LoXN^K68vAdKc`8w*FM*sEXhPnKF2?A!Y2PZ>RtIhqtr#e~FIe$Q`d8;+oLfKE zAitDDqlg1|aDcBzR&3L25iQy|u1o2Q0;HS1P_c?Nr1HkbXmpcn;8ds;Z(iNrdlIl~ z)0c;x_yS4m1V7TR3&DjgS6+C$nX?KD$X5eD@=-?Q7DE@N{PdxRtgEZROM)kaZFLJ_!BXcMPsHyU0; zxk>}`CEv3WD+0T+Nd{$}T639KB{g(8q(TvoyRtC+{`ji*6bS+&zP3gZUj;6pl!vAw z@3K_GJrWAUa}b8}!Xh-0LAT2%7NIxBMNfiD)ezH@J^=?^l%dgKuUyNeL;u%!%}kDs zk45dK82NHF*Tud0eWyElDI*keMl_<}DSC|&%IPASX3*O%i_WKMzG-dOD|Tcaj*p_) zsv*RW!bdjag$7Fdw5Yuj1~Cl(eO0C{k44I%#joRM^@rh5EqRyGn3z*vW-g+a`fQhY zqEPlLEK$`=#-)I$nVs3x+b>WunCEczO!y@nKPpfvsa-;?N>C7p49 za~;*-PPcyqa(6K(NK{|>Me!TnbJMx|buibfvjniiOEp4tr0S&n+G-aOe}*wsCz5c! z#`*iUzf`EQOR2<43@A1_eV@gN&5iwOoT=2zBu~A%U!YWL5lt5^h4tMOa2kU%gFB*r zgiJiqBU+%O^=tLDP%w!O&Bg`GpxR`ACYMF?W%i5)9_ZCh$|(#~k#Ikf&Zv-B`hTp0 zk<6sY65nMwzaDLUqN=)YzXxttGgp%y@Y8MaedpD@A!=-J19Y(2>QK$+j_ohM=M^kW zCI@$=ZL>6Xf>HH<@PQ zn8`~tLIt!NYE6X|f`hyAcn>6AIdZha*R#IlDvl@k-7zl~pu)YlUCqLlD*$w2xZBk5 zF!Z@)Dtc>>CP4Mcz%Ow_Q-t_d3xv6tsE2ylS)SI_-1Bxzi}J<{n*0UYLcU&PfXPdc zPPBTBQ)1K6ZhydDH1A9NONrTaz76?ie%Ql(uAk}=!-fwQnc&p_8Cu3eD7o_}-S17B z_C2EgY-@yc1?bXCJS&fFs|E@BOWM5z;692(hp)Z8#($uc!$p-306Ki9uk!|vZKfuh z@1AN=Fdc{giOiC7jq1NjAnAAA60lJ;kf$!O19rjGgB+N2{j6*GQecjYo2b_eK_mx1 zU4aLn%#2U~?9BD)`}T5jCa`Yb0p~II_Jf&G2^kU*7bJ-)m8_XgpuNc`&_E$`;X2ed zK#Nx0oa`U^9Wv=cVL7*LbpgM|WjXQeG5KPU1x1(DD!nA{y?P}zWL7oE*_2t#t3E?519?`V@-bx1s$W6=e>$vxM3D z+>jpQF5HCQ1_TJEUYt7RH;eA(Qoqu#t;*Um%=g-#RANZ5Fgf9t5Obz>lr>V(qBPA~hS#XAoYEimk|GbOiv)9K2jBf5()~ zqw3^gq4>B5Acu-^I9K4?nzt9q(mE92+Lj@E*78*}vjwCUOp!`*reQc6ko8uK6Fw?d zr3hk5u!4O4$cCM3B&xeRAlYZ4W^jaUe5l{?eIFmji?^FYE_7m52sjHuW{@kZY@@pKwb%s>?tqL)T>>apZfZS z4%{kmK8%cPU(O3o0@j0xA}gZ#(_*8!(H;pDS8;qnD<@R$l|dU7n*V{pKi=9o7b`pb zn_*?S_BAe`(SYOqw*^la1TqaYr0osz_gxg)=^EE+dm(s)UDqvrRV3hW^f$!1^ZE3k1hf@~7|39!o`V{Yb_SNmJVdiz>N?0! zkG~k|THfZqnOTmL=0+X5F~5?J6HIzxU6^hubF;(ZaxV1*d3@|2dkmUrY-m-ZDqZmJ z{Kfx{$NZEJOiG3YA9y~rX&4X(bjYX&_+Cz?`8N$5hotIIe|86iXf!%nOoE?kSJ;z(vT`vTHy4i+HDYQ1 zTZVK8&jDdy12!XY(m5>=eQ9>m=S-vsGGEyO+pg(>#MFaYqv$!1_5Lviy22QaS-Qf{ z61n?heKb$y{mS(Cgb{MP>9e%lZWxtF^Wij#@e_2~c1%csXc07Zsrluq1W+LdFS316+%qGsA zc{CN*zAPsuJ6Z@KmxcQ z)o;8yYS!i69tpT#?Icm6t0wC7V|;!i`5T+gF?q+dNDtBVA}uG!CZBxk7xp3fKD6Vf zq<&q{A}UIP-sToZ#KL)NI0vbyP)AT9J(%+8HBLgub>Y4qWx~o)qMyJ)8ti|7t*6~S z!^{gE1rivoM%=OzIxZV|9rdlaJzyo?gLMe|)2rK}z`rvl1o0!E!Eh9G+6N1x^ie!F{o41743|<4&W(%YuJA zv4-OpoNYoezM|bSC~)SyX@B0>WBB+zN?c1Gv9l(yM<0k=WR?G+NMPf&xZGcziIM5K zR-XLSXB8GRnw^mEjV~07Ml&J{Mw^udBXBDp!Wr1nZJrb@&hRf*!E4b2D;^aQM*Fk{ z;kn0ps+4(>kX20V78l5CSjRYw)OcDKimh~1<(@f^WdRzlHGK;9Y3yH4Ii@m4aUv`qq&%yt$3cu2G>|yPU0lFRy<~%Vy zCqQE@avVWlln5<%n%n385f0C|61;OzSwLu|OEqmc3X&*u`y{M_dRopF)?j~g3T#mSj%(BSIr_xXt?*Ge%rwT~d^JnnZ9;tcepb~_Uzf$r9-l>@7KAl6h{fC`_A zPZ=DB<&o;L0BcueSuk$&J_ERXxYNipf9wRQc@!JxM%8YdZvoiB3prd6$&0VoE#04| z6Fi5=3F5w4CL30bHj!y`cIl-c^ zwge8{868d8Vs*y_a9TSnLB1ey~moV*N`hQ`0{$nTGscZUz%qEKl@#>;D=xlUQ$dDA-1Ls}%EkkPewPTXp z$Q=BvUG#kX)1mP@CzE+^IoozAhj)Xty-wcf3AWM;A4#8!~Q*H-w{j7=yaOZh z0n!%FZT@)5c0-LWujzrO8IPbPF99C$1F%@1cDBCobH1Y-;U5Zhdkdv5tygx~6`nA) zQE8C1{$6Z8&%2tv_rKuR|AJZjfnr>8b6g|p`y)Ku%!JWvA&>#!2r(e9RsMIt6O4*u z*kR$mp)R|!gXc{2rw}yVlGapjYGE45Prpyg^)Z$=key2pRA2bhZgl0mhNrB5x+;s@ zSyOns7%DJCTrOBn7Q9qSFriCN3^bl$rI(`CQA{g9ewx~1T2fDHGRjI_ryDkk@B$nf zVTpspyJ(-r5#7bx(p2jzVj%? z<=FbqLHM|%88rwtH5Ggu6d6;2T~bZrRL=MFPtr{4Ue!Y4#I&CZo7K6g`gr4Qp3=^q zN_&CT3!Q9Wd#X0K?<78}`QPUhoU=EoK{qDrI5l zS+K`!KV3xu)y$#4%*HgTe`nA$HC>eX0Y8acj2Qn##t%6Gb}I+`q>a2|Tg&47vBh{R zn`UWC84@)fBZZQ$3kr~wkVAH{BN1HggEnHs%Itzzb%>-Q7T_Q=!e{6%+1pFc^XZjb z$>r;L5huZjlx!FgxGV_N*_77YzS-CRE5)VHlAhWAjz*tJ1)R)~ih~V!qfh&H={9i_ zEpGIs1F#*PZE1QCV$4beyK-eEaJ|c)22rC`dJ?9o0l9WVt@I})IeRFF)M49j8P@j6 z?t!8M9+zYiht3w-%MYDYLNP{v&H(^~7{BR#J45+5@ykxRwG$`1{HC`(qew_kMeX3V zef-le&d1*<4Rm-#ud>BWt z=J)xqY6;#F*kX|coq=}7F9JxxM+N@>{$`4g#)Xo$Efd7={20WTZK2#m4b7#=6p!kYz0B6#of zfu>S#f3)M`HhCRuv_-3}ba`H4VHvb+K$x2ELRXL6E8Zr75eCsRc>VIp1RVp#8hokI zhBBb`qeF|7hJWC@?u#)QtF9sSOes{hXRkT|F&>A8tp@+siif*7s-9G8DG-Sq6fl)` zgHaK0wK8gJX7k>UtJA%vrGD7#O84J$8vrcw?+Fux4Hk<Y7nn*2Yq zRd?$%w2bTcP04-8?y!1&!d$Xk8W&A99yMg2MIpHCG0V2X-I2pKGNZWpB9|{iN1m|~ zk4Tqa^6-sBSg()9kWz^R+8um-yteAso{>H-5z(Sv*hQS zjh%zwcO5)1EZR!j+;YjfQP6+zcAHYengS=uwn#8~=`HfF*Fo5)wo+D2t`kkfDR{@A zK8^Z2Iz;?v=7ev;J^&zl!&+@NH%{08sq%x9Fq7FZA!XqRH+o;hd;5*6r-LMQlA50$ zfrM;{6QH$kUyMiFh&Wro?GpnncpS))-|gG2h8 z>$1Kljuq+2r6=y&;QPAJ@AH3XXM>r_Am(-KfBtnI31a6dgL>mfU5$Lfz)GkVV&@<7 zqI`F{1L_{=K66lr>Y^c10wrZ|M$DTv1L1NRjsB|(%Mn@2whZNw(vm0LEAv}$z6c#A zLAoSm$;ZT#D@OZ{)eBn6%-|4S z#jahB(0}GNYNa;QTB-QTKU=EdLoZdqq+{1IOKVH|DCK>F`;HmqNstSI2q@Z3c%=W= zpJc@8jdnN>QTi?G4FQ!6O~aO#zy`h;&(3=Rac-#dGuJDqo!H zxb^SPA({D1sC1+SD}<&s9{d#UAX6rycwFK^4)oHAQ@rjHsEb03>M-RW%NB zXvW6h>NLN=df>hz`14wjIQw}mUKnS3nV$`E5_;}S_@&JQ)2vK*b(~yTdJSc9|5&kf z(Z!7C@=!XB1E8{e_JjSj16gZe*DuiX*fuD8Y0z+|>-xH4anVw$MiPIikGP+bq)OYE zjq=qTsQ`J#+(6d_Z|&LbqFgx0g0Vj%O|}l46wRsC2(hVRnW*s9_)}=xHr!RYy~q3~ zjIP@A<{7a(ddu&p2oQPdBMp?D4ughpN3$3-`%_ZljEWorZfWIT0^^#y8?g&o=9aIo zz}El&OkFL!J<7vd5H&^3zWGh73B#*Q`KlcIl6P$uJiu;`L3rn475M*`n~h+fN+

z&Rg@jyst5dX#mvIq3 zEAkGGqlrn9Z(*BAp`>C$Na188^hG1e`PV?8_r!e%9DG4QR-YpR=mJojj4^i-LV_`e z2*s1h4k??)I9(ASj5P6Ssx1e>(&j}X!#qdB49Fu`D5fToDK4y@^!=c2CoO%w#E(f?V>pQq#EW`@ zC7?M0I;`+4KPOlLWha{0aCGThS76I9fU#gwWwURWxX zEnxle{XU{{0kAz|L{UIS<%eKF=iJrBaUw*eiKv2Yq*P2!4|Hu<4XD7cPo6{^Jr}mA zotmbLJsR+3VW^~<63ehWp+~OG*JQrIjKHZ{7RMt_S**?1-Oy$F1_6nvP`*XzSZxIH z4O?hgI8@SXh1WnxDpf*GF^H2@J7$~-O?am>6)UfH{e)1&BY)913EF-E1Oz1MC~^;7 z9H^wTWGoRcF`x>GQ$T=}M7ORvmPzSpA9PDThTOQNT6G8J1bA^SimVev%cacNT2s(l znf{xiN_-Wd!CNGXWj4DbbIBAqq1kp|+PLQBpopcDobj*uSD0w9Nj_Qn49=;RneZ{C zg5v`b>OvBL;!=h^geC`ok(s~nGYg2^G=>m0k9n-D7sFA;ZV;7(O%UT^2I6c38f2oK zO6P%zDEyi;iS(iXoq?NIRW#p2+F}l3LcA`!zPY|90SBe+r3^rGi{U82;;2fE2}CVe z(ZotLPcz4wX>S9bn$$d!qt;YT=4!|Feys)Mr)~odr$~qIul*4e9F__Iwq6>l1OTVV{ zWezMsA~bJ$xA8$ja`5A70G4 z=R*R}(osxJuZ7@df9C}`V2}f@ecNABK!se1`Q$^@M6!yZ#MbN$0&=b%tFu1tw|~|K zRV-9SB&KU@P1eM3i7wj?u|rM(CMeK9(X0U)?67Yt(?U)yMiS8ga;W=Asy|2c7<%gv z=EQ%ZozXAZvbX6qlD3}CP%0Bg6PIwNE8z0N_}2YzZxF`eh!8U{X>02)mD=#f!ezX~O8|PAUOnv$Bmpa2&Q?^Ilpl^E$gTDYyaZDx z5JA@cO=cpz^kix!8E&`~HVq@}5+V;?+j~u2_IokmsKQjN!e?nHQ#sGT|fkh#wkj|RQjR_Qz0D5LnQBW5I=qEAbzI?uk&~_@mCuS0+EaOI0QJHIi8|iw_xLv1uU`x;e`_eDpY75@y0={M)juQ%ScnwpzHEQQ-O9O} zD8sc%O6YBuwFydr$80$cQlqhw?AH8?h)}W|ZMulWbizh*lAosuoPsp02(=1_<4z)y zm|$=lBxyQh{4Zl;NPr*)Pf{$hBv{m+N<=Z^GV^w>1W#m@gn}iC0g`M9-u#mJryOSP z4$eSZ#gA@i^ zR5F;P5JF`}sw^AEsW4Hqaia3I%5;#*s0PA~MgiO`&g{JyzArKeJB?~C!bTqu< z4}C;A3BVe9!s`ZuVpf@-lsS-Pk_(8Mn*^_oJv`X9FG=j7B>C(H6S)E)zEhU6$#DMr z!HhGgrG`6-`+N$$%cC2>@CX%*N5;WLAN4mxklUTc9yEBzpz2)iO&-09k`FmK$<8 zXy_x!^%WH8ApsU@h4x?B2;jnC3xV01xML(<-a082R)zYZAWX{<-5A+yMH zNWi9ipD@rT#2MsaSQxtPo${6A4#L6f;dhSKg2u7_C|cpOCjQU>=H~{da{}#Xeb~&2?WC zP=z#oz{1|dM7`=ZBc~NfCK@*oR{GVGVd`0PjMmrXE_OQl3`Y+&wGN;s@%-WLInq*& z#@wX~C`U@Pz4;f`GoF%()bNGvL8JtBme90x*2F3_AFJHJXJk_hl}dA_mI;SWV4h$! z-G3%UwOi|0s61~8`I3=G(Um#DHiLW)*cS|Ca9(Xhz4 zkT78C{+_b*pKtokQIh1D>u?XxdodEh_oS;Nc)3`@<4 z{hE0d^bV*xVbxAB4qMz`CpU0HEUT(;BEF>r*rpf>0NR>I4Wfa7#W9zVrUmrF9>89SqU@>jz%l!|E0@GeBiKQ*hXJO=oN#C0}hh@jJ-VtUg2lJoH4}> znwoZBXDK>tpD6*P#hB8%4FfQbMZmO*;%$I-{qiQn*pLPwA5|)NH`&>z(sOZ;K;5}?2&TKM?Ev|Mo&X1 zHuWyh@&}o(gT+`v{W8^eZU7=7x_`6)hu9WJB7Y?j{tN^Q^ub76uuKcRdd)w(D$$j` z*4rw-94D{>ww$r7H-_fG4=1p$Y{m!>J_(h4@+N4_ zje^tkOgRZcHl6;@m9Soe^W*Jh~5tp?;>M#0s?+gge}#Q;lEwaiQ`!v-Q*q7mr) zSR#slU5tY`@e35G(wHuu0n~uhv839{R~0*u#cIv>LUI_5q7D(3e9NXN_Z>yW$?=L2 z8AZq>QtmCmc%Uq(JAHy7T zDfA$cr7U=Q2u$oiTK~Uz!q;go?A48O+W~@(va>|Yl-oc-oGAuXLpTbFG;E_Wh607q zp=fIKb-husMT`$KDXU=Y2i|x~NXQ>T*bMylUx74j8Z~Ifh66Skz@r5eoLp z18TdK5elScuUtJut5Wl$;Vx2mSQrKjx4n+Yj!`3^GiHCeKv$*d=w{_&ujqmruL z6ENa*P)i8m*1XRJ1G{*hE|iQlOf0uR5D+kor;_Y5WphId_m1_Sf~E}sXsi+9geOg1 z;-1+}mOcvA)w`C!kV$EtYX+K?DF?vt#yLNns{q(B{ow}`Yq?r>3G05oG$&MLZNk}f zC=qW&#;77FGX#63-1cx4V2jswb`s8d09ZA+ojZakS-JJQ&R|_l%Q^WL)GOo!?$|&{CVDeY2^{Z?CO4z7 zGJP60o9bwL4LB`g&3ae)GUmY*D+=ul8cSFiT-s*LwWwb4Zv}Em7+63N9@GgP#5nkQ$(NTv|%) zQAF4+5!nwxZWvkDKOi%`sys)An zZlq0y`<*qL1}Pry%OJMo51QGvQSXCS=`RG%%oZi6=||xR9CyL%orSH)(^ff^YO;g# zix8pp+KL76s6#s5Gb`*HlC`jD(f4Gf88c|m*VInkb!QA?X_-l*JuEmj@t)b-phxA} zIAE|XIi;NFErUQ0!CF|N@W2iL5ziU;u(@B+!mteC3K3Fk_%3e=*O`}^$Csi|G5ShM zpM})f5k%wtEr%W%;epnD5Ur~YMKFl4aN?Ny%MwS~B8GT^!|&g%!`~Pwwex|mud4_kE=htjlFqIaj| zhBlOmL9}cEvEU<=zkIMjgLI0ZzK`>C0Ey0BHN{#R5$q5)_n-6nOXy-Mx@JTU!{+;5 z3|3MK6AAZ`@Q$dko=N&szzwYPItYWXmJVbM@JcEL!iYxeXl+XbBqgq`uzZo&>vWJvZAe2pKB7s^$XT0VQ(;UEZy(`Y z`?~^uA{A!yoBuS@fTiKVG-Yf1X*5t!O;#=fs%ld@f?1xhS?NRbH)fdP{T*O z_=6&Hasc+R*z#v34f95ak_}mrgVI`N?|~~PmjsjXcjcU3cCMrY?&$i80n`_Tb-rGy zN#sD7cS?;JB9i@8Z+!v=Muee&f=Y@zC=p!Pa3K13%4)0{o)WNwm=MyZ%Cw7}&?G*v zg2&+uC|F-)gEUnL@-!tDHu)UO2<;Ls5~+*%GKR{kv6(sG z;_jP-ki^x>tbwo5u8bH{Qf9CocdpbBL*@}TpTB9xB8MRt*s!=c<)~j^_+{&R4?sWEUuM3o z$YPiR`w0G^?KF@Y^1@(7TM(>C(j@5=okqKf!m;(epeQLbG;z+!4|@(06hEND{b4#5 z-D?QRkE4YALjkJf1QLhf0oy4`!AM7t_87uGaaBA6CxR$i`wf;Gbe(pQLm1kBR6fiL z5CMNbyRO2q1`YfPkHcsO2&IJzi`Eh7Wn1yCVzEpUi~w;sDPO*9DReWiocOyC4~p8) z_hJTZ&xmJ;w(b_gq(>#{P@`Z^sBz$gcQD8HxGq60zbS;9L5O`<#Mo^q$KVP)Sa68i zh{h!gji@j!SanoEpuFMWGwXo?ZW&M#(mxv%u0Dhoj2@pwDrFXv@K2iL2{aAhhj0`5 zK&{ZkZUxp56;9aFwSveN^K3s?3hp^G&G^C~QbKSH8YY_b7h5(N2Wi-J#gvq=pHli; zC!S>CTN6-WREd>pJa)l^Cp2~oS~H9a%rpsQ^VK-^g3H$TL{W?>oFv*P<4qG81Bhld zIj22!6I_PF`DB|9kDDND{>qaDdJ#^+IA>+lAP$gpGx0JqV$u?Xl8`cOraD+N2nLYQ z-XWS*M9R+8$<+>}qY??S{hc~%n+KLX&|KbgX%X=_Xbh6)7O^!b)L#7q`hin~`6h`F zsws>CnxL_K15@fK=uWg@>oZqD5a*mc6#-w2l+Z|r4d0-G=OR^d=YlA5l9=$7fai1< zYNBd6NchcJqtGb0W;+*R0Y}v(NwMu`_d(gMQ&Y+gW`nR|+R909*lkz`orQl=YnBZt zGcCWYJ7Bfzuwx1qWtEiYL!y9o{UgdEOayVViJQt$fPA!=-kvDEOFB_L!NSQ{iaZcS z#G$C=-VG%Sha1ttnM)+5Za8Ec_1&Bzwd}A)$(?{UjeiYijcd6T37S>j*Rb?UQnrNp zu+AxBJCKVHl(CD9jWOpsH9L^2p3)?Q z-b6}(wMVT6g9z{vK!qU-)rT6j$gzGRk)3aum8}J)!h%hU3Qr!I5?r^kpie6KCx*)?@xdRo)qZI443jAY%d8c0CkNVXp9Tf}qGK zfKOzSuyV*Ug#t{@<%zRMcrrZVGG?I2yhzPgjk^ey8?ltEBPzs_7}Pz7lnK%f8Os{= zdnls@fp=mMv2Akyg2^T@Xr0l4p%qAEU}EfM(phr^qhVn1*j3u1j9}v{V8G+KL1^By z-58-x5(7`WW)luvpoQu|*#k!(lmcPb6~#DMgQLHi!qJ__Vo=B|%`| za>*?^*-XPuw_&ycUVWd> z?xU5>m}a~@>lWm;51dC>aNPvDNa&V!s0OvLT|?l~2#-q@#a*LsSP>{~wj-p-uyISq z!=$Rs8`8onMXO=aNY$poSx202RINWJ&>^VStbb#Prz6!d5rhv zQ1fwG2+^Q>3|$^OgXK)ZaD=CIs6cfsFx#9q20((T_GM3m>cUUWgXD+2<{(3FVc+3l z?vewH{SWJ&VoBP;^=mCjnu`f1B{mQ`A!LP+uz3Tz9E3KV4;~0OS$PtlBF7Ji&G9oBq==^F(z;h9?|Hi z3k`G;tRXb2uzxCWQf8H<;3-;IbBy0y7d8H$+m7J75LB&Uh4F^;vl%cecFzq>79y&w zBCzH1O-lQY!|VsL&`5t55*8VrpFxx?MmFPy2IB*pW$sMe+OT<(##*~1dIgk+DH{w< z5EPXF(ZUHYIYF?3usFcNonv*$)33|eL=5CJ8XOMGc*v@y>?W#7N_@rp>RqP>@@bS__Uk?GM*Og*#i=J zdmQZ~4lcz|Yq1(rCW_Sikw8&aK%T+mZBvqAwP8VJm-CU$aw%7Ve6W3ehI2urT8dE% z6-ng%gs}k-pi<_6C&C+?wPaTE?;E8xr+iqp-^ z4gG1UqKx(wQZbT(cHvtCHo_|=;E`1iM4*o0#TA58&L%c&e2SAMtV&?kVz^8s*)UH+ zMQo-WOq?Y(ahIkz_6}KGnL?i><<3Gx_{Ou06%9{k69xf}AOgasPyo0}Bo1W{BtX$g zMYXvm)dO!~3U1~3wjE){V)Ilme5xE`pHc}V%~*I;sbLniu_xL@Z8pOIhAzbM0Xag( z!NrQ~HG{**wishm#LWRRd#lo*q7g@>^EDiocSvTneGHRQl3(n<)nni3AG6ov@K2p)wEqt$;6Kw^468r2S)%-}mSn7BS; zcq7o?!~ll`p|1A2C5M-=H*8(R?&vozG#5%as^4!~ni2IciWCFgG#RJBN`jfNMylWf zCz*5Gb)1_rcB3^i?lLS&^u~zjlNjUwCI}_0P+(Y#1jqEXu+)f8crP)Uo(SbiABpW# zg{{Lq{fO3|CT??u?E3=&NxK*)om`y&EqdXGjEV@-a(c6gTpg4E=gXpgm!;5h52CmY zcLugLUVxo+N4W`2h4@MUX*v@w(s?cz8P;YHRk0<8NME$TtM#le&{u~0c4ccuSYRBC zcEUiS0%1YLh#*JILzavNwR5iHtUe?}@hJx;Rf31Gs5924bmVAcb@hlf1hR)l;;biQ zIIa_ovo&N@fV^E$s)hhc*CF{-_pCZ7j`@nh#W{2N+a@itq1q{%Gcq-B6|7LSO(i9E zK~@=|kStAS*_OMJrzNQ}=b9wsO4wLXkjPvnzIw3k3f?&&qL&t+Ws4g}aW=>5XC!XW zg6ym>CT!AAV(1F%=`KJj&}iOvCK*O)c4=1%9$zyT%xPKE{b3LTk%Zw+#JvF0OI8pH ziV6@k=^_fxP(&Dw@MgkjgnmU`N8m5mWu@9!kZ@`qO$_h^3S^o0s@Z#2m)5u;lRdGNO10zC^B0Y zux&1Mo3$L{%q4wk)VKO(!|^8cqkK_4vZ~6A#}vzXZ4~rF&qO+lo9GaOk%foqj~oci zki5_c@)VdX4{#W)a|g&QWK`c0f=h}%?AMHRN)~?liZYjRmH+e>q({y6PeIS z1sK30$LL8TfcTB;sLx^yLKcC)1eMXiO{RmQaOe+pF5+7<2hhh?T81e*|jsfwF47*|oaubu1F$PgmPON36Sy^c*JrLEAqGeu( zc3p%m7R3fmLs{`WP>vD`>_De`D_KWaiRrD6u>Tn2z3HSFI(rIyfUG!f##wLJrA918 zTBc_OlBX@Wicu=nUd1fj%>1yU^ZrbBbg<^poT$i#mMtW>b=r)vmPLq53d4&rp<2dF zd#x*t$=AY2Y&&JwbH=8@0S&*fMIF>dHzK z={tca3;cFQIgVwMS6Hu#<_A` zJdcb+d0UGeMUkCGSXqg#Gq9*xU17woGc!Lkk0$`ZG(i5uDG##_#STe|@QZ>F>zo=LgQnYpCEr2#>=6<4e_EiJv ztU6nW5{nFaizS03$z+^4tGp$JCYj{z23rWoDgg02m{jyx3jXqpq2F907MP>Wnmw}e^S|_4@+36%{VO;P~`Ct%haRJu-~$t z#Z18W96d(3qc%;OVI3lpwlo8%&zpD7o-)Ch5UyaEg`H%u_AaK2O(T+k(TjC@SX&+bY60Zn$=z z4agYgjySW;rn7*FxS88Iaa-mH)*@zNH+A0K$w>qy^bX1BOuykYw79B67d&?fW#x3F-%6Ze`0M?m&I94%16Ui zD3oIq+CO-W65oEs`2?ZpDj_oOvpG@Dl!4(bPyLV+}pYTm9h z%@oL~%L*qgY%!jLF-3&wh+9S?FRl!d=N8IuC9&^p2uaTsl6>c33<)K>i3OuDcfFz< z{-9}ajRypza$KA`DafCuG`17_C>R9RR@pi!N}E9jWX;U-XF}rOmNTQG3LTDglqOMU z${63+M)XM4?_w~cI^tPF3A`a@jgq-iHHeeDY%)xa2`FovHAuBAGH1;W*lO86sGca~ zTdL0|Tsnh-8yiXuk?v_%P&o`L?L8H!2uk9}`3A#=u=<})zq?w=on*$>lrL^-;W@`9 zVWK8PIBUWCB&-U@=$v!+D7JQB*@{pllL0A%1kp@fkCOXT(F|FvNIWBN!eyeVCk?F& zm0{jeT#$D39qcb!$_$G;5+4X} z3zi|BI#JoCiJ>>j(0jCUu)ezmkt|}MvgtQsKF7tOXwPYe z(r*dB9JHBCKpr2>7cSFs~Js*Z-i2#Ncbl) zRA|_n;KdEZ0WvH(@N0-y{StRExk=3Nqj&gb5j$wHu4yO z;$!0iAnL46qrEOFh~mQ6CLa2dF#Y3B0D(R-8g|m;g@+^BNFq=p6fTlXJ1(OUKo`(! zPj+HOIw4;J2-R3oSr5RYAu>npV*q;l0Qj&K&E=HZX||!>Is0?2PvmHG2=v`kY}U!Ob}rp0}eL>I;989 QAL|Q1PyhmzAp;0FfSf(p5&!@I literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_win_names_unpack15.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/audio_win_names_unpack15.rar new file mode 100644 index 0000000000000000000000000000000000000000..4070dd5326ed5372b3286ef1b4d9fa1fe72adab6 GIT binary patch literal 42964 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/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 literal 0 HcmV?d00001 diff --git a/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/doc_154_best.rar b/arca-rar/vendor/rars/tests/fixtures/rar15_40/rar154/doc_154_best.rar new file mode 100644 index 0000000000000000000000000000000000000000..6dee0c8780d4625fd9ebe58d2a4d34135f4ed498 GIT binary patch literal 189390 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 T96L>v>nD{0p$2EUdIM_xgkWe?YZ5P=FlIF$ zQ;f(+O%oC{N{!>4s>2_}m_s*=NfnuW#`+dDKdh~2TAa6c=)NOWGNa)T8uzCSF4qH! zMU~*M1XyS4ohT|jrH`(qWz#|-P_xY% z6~@Oj9P7Z_Dt`!ctN6}rHuTVp4^mO>)zMW}XS}GHyWaT88 z>az`y3>8WXfy+B`?PDR%2R6LuSjZofXBXOJ;DycSTrm(F(gRSl6OY$jVa}9Uo%3Rs zeVsa?Aj6$dI+e84F&?w)|C>kqLz)e^2T3Z^-6sld00bBWP<2bF4PI5gZ>>}#gTU$o zYhMtmuJ;;a>|Ms8+n5JjwtHli`~xRx99l^6Tm#2LsVV*qfOsTxHIG^v7B7$}IN}l( zEO{-gphXNTn5~WH`O4(=2X)ew)!KV0h7~p=Y0GhCzq7WKl8yMfHT*E(ViC3e?oa{n z67iPT*I%=@Mif2ce%C}Ii`?isATE2X!8D$zxZP0fXc@j*g|9kB0`1Gg+rQhx!b6XX za5+XQUHg&;x<4KReVd<0qiBcV%qaPRooA-$>5tFY8dc7XW9&E4)gb)El~*S3DPGQj z*vKf)eHp9s+#1SBp15~Z2AkK7!V(cPDps~2J4cIy1_u1?bE>W4FP;L%`vv%J z*YP80zZWgwSskTG;fUJWcyK_Qh5jv;!zB(G63^R9+1?~h4*CLO6kdC@(@*y2$?l7I zqLBs5Ftg;6c#j$G4WaFv3b5gZQtAmFZL^qeVr05I{GH&5zT0D!Vv~mHMaHk)LNr$} z+nYt+avh&_6W5*sWJ>>N>j_`FHIhX1sUKw}5U+DctY5zp;&NCxiHxTr(`|(22zfXe z0i@k7Qzg83fo1>B)M2U#M3&6{OrXr7M=pcSVp;8f+o(#(uO1FlI*1wwl#ANWGc{Xz zO^$7CDkA|w{xmAr@iCnpvHDQhXx+z_Fuj#>rvJ1WxuX-bu5KiBa|zee3{6`4@-B^n zZ8ASQKE&qdwXf4nj8?s3)*%z4D-Ic8Jh%Hz=2B@O%A$^X+N&(0ml4P|yB_to1|%~W zeguGkVjXr7)=o#_ZmL;g^&ta!YDe} zZ3&I~lW&=W`L~~!-Tqm@(~A5ODx1YGE8JbXfP514Bjjvv2Y}NI%82noJ?;v08r&GY z_}9FKijO3b&7-}QyPgMc!XJmKfUsOWScICX&`+uYxE!6(;yhkkP^QrB5fCd92#1R9 zjHqk{-)I{U;4WR4b8bC+!FEnFCrVV6nY$w{54ZG?w8ept2n;<}JJ=$J+u2Q6MB1bD zptTA*?LjfCNV7cV!kwZhEHM5a_|3ef8F2 zjV&u28&V#R^VJL|K`D?R&!!M|oW6guDox(C$zzt*HWV_ zP61B}CshoC`$(Fr*fsi_H&RjVQuJ}GZhNl{Y-a?**R(Y52Fi^O%O^f`KzNfNSy{s} zQv8;xh2ddz=i_t+E`QFt#mSDF36*a;p}r+FX5F{qYPY+@jvKq_6$+dv z40+ z;B(&KwF*a(xcl*g<>*-!p!&VqJQEE|dYa*dW7uk$VQw+qid;V} z{{O=b#zBSHt9%wj|9Xdh=_0yXlarC=-%fHK91+f)pj;y>r%n5BYMd!*>qfmTT~!Cu z!^$>*SxT9Jblz-66F0kVZCU}|uDiUs=TvZ7cW{FbB$VCqPx>w8S?$Tq~nfqwELIwX6mbeeRz_I@arPuKB8rWlR35_gGXdddJ`I>Lu}Lhj2< z>Q`lHhG;&g;ry^=!C_n1OLPRW9ykZb^`OY^>W#Uul zLPe5_Z~e=iFFnp2{TqUdyNu|JhtRELHWJ7#=+CrP`^X|0x3eJqGRmPXm!FUEzafvl zQn-a?omQY5HgkHkREk|nd1TF#Y*Wl8LNB8inU$7d7g&6oV+Eem-_u1mBL7PB)u6)7 z`>*DSVR>=87_jwi1dqRer6CM5vFQjHNi+RiF9%CGU-(@pxaSTS(C9Ard?nTzRDS#u zT+nqlBsLH(2lBSy)JRhf?3Yb;v^a1Y^(u*6CKb1OlXuvD9^DJy$dQ+sh0&9_MPsFa z%WO*A*V~-!p;Mg6tXN-VFZJGGp?hPPwf4?nnQkT4jMeFNc|>vLdn^T0Or~0|!{LiA z!0ma;?FpADdeZoqT4r3l%)FjqhZX zzKk2>jF`LrG~-`YbI3Lwr9R0C=h65#xsE*;L8bZ<$WiDVjqEL2bY8)hjs=rMMI>If zRL*VD9=+}8jbSsmkAd|G*6wX~N6(~cR)A=9$l{VnKs zQ0v!_5~G65=$u6iY7MLCz`)~&lOhO+Y@En-2m5Cv6Ws$f12a(5yN@s3DA!w@_+QDm z?NuKns3B}I+HjCvue)g43D2(YMRuQ=v`?znbGniWtLIE+)jqB6(W3gF)jVQVI4Se? z1fq-}VtX_2-3cTngh6=vZh`EJr1xDVOwLIiM;=MB5PiiXKMMtF6O=TX(iNSH_c&CA zNXi#c`K5dTLgU8$--9Brc%gW5f@l?ugW2(b^~BBvgZ(j{y7)8^v-z~fc|}jYP}vJN zNU*dhYNM%W=CBNRSWQ9Xd5m08g@u~+VdT>9jDF#ld2bX5T+!()l)Sw#ib#}h_inYz zZI%b_&jX;R$Bv`~AVRu>!@JagGY)w-4qNccp4eOc$+Tt0J@0qF82N+ z+KZkfoOkrVn*Q-2ifrMsv-_tZ?7^~cfUT2Z> z7p!RMSHiaUz`#N*Z)!*b3pP+*%Co2IRL7}ih?gKNdnL6j?!r1&2A@dGD}{*N0Gm`Q z(U{)n*>z_W>UGpTmT~agF-w+nwP2!xPs(?I7^?@1A;Jy0h34dnyaK&A>)zYL3t1?T zFmg0khy(B$)ZBLfGwttGwg4s^iVytj@}p0P{qXyG`0>v`QN&9m zAbzTbbrC{a-5ZqBaFgGe4?@Q4X7vttKUtXiO5 z2+bi2-Y}Z3mbI{nyrr&ohoB5v@tU{B3XwHL+;zHE^jb4x^dKWka4+*z@`psC(XwFv zIcJ-l%kMIOuK~?`&43X>Mx;0mkcsD%Blz`HqYO)R2|C%LV*{=FA{f+o_S{#U(VY?$ zJS@6*Fn#{e)cD%Vdr+4y9=xYuI`+B6@?mPyiYnkhPFp$qgTLF#R8lWWNRCe;E57NW za97d}eG+M{1~#McP|oqAdz+qn%1N&j1Na0Fvz>=GIJuNzqIc|NtYvq-O+fUhnw zWcuD4n-d(Ed5*PRMGbqwSh*5VP+Zc$1OvM@QJ0I%!GArBg(+0XGq@?}1wnoAV;xNG zcS`^s`UUSkLsTT<3A8gQI4@Wwa|R~+TgN_yOFS+YJ>}esK3_CAVojv4irHL%v&QK8 zIf1#LR7??50JF+CHoE*p?Ia7y*_zgqezXG)*lc}T!olRP-g#Ku@)Es4pnQsEyb1Ni z!+ij}8uNDWAo*&=+oCk_JNW^UyJrl*wyX$4A^gv_GJ^P=)S}pfZ+$GZ)5sHM*HUeR zt?Y4zwQl6+23p3K3Dez;+YVX{=K-7BLukdjm*}X^emijKQ9O<|yS0?+I{<&uuki)JvVWheOy(j6?*)~n?JHGk*L=+9xs`PH_pHaDPwC@^69HL;6Vte7h&e=L zt(Po|8opfyNRG6$(272o<~Bwj)7tiY-LBm)IRZrI7x=l0*}aec`wqr+9qxI*YGU1zwOsF9H%flmt@bh(qX-nePYaj1uhAK#VtX*wT~N38aTzmrw&&;O$17bh2#T=IXJ3r0}hpK=XnBcOQAN3}Jl;yl4dP);3r zZWNmE^Z~nD`QF&JPrjQj;WyhaRR9=saf@mn(qTK=mk6S|dt912NE|%9X)|9)G(2kq zz6T+Wf=X1&yqh5s6@RF@I;F5KEpJf2dfw|Nf*SlJWwMyfz}p3*v?ox+>TF8|j~AeH z>~e@>C-p4l`(QFJJrg*-$)-C7rCy>h(xBvI#n)?MxaJ#4@uv(mZy-YPqAfh?<0d-a zMgRYKKTyx7xVc^fXA-ojRh_dJSedicwqy3Qe6Q8$EqsJZ*6T%ol;HIR2tN@{c&yiW zmDKOl_~^9idPT^zNm1yGtheTj-#CbIIdzFPrG}I!ljFnT+{dSy+WqxlG_CnL__IMb!2GeEPSn z)p?blPdpdiZ#DQuET=*Ghy6tSYL0ly*?7Z_IwTvFRraY>3H`Z)ik4R1ewJZ=O4y*! zp-ka@@CXrRgC>wnW5zgju%n=7iMT4tY8F^XB`?@Zg#4;#%`PyM^B%8&Su=M;es^8o zPv?$P{inoDKO}OqONL<(RDom1Ne26oG7hULA=|vK8j=x({8BZOy91MO1QTju3wn@l zXLKu^0nhJz9ObfKIawdoa{M~+z1X~Pi8gvzyFCEw;E`6#h(GVQV zh-(1vcPF5Eq_z+lF6?NsC1W?sCdWE+@IM0?*bE%!#~ayh`^NZP(_J70%tE3|#OM*M z;C*1sTknt*eceS=SOxqg)Wk6&nNt$u{U(YR)}PPMK^PW3A51tV#{B*2v0@-+dOM1B z2%tDRd{4?Lp!*@6;TI6x-u*9+8VzvFa!{wWkZ(H%3^_+%(Eb?Q70=X)$YhGT6>b`fVPqT;HWK!3 zGmv%<(lSKkNN_!gW1{Id{;vEZ7K0Nt2f81O_;q9E*H44gvzM5TC|su$zo*CH{Z;Dg zt&&Zf=*H+*c#?q=z`Fr}{CQmM2pg;^|A|F>O*Yv|=luxL7yb)z?XpqkKI_TPr? z-MQ@3Y75E2aoM)8z67s7T#EN{^^y~RRz^x96RmXz{_9NFn8wTNnp)Y~gv_q=cE^UC z2SInZn~^$>YXatRCM301E?gNaK{$?xxH?{baQeaV{WHv(?RWChm45QhqvkRI6sc_UAFFK^aUI~6;*L+!_C2AuN!aG=VKb~ zg4)7eb!V93*DL<>{EG4Du$6i%3e9C*=lE#Cq~10ET}XNoH>S#-SyG>Gds+*nOxhLK zZ3cRH?&Xl@OA|YdncikmUsmVHA5^jM*BX0}pP~grTx|XjWBF=r-~@Y z9y;I7aV8K{8ULWF;u@WWjn9%Z9N*g)Zx-f$0ybMe_>}vKEHhznkVKz+JB#lbTXb_= zg~fW_Zxr6@uBK6@i^3?wKI#IBwrem&V1hC-h37@t$AJ7BfOVhZEq(!M1LFKZ8lVI1 zwAJ=PMJ|7S9ZnWHT+ zmVMMB3kd~CnFh<=<(qJn;|xfMP+U$o*Mm(PbrTXNn$eCO&KV7i;>AF%X#IXPE%nVW ze?GIGT%yGRdtF^dkaaOH1Q-7SQq=c?m#*gON?`n9y_T18#+Kr&(QZi{di^QtdUOXX zjmGA%?eUEATUBF;Ses(-QOu zDQGEZdPF*GR?6B&VkyxA!(ns3ZQ8P{bvELH>QON5U9&e|D4yB3XLB=JMlaq4c>=T# z4#b*No3?}fT`Ip^3uGa5R1BV0fQv>zxlDqcvh(uw*2jLM?xhx;h}ZbZ%h&$a|JM9h zx)a{tj{`pzymN+rTuN}O_(gup&g#!i%MxiUF7;jO(N{qRCLxyUW%;2IpptPK z@W8{dq9>@iv*1Q>>$k{O7i523uy@aM$GG;iG;(?b&Y zoLoJqDk4l#dq{^Uz*C9%F*k+Y!F1(v{NatMXlcmsKJS0)tqw)UQq69X)=F1x4}^>j(#<-XPQYsu?tu%Wxg(%x8MXvU(&?Q7Y(SMRnJV6dBtAr%x+TTw zPY?dI>uK#7Pi%cA?OCsTEK}2%wqSTl|Izhi)0uAs&`b7c(>LT{%n700t7dDUx^6Bb z!j%=!w$VW8y<30Q#~foI2jD4W zevIVkwtMaapL3qvtbxN(fMcHtVe_CQZ%`Yi7Vcd6wlh(y^qB;MyDn{~BVe_Ta+vm6 zet%H>UGB8shj06uul2bDf zh&yF9?K*5&1=f;ZY+V?OWVWHQnyxbHy6u99;_tLK%fN&HwoZ8XQrF`m#f!c zNwxSl0_$lbETj>oLezeEUNl>a~eemb3#=RUKR_XY;ucZW1=h zTq$z0zx-M13Q}{6}I*20c}{v#=RR z=n0pci3b7H3c#HCy<=a4^4mV!7;Y&6mm6*+6POwYtd82`LKuBoMjT8vL-H!KYBByw zwPvqVy;n*M{kP!#BN9|-^N zrnkrJ1j^!y9`q{6Gv&X;1&q#@o%J^VH_&7zyYl6VtA}9c3OM1ZWLcb@Row3AF{U73 zr@ln~H0(IAFc<%>m$(@TT5c9QYo{RI!inYdCx>(mP8SJOd`N{Mkxx(#fb;fGEhky! z^12Oq86OqGUY`hDmhS|z4wsXxjF6iHTjop$coHoXJ!1@@QOf4LlSvt8ykgXms(o-c zl0B26lbgQ#(y4-EZ9AmZxo1H+r$}`QMiu%3U{7MpwQwnzhT&SLo$TWyQPbmwi}ww` z{WZR=4zyX}CE-B{4)AWP_m=*A6nzO^>FRGkqe&K5u0cG;UC8I({^0dYIvgMF+*Ec4 z>z&OC`{fT#ENc{SLP!8Cc~GyXEI{4rwe1_$SiQOSqzxU~*Ly%? zUEY{!rOoX+mLxP#Yp4|k5C-)G(IPCCU;KnOFMmZ7m3eTw40}KnfMy}Eg*mALGataV z^M7hD62D%`64xDHB_qU()=8bab5R_QG%KYWuis0cQs-)cD*_auVRL`F@ZbNOPH@q1 zjJ+rs9PBotixj(%tmW%_2V~!U^!{Ts**725-RJ|T1<&DIA1=_xnjlsur+bG?qZ+93 zsKuW)qye0rg_p2w6y)Qb$nC(&SN%^#lbQneprGUqfCC=~5L0dVF&p;mS6UvIYH7r( zZ#cpiNoyXmlqZe_lYo7CS3`6|O3*{)H6P5ihmOl*41qo8IEw9Kq;V_R-{Sq$e`tjc zmnC0<7;67$O6VK@>0K=Vn+fvOi7=CQJk<`Y5ec%4V8dqG#I9s$XFPf{`xjQ1>WPYE zjHz9xj?D7ePUBqKt3j>1#j6kAafq4hJb2GSt8T<(4zV~yq@B3CZ>muaEWopqBRrAYY|R+DW0MeI_kuF7`X@D$u6nU9?s30pK=JfU0^Q{ zIu{dyQO0Ia7v4SWh!~j}|Njr4%1@Mrxu`{dU~Ly9tzCUSE>1S=R$y9k z`PuI#K)~PqNp4vR!tkkb)*kH;s;x18FvPIe?R+}Dl9?O5ZVhWa-(HkP$25fF{AS4~I!WNr4rW7h^G>{v6xbVmQfVz#Ce9Gxdg}pO@q~Oi)JVgVW7E zDKrz;5Ik52H@GMEnbNL}-DmsQRYZ+RT->uf8fKhA~$Fj6~;~sXr8hC$$Td( z&k}fj#=9f?)(}7!$KNTdUB64bwCtAtX}9a0Y;62ov3n?e6B(esAkyGFPFl1Q4}EF5 z`b|FV*}j4%)3oB4q++XyorPn8xl$;@5PRRvOk2ze#;4%x)Dh0j2l3K#VZs?53s{nc zJeSAlm-5Iif!5@wPSgd#F$d02MZ*IHGE$6?cR7E$gl_Y*$apkPT;F+tpNV!SRQMJ3$D*+K%QfzrN zv!2GD(sM7;WII%H)Kt%UdrD!~cEx<7jbT!^fiRMJqS<*{gVgY3bN21(UG_iYns#{| zX2B3ai882kbQd-In&b~PKWb{%Nb+QMc9m%n#tDK%^jkxT#Fy8K7?w&xfkR#wh4W7z zW!5kWBU$E9%ZvQ53Y2PkigK6FrWrnxNTj?sVn+T>iVy?rA0Cp7k;2hhN{e~vW4V+nJnDS)I+;K1u(Nu&Ixm~(i|HS}x-}iG zgm3Vsq6gX$Ye=z%b~(lMZ=K?j!2MB5O||L8tlSQ@3Isj1AeY9h{^^)Ja<~$>hl}j$ zn?=}^6H(qVYV8!AU*hR7m4(|N9hE9U?iYlGZc@$%Y~AH@>b|{0&Jq0K?h1M~BJVEh zoC;{~behD4sg>dPCd=?m%5G4H{(9hyV=`OTBmTRMQG8G)iq{RY?$wnC_J-BcB+g{gbAdd_dA4S1Rs`Nw*woVZtQ8yvv~OzK2)e)P!UJKa_u$#g zpU=@pvP&xs=wf(H0-z&npGDC7A@fD9U=_g0_}wqt<6->bG(NAFwT8N2#c?b%f?AB3 z*KVW|>PDdbgUu~>2v>e%&n4z27XPu_4E(|3QPL4iO?&jVSxBC@V53@FkZa`;dvZ~1 z%@d&G7)JzIKlMfrK~C!ZE98??BQUA-rP1aHa{U=G-w8nt7AK6QJO4}*7oy|)^S?f_ z1NtGKTuxYvf*u%!r4D_VD`XY5l5er43-$q3#bpC7ww~8h&N!|M0HTLpVKTC20j=<8 zdY#=a>eO@SD^W(Bva9YR#wYf_eG#Vx4`cJU7;RPT?*bw3F$)r@toWR`puSBeFi%Y! zC$ugkGb+dG>eZJgGxq+GrsMkVg-6Or5oV9R^lOMHDgq7^!I5H|$1<011z_TPgiR{^ zQ-5}3Hh`&oTuODjQbKinB%|Mf5zp4!2P zoD7ivU_AuS`oK>1!bKs!U(RoFk4w3N)hVDz9JA|NSHTc+Ksh^M%Flyv z874j0V^a%n*h7K?e`qss4-iAai8NcgwBhvJG#`UdGe+R3D3+P&t{W~ARAU9D~h zu6$hsL4u)k@zpcT@9o?2ACBquB~Yh#2_iP<*AvDB?R-rozgZ`Y-i(M7Rf(!8807># zCH;)OSx287PkkJW&ImN|^p7-2p@DUrf&Tpu{F*8&(+c>t1SyF?jG1w9D`9a7AIAaZr(j% zb6;+qX|K>}$%o5mMg`Y?q%X(m;en0+Z`5D|<7xw|8N&n3@c}49nlvO=z8LgxZBoJw zxh*dobb2PiuC8Zi>%Y1uzVfe7<{kMHgJ%%J8^=8V@Ff))DatV$OLoxzz*|CUx#`AT zz&J&I-vXHE(&8gRCm_Pk0YSHCR$KogF+H``89L$f8JZ&=3~~`<%|QO94HDnxGb)Nh z2j5vZQF_m~-~E2Rjw~?QL_wT1y>I`X*)UM%CCEppAlEJ=^;tss_$uDSp#zX5<@r}Z z6i$wxZml+m@^RZuk#gbg3e08p&-KhoELthkPk zI|zTXUR?hofZG6JNO23l-0?SnIA1Gn_6=c&U=|pDs>Aa=ET3Px?Mr5j34XxdTIfCX zdA$qnOI*TChD-a>8QK9Kh15M&newo7{hQNwo~z zj0|E8mr&iS$4?o6hDv`SYXTmava!8ca6uYgiC*fCFXkJhaYH1mlI(=DN_RiQ=(Hoq zVe0C&@kV75iBqoh~Mv})vX>Bd&@}el}|F?B8Vq9hu zS==g^J^bh`Oi5`KrGAD5V>jS~OK>@DgMnkB9sL6E#QUMKQGmq0fXqE&{r*)bKR(3p4r&9#iiEvX_dg{LYS< zrI%!ttu{_P0(7-AzQt460BGF`5Nv!!_`PqKm zT4$Bo(-=R4fO+2?BY1Ts7jK%s(28rFWURAFAtnBj#fI3!E%R&}b8NPsE6_-dxQMlA zJOwaQxVpbLAX$UIqw!?mV2@|f{Cr2~^M$Wk*_=(7Cv`+>8if7a0*N#DoK$VEZ%!0F zB_nGt_Z*GDJalrY1tFw|wZn7a?$>@XC zF06qDrjh6ap3%5X1>+!|71_bGGt4ok;+ZX5Ul0Gb+6fyiDm4-3 zlzDd?D^pGyxM0(Iz;9R;tKZA_%tC85DWxw9*)*zyz8R|ff+G0P{Av)}rzhNGwERFn zlxWF-z5as`vH=UIz*s5xZ6voee$njPNH~FkjQ^tyToK^lE zl~9T%VF)RXlob;z4*9?zRjJ(QFkMy4Y>RJr?Zic}=DgJwhP;FgNU-Kbm%20mrNB*j zb<2383~!`@jvJ^XnW`~a%wxKbr>@*3qDSYi?G+6ci12^PMT@BT&8y7@xHt!>o#P+G zL(9O^ecJkHVp4v$$2aX}?aZJP||WzR;2Adg;6jlRD`}?K)VD7ANqDD2Z88%@O*xd;Couqjtb2qU3vdDaMKl$GI7`l<oq)t3c9z+L1v7Da1{-}a}@4Pd7c`(XpK)qg4MegT6LZQpqOYJtSNkR#{vP{$cJmsqN8E@HIT$CUL` zAJ*q@%O<4-xF=>{kfrzJ24)V?ALqSG-XW_z$xaduiH==FsH^@J!3nB!O-Nu(EAC$L zK8mmh#%PtG!(e=BA8EYE{A=AYl%c+W$$;MWcF&5rHkA_&t|40vz%>LFhA-_g$cSN{ zX0&=lO?>=N<-Hm!A>WW2@-oH@MFH99hY%wQ)=IT6#5)sgBf=Dj@R@ zq)5}WALZmDP_z6e+a9?c7SJ7Id0Wnfzr7{>S*+i;v{nNY$p@>)#ozAE4-QwRFDz?_>=_`ag1hG5dk-_$|H0dk`=g=ZgKy|6}yc8xgC{WBI8}$im zHOZ5!u$MuIZQIYm=dvB-unftY520>pO*=MgROwf21AX6K%ZK@SKK;KL9j;Mcg(=AL zUyn_~w>AU!z1K~(>XGag`L%3ASdmA|r%@$AY#T28pa$~E(Z46d{L(B#*f=MH6aG$; zgELcGA4;hi3laszu%Z{A{~tI6yQOf`a++AaP})4(Qz=aFDHbw(7ZQ{a3-?F_cb?~{ z*ruOQ@e-hEfY82K?veu0eAA0x`;1nFRGS%Li}eB5@w&&mAfz(|#-|v^0!ch%m6ZmV zQ7x~eJ<2tsJQq)&red7);Mzm{c*8%x-ym{X?;A@38ISY4k9HA&n7Ltox6B zgVs{O%1RDViCqnZbqOPdf8&_YD84U;O3c{Ys9xloLPk-GnZJ4Ee=k~}YyZbEzp?kq zo#Z0{;lBoTv>ueJZj!Q|7TPYTGu}sGtZNKSzS$K1l6+w1&#QL@!GxqHn0}&0@=j)X zhx72mUvzPA`OI#4tMT^ueW_~|&~?fnN0-$?`gzgjx~Diuj>t%JqPZ`MK!Cl*7;KRW z+MH~wSCxQykRSOFLwtIBj<+V*4mg;Z7;2UIuR*Oja`2SmEllkqgJmbGh+6IQJnyhCpekJqiHc-}ILG05xMtHxN?c_+x@|h$0W^;5OEp3^g(Ivc zZS>KQWAeCdRZpLjq-jSxW>Zw*jS`^Lbsyce57jzFII0{umIFNjpF$qToCxhks_yN= zN@hbeFQ{b6{Y|cNZc3*6Kr{>_JX3>BhCz|c1=9%Plm8Q65*>|z6a{$FnQ`mDj_B>u z8;R59`5_{#E+#L86{uh6i~qj(8nGJMgtB}ua`BV-_Pn?tzB3uQSgikOHMQe)W-*>1 zB4>@3itgq*IjWgG?pjpK&AO$aqOxvW9RsZ}@p&Himk~%dVNt;>M@b#_t?vC^CaQu7{qdO8gkDx2);$#g z(K)${uiI=aWJ*4e7cK^)$i{dWD9^9mEx1e@5;==jJL2YKy2Wpkt3Z2CENQ^gMK`u@X*U7^M@}^QSg7+J z3UQMDOwLCbce|e_hu{z<{AM4qR-P1ZMHika0vR9%4&;^SSBvwY82`;a)Emf6#+ACq zx^&liTE66Xc_OO9kaNf|2Wi_OG=V_hx7;ukBVrsT@sc(Vw!W|BE=rbso=TpsfF z-IR|C6>hwV>%H|;md2)jb$*r@HUV81#aoszKO#uZ%VxtNDg&NdS+Q_ z#gY22h^tDr6(~QAVyB~pHHtbd5ia%Q43y#y0Te`8DZZo$c+0!%Ya-!88*`#1+#je6 zbEC~<*7?x?CU*)%C6tf?zv_;=&b4oU|Lv)v&8X{DG+Hxx3YslVo`kla`wjS3u5?c- zP`gSH>AUr)IocELhG^{Yiw~YysD&j;8Yh$oND8A*TE^pUH=wzQz;HQAenKKCZtBV} zB_#rie*f%u-l{5?}NceqV-zo{|gPKT$#YD(%#Bk(Kv1 zVRZnb{P_y{FkO_63j1HLVV~- z!T;vkK7vF_IXgFq1UbQby;tY9#y5ocbJ~24tAf% zGkhD;57eGvOo?#>nt>~aRpMR2{$>ttifTWtr2g~U_`AKe;Eig5hMp=bT;kO9HnULr z5aM=U4%*^Qfw^G=%Sddi$kSvyeHAQ-g*DvgqpmdFap3Zf`Lp!Vkb1kd zi^_LzAV}HF9qz%Q8ENQX6g3!B&zA+T!msFT$zkpOuh@i}VR3{k@YLKXd76)@1#}Rh zAoM_z5)*`Qh(toy-I;2&jW=pRYF9)+{81+n2hPJo@BNkU?T$-A!HOs@@n7M8 z@E|HPXIlJ{n99Sa6cD}GU5?`JMr)`HUO20HJJ84=n1?E7{VzxvTL$jMCIrMKc@N2V zQkK&`%AHptk#%Sf$8;x|p4PaYuBQ6PxpBP6=~=){LcP=~O%0tNJ{Ks#5NOm6*m?y< zRSDschf|bnQe{hMJ54X4;?Yg&d3fbQ_uI8YDK-Y>W_shJOBL+AWZhU8Ne@JmG@9Ua z91V$hYC`OHbZ6#2$LV)UK>1!p{VSd47@@@-5IGTRYh#La4hD9HQKyfmZeF+; z^A!-et1{DD`^KqE1xUBGW5nz`O~^`-nj1@KOPi!ogcH*h4QcA9K1!xV^5Gw33yenW zO2F5>ODI-XyAwk+_G>^okJeswZhd~!&vcj@0=}~g(>r!SZ+rX)jd7bGP{XcKq>XM^CXjLON@vX_EaKmFSX?z zLSHy?{1Wz_gcKMe>9gtsKIawjy_Ono{MMNP$DGzgDC<)dgi>HO^_Hk4DtM1V_*cN$@kxAf`IDS zcJX=+#Y(<0N+tdeU=|K2X03IBu-iSKmwnoLa|_fCs~|4*7D zsOo}-li01b_O$7>4vR&isz?pyYg|tlDVN!TvLHdOW?y>WC}e{MJ!@;Ii6z9ZnhKoO z-Mpq%%UfMI8$u^n{$BTIoJ_%1qBKkn;V5nn+1TPIQH%ehJ7O%2o%WJ!IuimBTNw9$ z{*oUpF!1MrQSMb3jEsi+Jw0%;mPA2Mvz)7;p!ZAp$|M$cXb~W$=gP7l+nZkGDhUK6 z8Qh13MTtjB&kJ`kY9gQFPr~+my^tVhyCCoysJ>%{y>ctKy@qOQPVvqWd7otcQk(6v zxWk$icTymFS@1s1J%dj5N%Rnr1R(d4N?5j$&c@L?#n-?*k}r%p+4JQbp;HcWKaa}IUL?(RtlBo89j6He=F%s2-R<1it5j8S3>d(@_Vsxeh}_qo{)5zjw2wkV zM3{hKOORwyb8mkN81ZdgRujdk`^tb*iSYQ$rCHUeq|j3jji|3a7AYf_*ZL#?+C`RH zqC{E!xD93!8W#5K(VS<6{7L&~`zigN=qgc&ugs;VDgmK|;zG@@LSU7;ad!STEnj~E9Tw1{6ZLnr z49lsd7X)!f+JIw@wtbPCXfoT^gICG!6*qo@>zccphAP1Xv1wrvB?d1a*-6IAWVa$%dud5!Fv$-Tu(zrN(2HhYKc)jJ>eKI zRu<#>V2t0t&PljT&7p_u-EP#^HkAoyU;nbPQIh-#d^rP~Kg}N0mx_HE#@Bo1ueq!{-R|mNq)^mL`4eL5SJFKJss3#zIk5jFhfv@dH z78m(ZnAc_ttUN!q-Q5ViBNl~Y{#DbYO0DRPv-W{si( zDZ+H4d66pg{+ClR4GqVZmYOZD>~g@l#^KmOs{=`C!BLlet>c&N2CWjSmFSb6k0l6& z*}=Br>0Bz2w`~R9bVZ(7NbS?~9ZdAj@Cz<9K0M(G<|FxiYefb4GoH$-jus7l z=`X`{ZAC+QSF`}&PsW4c@aQX?X>HfN7v(8>ssg@_7T+dm0)Q zmpi!x$s5sxIX!wcb(3V`={fHs`ab=E^i@}Z=?^CR2uOQGN~;I&{;o#L%jaj4VVs+; znY0L`wCj)Wt1BVmqy1k0YjC>%pVw&Te-}f(Cz(;q_&5JTt`fxQ|yq- zWpU2c)Kylwu%P*&VF2v)B6LWBQcS{h`uv|^dzaB43fxmWyX2Ld8JqWD`dL}!Xg02U zxroxV<5N7wcx1lWT61ZU#=^4_6?y7e+Xe9Bf;`Ilz0NLl{u&=I@75h1g};>w-5 z!ZFYyr?4oDOL3EWq0^??8Hlg0^uH;FZk#u`%o$t7|zc*L!mn^B25f@2!{k1S!fWfYn`!y5Aw&Ox@EiEKa^8wZdo~6pQdw24hJCP8 z54xL9BLJ74*)s^=IQ5l6hv27gDErEu9B9@rTeplIfnV^su`fRi z1!ko-7--0@;AJa8Np0Zp?KzlQlpwAKHyIqmw5>=tsU57X)K(FKl~N;+nVmiLUI-=ejZvz2f1zE7+mOuOrhL!5*5KPp;Sf^1 zsJLKxxt@{$F^Qb^>&%P^ ze-wfusV+gZVZ'~^P}9j;D=O4kx*9iRI)bN?*X>2$sEj_UY|d~w-7)Zg|!0{Fm6 zZ=VW%W&^-}Q*!(@DfUU3Y#N2>rUonIpdMGNi&+nC(niAEUSEd|PUcycU4krW6Nzkn z?wp($VrmNRgX#|CeFS3IiX8p<2kh>a+z9rTbG|U9pshw*J|~#r;{2|&qx7V6-anv7 z$joqWUlQe-;pt}DnKW1G<>g^o%ffn^Kf8^g#o;Pk4zHL-Dznq@Xs}AXaV}c_6u2Me zCRFoiOGG7_)0+AKik}=2z;H&;;B($`DBp!p^^}??plr>9hp7mCwBS z*T-*}Jd5{N2HfUGiMKvVl`rFY11~KN4@LlyO)peG^$(!FckvruZCa#(He1(8+IM8@ zE}$he+^YZU?xu>>7gQ{(X{YsM6YxYy2c-`xPI}tX*z*!4W2Ugt1EoClyPH=N^HtkO z#W+c7w!$OvEP1dD_Yg{@c13kzu0y?1YAZFy($J{R6wEwW{S_9^wcr%oU7e!yuw7tJ zdJe#IgN>ihP3Q5#yn(PZm3DPQjwwjlzob-B22cD_vluBLBVjzLt4ho?!r`+?>sKuw zDjS}JEcQ(bql3O-hf1cg%!=q-f5!GC<;_dh$EuAXd|_MkwHOx`$$o&+7;A!t>Xq0! zJTZ!p@tLJFz80xhk<>gZ3>~o`CwTQmsM{GvGg;V#DnVd+L9u}!B5;1&D@r8hX(k0|98Cok9G<>#<%jVdbb8r>zioEx`e5Lx+1K!gt=C+m%No9PW7?=l+WU>Ck9R*C3Py&R6>}C67+&eW6a?86|LF32{ru zdG(PZfb-jb`u@Iyy~>%kDKqK`5z_3+MkQ?;q4n7N4VjMrW(lU79sU6+%n30nJG$f9OMSfMQfJp zzBzU`Q`&Wh?%l&ZoMYNuA;<>|;mEd76k4R&JHk=_61QU?F!%ie_R@5Q%HRe(7}Z06 z2bp?5xvwoI<11-Il?XM83krfhji_{)Th%sz^+y%=stA?M)7CiYFmR1YDR=t63Qg2+ zcy$gk^VVu^6tF+ihEc)mb`z1mvRXg^Pu@A+Sa_R}cA7Jpz*3Wm=Izl1E5Ek40E3Cx zJTMkB)iZa&moF&ypLOBU?Bf(6UDT>`6%$)r$@-_p*dnNwJG}W1?#hqwm#*IHKBLN= zM^Wq7*#Hob6L4O>ZppF9?T6LgTR;U8U|CTcp7d;q7C1$+LiFCgxrm*I_iG;!5&6>= zpaes=kfYKC2kV-ce*Fm#RRQv(s8E&)-`_;V2(S%B0(5XLS&Jn9KR7lF~mm$yBc+67Tz5sa%%%VfAytHAaeYYyhEmjpwrtBIUIvja4q zbqs--5(5@T8_1Ubuhf+eIOEYE@@&03gPQLuA7fzh{OGIp2G}_$@CEbJkO>fCeIRvN zhJSNS5nkTZi>3LNJI5=hZo$6VkJOjgqbW8a`0fYV*Xf33m9Jt@3ZstKZLJQQ`%w?n zQ1A_u6E$KypFi^C@%fqnrX03s7t6_ibTtHIg=y;$2X0t?e2s=S^Y|Q*$@HA(?hlK#Y(MNyvhbN-t5I+Ah zG4nGV2_@s?i;fac+yi723;nZvyDhcKR0r%1SvsBP)Clj&SI>eRI+UE_x2oX~E+CDMG#G$En_L0eE zIw6_C)OZ|Hqu|fjU$7RbHX03B?D0!jUA9BuuCct;_G!cK{zZ*@21J8TZx1#%g*8~k zZZ72W_bJ8fmcMPifpN3p-@{vW7|f0gU}N@p*GWZ0sLm(1hj|U9U0mj7rh}2Wr#AP? zh%6bROE*X=~sI_Ncx^XS-kcte(>M==CjCXV;-LTP!En zj6x^sJ4m+$0RmHJ0cm&h#CYo=D9=3AYIg`}RJYVr?Vx3@<`E}T&Bi7g*(0fZBN?_DP?_BnsTUS=?_rX|A=61MR(_(%gM3z z%*4WfMfCxK@F$IShXeu%o~42CKo<(+hgg7_YTs$DjqtvsEAOD+l6ClQ%YSO#l=-2n z3p|j#pDG*=Pn@TCIW7SQljhhjwz~?WiEzRUkdbX6^YsIWTPt!ky; zw#nGWvfZbROhKN^Wa3kI6b5@nquNbB;OXK`8MenQ9-^(!adzj;{naH0s9>K~(8m0J0t*igsr*LxuWy8hl-oGf9!`?zd6<$n${?EMBKJkvWc~~*L!^yA+|D6oQvEA z3nFwB>oeygS{tCOlBmjymKQbg88=?R zpO5aT;_k6N(~>7qwo6hE zLo`#!QnwQO6H8{GTeaU7GMacec$ECQ8S*2btU3eub&Z|1*wW3`?^30sDCakZlB%Dc zmNNZ<3m#ILOf_%-=^d_QyQ4GFD)i=)#|q;#SRj7QWMBs76ts0Z4Yb)oa;^3OKEjNO z*MPil3CxvNzTx!y6G;cez%T1^F7^C2&Hq7aKanzz$KW=?$5+``7W~=S=fzGCMBi=4+E5F==x|%B8pVnFL{wNbZTC9Sb*XrM!6)JaiJDkfPKblO z&hTY6=%5W&hK)%J!|}85$bBo_dDxmWdmUKvaQ|lJ1UTZC@``2GJ6V|N^oNITI@|!1 zZl1(4gMawUiHN?kGAd3?2U{-m=S!iiVJxDUQg4kR#cgKsrqHhaqH5F=6h}u$+DspE zCD67Qza-oxN8JOxXUB%)wy61Gu|_FJfcp{gOskmHXw-|Rs9;@{EJH5f%a>}pEiWzQ`K*#JHRlt4m<}ddhFnx>9SfQsi@0#^l>5 zlTX4c5qzOe&#Y%m>#y0!P{C5F3>2`|ZSPFM9Z07)W!IH(dJ#%gPXUToZ}!-;_0 zQyRnsa6A|t%d$v>%st)X>XC;v88h4#R$*{O0%hqP?}~uLQL`r%@eiJ$9jPH5uyGs@ zO{3#j&RJV3>4vF^DhUB!u2)Tv=A&pQF+ly6>8E1|`N11+_>VQ2ULq|RloaH#V3N3I zOjl4yw;3Zmi^m2>{me6LIY#%ooIZ?W9x?+;3A9B6*u43GMAlk`C-H<@@)@$ZWBS^A z$fqCjj8$$%yJ=cN@j>El?1uJj;I%HdWcY_Q?^78jy5?cupI-le=%iwcoH8FYKLMY1 z*)QLKQ$2C)xP7}Dra(*ZwFDZ1!HB0|h$(KUSDB>f%}ISN84@sCWMZ+)Pd2&g&IGEDu8VTSqQPg*6zpL4 zUr=2--5d2`uAcl_sjBgb!i<6=J$~ZVcYGcEOyY&g6Abj>(Y&j^JXgHt#okw__^)3g z(v4V`^-+N~S9sSJeVa;7{{j#Zt_#-It=`pJ6$7THb29c3$)ZLlh$EIx@+`W^jqc75 zd1kjV&7c3g#JV9!sMjHfeT=tM+x#lO-~;kfM}p|(VMTOGoidr%>`@99w1vFK)Ut*? z8MakgV%ECZM3>Y|kHBLs5!~EdEHWcbZ6k}hMx-edsXRQcO2?uX5U`dLf4FS@gi=I2K4C`TcB^#aN5M-AX_T_xDp(Nd_(@rZ{ zCMhb1U6Y9`N^@HLPg&@((ZVty)lMAw^{wEnJ8_LeN}WT_LuJNlK8w;rc(*o;vV^Ib zV(4uBh!~RzMmjRz1___v5?+TY-zeDFthC9)=P&!*^HPf0sLzV>3Nqhyn*}5$7t4<5 zv}?*>gy+c66sY=c2Awr{`5~E?CftnwYZkOB|LO#4iz!6d`H0N^p|Efev2}v8iiHXm zX~>{>+{OAi$%4b><(a7jn$1c{yn4%I@$8{LuD`y3y(u!^OVo#kHl>qcYncEuPO^o& zlBjKaBRqb#N1V)1Xy?SiB?=HhXprEYv=FiFB4k)AbJhGLC*I)Td|eEw;hSNQvtaJS zidEl}bWd^|B(S9AOER|~eMeSg3k9GdW8Cgf;h~SOQMAdQ?vOZ_H_Ch8OHO)$&-w^D z*wcyqzCKQh4Yn55p4+x0f2n+O(5ZBT3e?l4@;MxWC#hO|Me?LbQFTgI6H$5oXG;f~ zOed?#HPX0(&~A__X$w6*PtHe3e9My)Ai-*DO*A+jSBHMY6rn~&Ar>bHljZ|(y;-ju zf>|olH4Cbt-NA}k61I-=C=|on*NIq<;Mr?HSNVTBmpa|>2MoYld`(`EQD{*$-CtAC zE8j|mKnSCXa8`{ZCq=h1{KVe8G%1d6@>8%4L2Tz{~#>Y64N zZW;cN3;5J3+DU7dlJT90pJ+O}EbxV}BFfG6AyQ~fU}saalftj`IKVKuw+E1sGl)`F zH9|+EhN)W0|L3KHq2b6kCydPFuM#)Ix$`n=iYq=ghI4(T+5H7PHjA~M1h2Da8L)pS z3}kU`G7)Tc_%c7d3VI6}p1{f;p zRJYax@@h^jfb~M7&k6?1_Eh}jyi~d zx*AruFFId0SUk7JR*_ZC3Oj5t_p@HOYwh(6j)#XJYoQ(h)KIVZU|0$fYzRYd*gh(e zEkW2%^&#Cz0DHqQs<@MAuO#K_xJH{rEvuA2qoGch6#PF`Fnz(HBQInASuzRtE?Z+2 zeb#(b@%TSku~~G%XjIXAz6)5aM-i5vE+Lb>Z%r=r+^ZNc!s^UG{U3vn925D&x1Z0mA3ienwf+U zP1w-+j46h(ToXNJ16zMPoG?DAr?~M#;<)e839rw;x*?P(XijdJfqZ_$vVO?yrt+f) zAzry)7rpGW<=nZPezbya|^IHEzK2@XUYn$ zu4InWtlc-A;KNcLN@YX;em1ItjbtqMX#Pcsa1>;g)3mUM6Hcl1#&MW?*jdM3fGbM@IK_!{I;d*MxMSzxfk38C=n zk7Xri$!VIo-*Y1OTW47&jiQ>LOz!t`?4`3VzkIYt`C!8)h|NU)L@mjzs^-^_y{ zi7SBU6d@Li(KuQr&eHo3dfcul#>$2zXgcVeDvtUhFzQMoE*3$5=3QWMZEJ<&3s!;FCE5aJG3 z^_Ni380pb6k7Q&uvk<_DtmQqrNboCALTKqTZEnMltz2J&H3NDN= z_%fW=i1Dq>nEgvO!|)ys-870BHOuo(#`9VHwTzVhp)^?^9A_)-q8g)`8(!Lvm%V-N)+bMos2@=V8X()Ba5t6e=by*$-jBWJ`^g@ z;~Rz9Sy<`1xWw*Fx|oV1!S#Rnb$0SLOIFJ>V&I){H5>$i;FC*XVe?D{x6WPW#EJAk zxdEjJyUs6Z3jne*;zomVmNVA|GN!1(@S-;bRIbqgMDHLeiO`3_kV(SoT6AcXLP+<8 zQMOf>;(M$O4yVEQRUq#vhRGdTn~>1xf4+JD{i-eJ1t|WT4_pD>Ly+Mfp$P1a--%?# zX-@ODIY(zA^)}dl^y7dRj0ufWVLCe>^HXCP^1p548h_A_F~Uu(pu3F&|Jk8u=^8Od z7c2Usl06a$yi<#T7Aowb;G3DMCaHS*H&SM0a*TC6w=00ig!{hDu>Ww!587b;ywn+< zj~qT1t1e#Kh99-kLt0yl|0k_2S1>)WP7DekCvEHxevXH0W&_;mmFELHk7^O--fg6DSVkmtlyOYHxVYLkBlye49;~uBDH1 z41@f`j69yXDH{O^S%;^^ zLZ&?f%xqus6ZGjUaRPUx5X?0QtuT78 z`atcuF?x1Bh{!{6Y$gA-_eeQDqBsva^h|YyN+bnCxFv@D08d!pdek&`%jhkL))A#FE#wmC*dPoP`!9gkVi+I(KV8A~FoL^+|Q zt*^xTwo+0?WV9?>VXp7BmnxKQyANd+tcHr zxc00n&s%2eD*299LAc1uigIHRglY^p^#n_;868(RhQpO0~|AdFI!wn7g?@zlL)I_a2MJ%UJx*XlYg z30e#1<5s4bH6O89#ZP|ZOuoFuUvb2L#C8L_K(p^A!hemW<5(E|$yQr{I_R^xDkKUd zzd%8O;7z)#f!)ccFnkp~0fP*%9goFQ2b3E8cBo!ljBd{PwojYid@eww_jfEav4%sz zHD*T-c2jhGNV!?)U}gF(je>PQj2g#3FgPCI(Rb&0mpSds(2e4lmA$h$BJHu;m~_E_OUJYq z))8jATW*@Eg0Dt7WqgRhApB4<#g*{*NK#y3AY^D7!^(-|kf1Oarv+M;Q@IUlV{3TA zZI_n8@`GUL+euRqUoW3~F>DZh_?-@UU9~v+HV8GNy@;i~(_2{K^{vLC z;maEHkOX_(UyR0y+x-~2TFh7dOl0wab2Q<-MJR^_)njM{bFo!TvAHQ))xe99L*)hD z?i%31{vEZ8*zQ>YFugE3Q@c6-3|ijK4pGQOE_bE9@5%ogcNB`D)@|=2OPHu=@fUei zt4CzoOyr>qXMCsaAdr6?rng@F*y$*53hrF`F1&=&OKp#((%SiO}GJ9F^5UvFIIC`i8~ z$!~h$4uHcRrOERWfW=2Y1|33fD$7@>*3p_;=h6&B#hS}zeNHZ@oeBcs#Y6- z{VeTko&wgJdzZOc3Jl{5%9Xd>lIDp_IZ*MLuGr!cNt1~gS7MGrG7)y!b8*gYTQ-#d z+Wo-aLWKJPkV_nG8-;va3;_o9u*PX6UPViL`i}6D+3W-3B_NaXpjx3a|0+)Q308 zsyyOpT7|AsL&eFeokBUy{xnZZMVUmpF+^cRHXtoQ16lh8m9PF-K`Fw)hRB|kR? ze7QD8i7H4T8yTBV0I>e-Q1x-%iy%EGDHBuM=j|BjnXVycH~SNg{1EE7($UbEC~Qb5 zALd(3)~j#><7YhJfRy^~cr(rKDO)+WB>s0wk+7-wm>!V2WAegtBi(=Zd$*g#IxO4U z+mtgcT>kpX3%FnVh>@A9_b%>**#PIyFd1ifLnV{>us2&RK7gNOT6}@OtweiVKmW)m zo#Ndje6ar~`+>{%G&Rd@@C4ib>Q$n#p$(XApb-T-$Xwx@QZ6F2X*RSe*0ui-dI^#@ zY_o-SqW_|7y41`3Y^?UDta&apr~w=rh|ia=xvHKi{eMR32VZT7-8GLBJxEn{ALisa zwDX@_LZNomu7X6{4S$Y#J}#JW{pb|jm^Z_GC}QD&Cr*lH|qT3XU5b>HW= zo?(uJwr4`3oFgF-ZEticG+In7z2F#J9ke|X)_7Ja87@!KSIGv(G&}oGZBj0!MgTN& zP~_||rxzC7XDP-U-mvtS5UW$eO!YSklpv_gXlc!piU50X9y+Sg_Z~jy&Z=!NiYXXP z^aHg}&#LWfqXl!QLw$XC&|iBg9X$V~hFe|HIHJZhS`iZ;kQSwuHQF`*A@ND|-ngk3 z{6=eTpT*3=^YTk!w!*dfjPf0*Rd@V(%;V@@pYJ1^5N)nExnpO63**P>o!Nqi2c0=b z&r{j1F^3>0i(ZSO7d~(LuIyfKdUdrE&El?I0U=)-_?5Mm@JAH4u6l>-Ppt^b-9+e2 zg4$}RLQQ&r!GBb+dWW~Y@jT!<4YY%df5)XQI_fKJ+4=rr>7=4?+ZpSv2vd2x9JjJn zbDWFX$trj9NAFXEJJh1!KFOyy%jOTQa6e-abM22)ekhP`xelPOotaouW6;DgF1D}m zwaiNO)DnQq-zuGjeFir*K5w~3!HWrS>hj&0PTa~y?9_FLfmYt*gBgJaqBv>wS$NAM zVmFJxh7j(^qN(iHt~*9w7}k^7dQw#{T0NZ z&qA&}T^)IK@%&S{TKNAV-mgv0N*vfdvTvUVQ;p(4x9a(?9QtIYSYtr!PvEyGmZHj5 zeL}`Vat-|{D|2{f6F!Kj`_p}>n%^bZ#e5w2*Xj{ZIwt%1aoOeqcME^xESB*;fwJ$* z9_54UEOdv6vjWHhOrs~W8hbZ z*eaE71f&%=3Tar$!BC1-4^YA(kN2OmD?_WHtql)ne`|8(cIny3*3~6AiVYwC{NFkn z0BWum(TA5;EX(4NLHADQc(fzq3d;1td1cZN+ASj184btVTChUV2q7h@vB8@l!lLjR z-PJnsK%0mI6!(xB8{)z4@JHLn8=EZmaGqlFkPckny@4!l(FL2-B{6W22WVm=AlE z0{DS{x>%?KCL*6t$rdSBbdMA}KV^j1(-@5|jV@-c&6m^N^Hz2y`l>rhAN}IS_qnyw zW$S^>>eTnf1LNh_7f9}#!@OEVyf-M5kFFz>}*D8t87mtog zgQT9QI>xS1BqKpZiBM^q(7GE0WaLkFSwX}-0{P-THK(89)pBw9Z8*k#SqJ#=S<;K( zH;?c4sQsJ)LS|!e{!AyB4r35igdS%-y5SZ<)uL9m&qV zP;tr7+~Bf=ypNrcF{uf+M?kqg%UhRLxG@@cGrBwu zjL&HB6W`A%ATy)F^oV_06`D1NUvt;y2akN^#m7Wro&{sVZ9Z{NlkxXXBOju}Nc`7! zlcbJKl=DxUj>8g5X+dDIKKNhXu78v#3WVAVOen@jK+Ny|_wkB2dl!#^CdJ>(^^yZo z%H-jwlU(Y&n5x#O0+J5hR`v%5sS5!!FLz!b)lRyde0jnV;&bSG%!&TJBKIV1s2}T$_Lvsr z%#?~`&?;%)KY5dnP=Y^TzFuN4u6B+7Ocp}+M&&%b3tW8JAz4S6#E0jn2_@~YE>QtE zFz@Fh2z9GUxqjnO(O#%5P+IH^c>NDX9d{7#PS$0gh{w36*cuG6)WUDJmQf;r4Y1Vi zDJmXuP#1zk=oTB&POp3w(dL+D?`-DtPHOTibU&x~tzrFH?TTyGS%gv$?*W97&M|rY zaS>--*UIFZ4AB5S`6Sn(S$(Tc`fvTMShC;MCK*`1p7W5`cV!ydK<()O65K%g=`v*j zKyc2-uB z<<|5KFUUNdTPx0`AENynu?FO?^PZ5}`Pb1O8cK_YI572}Z2|Uf!c@GqKE9?pelelot1MH)$`ilixnTX?;dNZ+& zK47E$9g34j#ZS@PhKKm&km>po@X&&;XAK6rg&IFbhW(ksn3)ErS#M+X2zeH=bQt=u zlt{Jasgf9~9R3r`C=%An-5J`+K^?Rd-U)>L<`dZ2J2F(Q`ZZFf<~=yiR%wX!v|zg z0Zd}aq#pi%&GMT?c4i-kL8?zmw4E5|aBYd933S5^Jrw>4wr|=k@nMUSMmwcq4Ntoa zfYvP#=~f*#cqVTWs<(LVUOW_Hhb|%>cy@hSq_dv^{$C=PRh~CZuUOajdK7*aH)P{y zes$oRFj&Vw$uTs}2*w4VPE+9f9_{8=IlNvj6Gvr>IbjcPgQ^gdil>=*rd}+yLB_Ob zKl)HJ9AX+3DE!@e*yb)QSe8k)ok!%4GI16ol@%Tk!)y&1951)H7bRVTtvpU3+Vr;a zj>Sm~3lQL;(XMl7Lp7V!-Klpj2eWeJy<`a9Am(uC9Tq>?(D^7{t(5IqfuUh<*b*87 zU-5-B8W|&FNb&?JzBnj(d^Xk1t_2QAn0+3`F!FnNu**x_4H7gjgw$;!AmhKv4GvAP z?4@wfs2=c5d{3}HHJlID)$nUTeRbZEm2R~eB3hyM!ub+DRy3r)%t)qbXQ)v1z?OsF zY`${MJUg>vAnO<7rLi~ViZ?Y{_XeKAe#qk$-q+h4s;6QXFu~ z?=cs)V4@I@fHS)1Z3GFA)2}K9Oq!<@yrr6c@qi-Hr;xnv?{}c8T~QPMMfyGS<4z(Y zp4ZGgR>PSxw^w$VT_MDGOpJt(K(cSciynoK=3U|+dRF%+!6&xrrxlEq4NY>zF!Tc7$~<;nVpjsN0fF!AKUI^;f!g5KAsomSj=4w$y*8`j!QW-jIcEjA zE@%mS=~(rFTqE&_;`O4(^Vyzn{bEO8PViiCw)X9Naw3CXZ~n*+=BDm71-ag47m+>J zAhk{nc!x3j3W+BBtD6nyiq55gP`{84x#irX>d^rq6IH%MQ!~NH?P0#81IJZ+O8fBqM1R5ctHxHA*#b=)elXm9f_HL9G`6)aYSzrvjmphD!CuM>VrcdLVE-KnUKdv zmQnVY1RuV99zv)>BgnKTzsZ&>x0zGB+y~26IUQV;Yny3`evo4X|B+Ig-R!q&FH`-y zS2jg|D8_t9M~)sVL`|m?gev$XO5n~7I&z9l*)SXW#s3xhFo&aoJ(cu^T*#r7l$N(w zK;06QLxxu$ZQXDoxD-g;M3|js3K2waB+(pE+`30w46HECHw^jal3PsYa>ChJ$6af9 zq*6DQZglL4O%0A%OxT#(h+YiQaXX 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%0AiKWa9S`6z4XCjYo#q0UGitur&z)@=o+Hz>> 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ⅈ{#uKBXfODOV9w%)DJ1$O1Kxl~QEt8|!Q38V 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