use std::ops::Range;
use std::sync::{Arc, Mutex, PoisonError, Weak};
use bytes::Bytes;
use crate::counters::{Origin, SpanRow};
use crate::detect::{DetectError, check_entry_type};
use crate::error::Error;
use crate::files::{File, Parent, ParentKind, parse_file};
use crate::limits::{Charge, GrantScope, Meter};
use crate::once::{CellError, ResultCell, get_or_publish_result};
use crate::options::FileContext;
use crate::raw::RawStr;
use crate::stream::py_read;
use crate::version::{FlagsClass, ResolvedVersion, VersionError};
use index::{Ends, RunIndex};
mod ahead;
mod counts;
mod decode;
mod index;
mod legacy;
pub(super) mod open;
mod runs;
mod write;
mod write_legacy;
pub use write::{BundlePacker, BundleSaveOptions};
pub use counts::BundleCounts;
use counts::DecodeCounts;
use decode::BlockContext;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum LayoutKind {
Fs,
WebRaw,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct BundleHeader {
pub signature: RawStr,
pub format: u32,
pub version_player: RawStr,
pub version_engine: RawStr,
pub layout: LayoutKind,
pub engine_version: Option<Result<ResolvedVersion, VersionError>>,
pub data_flags: Option<u32>,
pub flags_class: Option<FlagsClass>,
pub block_alignment: bool,
pub encrypted: bool,
pub hash: Option<[u8; 16]>,
pub crc: Option<u32>,
pub blocks_info: Option<BlockInfo>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct BlockInfo {
pub uncompressed: u32,
pub compressed: u32,
pub bytes_read: u32,
pub flags: u32,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct DirEntry {
pub offset: i64,
pub size: i64,
pub flags: Option<u32>,
pub path: RawStr,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FileSlot {
pub name: RawStr,
pub dir_index: usize,
}
pub struct BundleFile {
pub(crate) writable: super::cab::WritableCabs,
pub(super) changed: std::sync::atomic::AtomicBool,
name: RawStr,
source: Bytes,
constructor_position: i128,
legacy_data: Option<Bytes>,
header: BundleHeader,
blocks: Box<[BlockInfo]>,
directory: Box<[DirEntry]>,
files: Box<[FileSlot]>,
parent: Option<Parent>,
pub(super) dependency_path: super::DependencyPath,
source_depth: u32,
lengths: Box<[ResultCell<u64, Error>]>,
ends: Ends,
runs: Mutex<RunIndex>,
counts: DecodeCounts,
pub(super) entries: Box<[super::teardown::FileCell]>,
twins: Box<[u32]>,
ctx: BlockContext,
stored: Box<[Range<usize>]>,
this: Weak<BundleFile>,
origin: Origin,
pub(super) charge: Charge,
}
impl Drop for BundleFile {
fn drop(&mut self) {
super::teardown::drain(&mut self.entries, &self.charge);
}
}
impl std::fmt::Debug for BundleFile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BundleFile")
.field("name", &self.name)
.field("header", &self.header)
.field("blocks", &self.blocks.len())
.field("directory", &self.directory.len())
.finish_non_exhaustive()
}
}
impl BundleFile {
#[must_use]
pub fn constructor_position(&self) -> i128 {
self.constructor_position
}
#[must_use]
pub fn meter(&self) -> &Arc<Meter> {
self.charge.meter()
}
#[must_use]
pub fn source(&self) -> &Bytes {
&self.source
}
#[must_use]
pub fn name(&self) -> &RawStr {
&self.name
}
#[must_use]
pub fn header(&self) -> &BundleHeader {
&self.header
}
#[must_use]
pub fn blocks(&self) -> &[BlockInfo] {
&self.blocks
}
#[must_use]
pub fn directory(&self) -> &[DirEntry] {
&self.directory
}
#[must_use]
pub fn files(&self) -> &[FileSlot] {
&self.files
}
#[must_use]
pub fn parent(&self) -> Option<&Parent> {
self.parent.as_ref()
}
#[must_use]
pub fn context(&self) -> &Arc<FileContext> {
self.ctx.file()
}
#[must_use]
pub fn uncompressed_size(&self) -> u64 {
self.blocks.iter().map(|b| u64::from(b.uncompressed)).sum()
}
#[must_use]
pub fn counts(&self) -> BundleCounts {
let runs = self.runs.lock().unwrap_or_else(PoisonError::into_inner);
let n = u64::try_from(runs.len()).unwrap_or(u64::MAX);
self.counts.snapshot(n, runs.bytes())
}
pub fn entry_bytes(&self, dir_index: usize) -> Result<Bytes, Error> {
let span = self.entry_span(dir_index)?;
self.read_span(span.start, span.end, SpanRow::row(dir_index))
}
#[must_use]
pub fn pinned(&self) -> u64 {
let own = u64::try_from(self.source.len()).unwrap_or(u64::MAX);
self.parent.as_ref().map_or(own, |p| p.pinned.max(own))
}
pub fn entry_range(&self, dir_index: usize, range: Range<u64>) -> Result<Bytes, Error> {
let span = self.entry_span(dir_index)?;
let lo = span.start.saturating_add(range.start).min(span.end);
let hi = span.start.saturating_add(range.end).clamp(lo, span.end);
self.read_span(lo, hi, SpanRow::row(dir_index))
}
pub fn entry(&self, dir_index: usize) -> Result<File, Error> {
let cell = self
.entries
.get(dir_index)
.ok_or_else(|| no_entry(dir_index))?;
get_or_publish_result(cell, self.meter(), || self.parse_entry(dir_index)).cloned()
}
pub fn load_all(&self) -> Result<(), Error> {
self.read_span(0, u64::MAX, SpanRow::WHOLE)?;
for i in 0..self.directory.len() {
match self.entry(i)? {
File::Bundle(b) => b.load_all().map_err(|e| self.entry_error(i, e))?,
File::Web(w) => w.load_all().map_err(|e| self.entry_error(i, e))?,
_ => {}
}
}
Ok(())
}
fn entry_span(&self, dir_index: usize) -> Result<Range<u64>, Error> {
let e = self
.directory
.get(dir_index)
.ok_or_else(|| no_entry(dir_index))?;
let u = |v: i64| u64::try_from(v).unwrap_or(0);
if e.size == 0 {
return Ok(0..0);
}
if e.offset >= 0 && e.size > 0 {
return Ok(u(e.offset)..u(e.offset).saturating_add(u(e.size)));
}
let total = self.measure_all()?;
let len = usize::try_from(total).unwrap_or(usize::MAX);
let (range, _) = py_read(len, i128::from(e.offset), e.size);
Ok(u64::try_from(range.start).unwrap_or(u64::MAX)
..u64::try_from(range.end).unwrap_or(u64::MAX))
}
#[cfg(feature = "test-counters")]
pub(crate) fn span_origin(&self) -> &Origin {
&self.origin
}
fn entry_error(&self, dir_index: usize, e: Error) -> Error {
match e {
Error::Entry { .. } | Error::Limit(_) | Error::Budget(_) | Error::Allocator(_) => e,
e => Error::Entry {
name: self
.directory
.get(dir_index)
.map(|d| d.path.clone())
.unwrap_or_default(),
source: Arc::new(e),
},
}
}
fn parse_entry(&self, dir_index: usize) -> Result<File, Error> {
let twin = self
.twins
.get(dir_index)
.and_then(|t| usize::try_from(*t).ok())
.filter(|t| *t != dir_index);
let twin_cell = twin.and_then(|t| Some((t, self.entries.get(t)?)));
if let Some((t, cell)) = twin_cell
&& let Some(Err(kept)) = cell.get()
{
return Err(self.as_row(kept.error(), t, dir_index));
}
let got = self.parse_own(dir_index);
if let (Some((t, cell)), Err(e)) = (twin_cell, &got)
&& !e.is_transient()
{
let _ = get_or_publish_result(cell, self.meter(), || Err(self.as_row(e, dir_index, t)));
}
got
}
fn as_row(&self, e: &Error, from: usize, to: usize) -> Error {
let path = |i: usize| self.directory.get(i).map(|d| &d.path);
match e {
Error::Entry { name, source } if path(from) == Some(name) => Error::Entry {
name: path(to).cloned().unwrap_or_default(),
source: source.clone(),
},
e => e.clone(),
}
}
fn parse_own(&self, dir_index: usize) -> Result<File, Error> {
let e = self
.directory
.get(dir_index)
.ok_or_else(|| no_entry(dir_index))?;
let span = self.entry_span(dir_index)?;
let (bytes, pinned) =
self.read_span_pinned(span.start, span.end, SpanRow::row(dir_index))?;
let wrap = |e| self.entry_error(dir_index, e);
let ty = check_entry_type(&bytes, &self.ctx.limits, self.meter()).map_err(|d| {
wrap(match d {
DetectError::Work(l) => Error::Limit(l),
d => Error::Detect(d),
})
})?;
let parent = Parent {
name: self.name.clone(),
kind: ParentKind::Bundle {
version_engine: self.header.version_engine.clone(),
bundle: self.this.clone(),
dir_index,
},
depth: self
.parent
.as_ref()
.map_or(self.source_depth, |p| p.depth)
.saturating_add(1),
pinned: pinned.max(u64::try_from(bytes.len()).unwrap_or(u64::MAX)),
};
let meter = self.meter();
let scope = GrantScope::enter(meter);
let got = self.dependency_path.parse_child(meter, dir_index, || {
parse_file(
e.path.clone(),
bytes,
ty,
Some(parent),
meter,
self.ctx.file(),
)
});
#[cfg(feature = "test-counters")]
crate::testing::adopt(&got, || self.origin.child(dir_index));
let granted = scope.finish(meter);
if got.as_ref().is_err_and(|e| !e.is_transient()) {
meter.add_work(granted);
}
got.map_err(wrap)
}
}
fn no_entry(i: usize) -> Error {
Error::Malformed {
what: "bundle index",
detail: format!("no row {i}").into(),
}
}
impl BlockInfo {
fn flags_u16(&self) -> u16 {
u16::try_from(self.flags & 0xFFFF).unwrap_or(0)
}
}