use std::ops::Range;
use std::sync::Arc;
use bytes::Bytes;
use super::counts::DecodeCounts;
use super::decode::{BlockContext, decode_one};
use super::index::{Ends, RunIndex};
use super::{BlockInfo, BundleFile, BundleHeader, DirEntry, FileSlot, LayoutKind};
use crate::codec::Codec;
use crate::codec::unitycn::UnityCnDecryptor;
use crate::counters::Origin;
use crate::detect::raw_by_name;
use crate::error::{Error, Unsupported};
use crate::files::Parent;
use crate::limits::{Charge, Meter, MeteredVec, heap_cost};
use crate::once::ResultCell;
use crate::options::FileContext;
use crate::raw::RawStr;
use crate::stream::{Endian, Reader, ReaderKind};
use crate::typetree::parse::string_to_null;
use crate::version::{
FlagsClass, ResolvedVersion, flags_class, resolve_bundle, uses_block_alignment,
};
impl BundleFile {
pub fn open(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
) -> Result<Arc<Self>, Error> {
Self::open_with_reader(name, data, parent, meter, ctx, ReaderKind::Memory)
}
pub fn open_with_reader(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
reader: ReaderKind,
) -> Result<Arc<Self>, Error> {
Self::open_at_depth(name, data, parent, meter, ctx, reader, 0)
}
#[expect(
clippy::too_many_lines,
reason = "format-gated header, writable CABs and charged container construction"
)]
pub(crate) fn open_at_depth(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
reader: ReaderKind,
source_depth: u32,
) -> Result<Arc<Self>, Error> {
if legacy_layout(&data, reader)? {
return super::legacy::open(name, data, parent, meter, ctx, reader, source_depth);
}
let mut charge = meter.charge(heap_cost((size_of::<Self>() + 16) as u64))?;
let mut r = Reader::with_kind(&data, Endian::Big, reader);
let FsHeader {
signature,
format,
version_player,
version_engine,
info_compressed,
info_uncompressed,
data_flags,
engine,
class,
encrypted,
block_alignment,
unitycn,
} = read_fs_header(&mut r, &data, &mut charge, ctx)?;
let blocks_ctx = BlockContext::new(ctx, encrypted, unitycn);
let start = r.position();
let info_range = if data_flags & 0x80 != 0 {
let len = i128::try_from(data.len()).unwrap_or(i128::MAX);
r.set_position(len - i128::from(info_compressed))?;
let range = r.read_range(i64::from(info_compressed))?;
r.set_position(start)?;
range
} else {
r.read_range(i64::from(info_compressed))?
};
let info_read = u32::try_from(info_range.len()).unwrap_or(u32::MAX);
let blocks_info = BlockInfo {
uncompressed: info_uncompressed,
compressed: info_compressed,
bytes_read: info_read,
flags: data_flags,
};
let info = decode_one(
&blocks_ctx,
meter,
data.slice(info_range),
info_uncompressed,
data_flags,
0,
)?;
let (mut blocks, directory, offsets) = read_blocks_info(&info, format, meter)?;
if class == FlagsClass::New && data_flags & 0x200 != 0 {
r.align(16)?;
}
let (stored, lengths) = stored_blocks(&mut blocks, &offsets, &mut r, meter, ctx)?;
let files = files_dict(&directory, meter)?;
let entries = entry_cells(directory.len(), meter)?;
let header = BundleHeader {
signature,
format,
version_player,
version_engine,
layout: LayoutKind::Fs,
engine_version: Some(Ok(engine)),
data_flags: Some(data_flags),
flags_class: Some(class),
block_alignment,
encrypted,
hash: None,
crc: None,
blocks_info: Some(blocks_info),
};
let blocks = keep(blocks, &mut charge)?;
let directory = keep(directory, &mut charge)?;
let files = keep(files, &mut charge)?;
let lengths = keep(lengths, &mut charge)?;
let entries = keep(entries, &mut charge)?;
let twins = keep(twins(&directory, meter)?, &mut charge)?;
let stored = keep(stored, &mut charge)?;
let (ends, c) = Ends::new(blocks.len(), meter)?;
charge.absorb(c);
let runs = RunIndex::mutex(&mut charge)?;
let constructor_position = r.position();
Ok(Arc::new_cyclic(|this| Self {
writable: crate::files::cab::WritableCabs::new(meter),
changed: std::sync::atomic::AtomicBool::new(false),
name,
source: data,
constructor_position,
legacy_data: None,
header,
blocks,
directory,
files,
parent,
dependency_path: crate::files::DependencyPath::default(),
source_depth,
lengths,
ends,
runs,
counts: DecodeCounts::default(),
entries,
twins,
charge,
ctx: blocks_ctx,
stored,
this: this.clone(),
origin: Origin::opened(),
}))
}
}
#[allow(clippy::type_complexity)]
fn stored_blocks(
blocks: &mut MeteredVec<BlockInfo>,
offsets: &MeteredVec<u64>,
r: &mut Reader<'_>,
meter: &Arc<Meter>,
ctx: &FileContext,
) -> Result<(MeteredVec<Range<usize>>, MeteredVec<ResultCell<u64, Error>>), Error> {
let mut stored = MeteredVec::new(meter);
let mut lengths = MeteredVec::new(meter);
let base = r.position();
for (i, b) in blocks.as_mut_slice().iter_mut().enumerate() {
if let Some(offset) = offsets.as_slice().get(i) {
r.set_position(base + i128::from(*offset))?;
}
let range = r.read_range(i64::from(b.compressed))?;
b.bytes_read = u32::try_from(range.len()).unwrap_or(u32::MAX);
stored.push(range)?;
let cell = ResultCell::new();
if known_at_open(b, ctx) {
let _ = cell.set(Ok(u64::from(b.bytes_read)));
}
lengths.push(cell)?;
}
Ok((stored, lengths))
}
pub(super) fn known_at_open(b: &BlockInfo, ctx: &FileContext) -> bool {
ctx.codecs.stores_as_is()
&& Codec::from_flags(u32::from(b.flags_u16())) == Codec::None
&& u64::from(b.bytes_read) <= ctx.limits.max_block_output
}
struct FsHeader {
signature: RawStr,
format: u32,
version_player: RawStr,
version_engine: RawStr,
info_compressed: u32,
info_uncompressed: u32,
data_flags: u32,
engine: ResolvedVersion,
class: FlagsClass,
encrypted: bool,
block_alignment: bool,
unitycn: Option<UnityCnDecryptor>,
}
fn read_fs_header(
r: &mut Reader<'_>,
data: &Bytes,
charge: &mut Charge,
ctx: &FileContext,
) -> Result<FsHeader, Error> {
let meter = charge.meter().clone();
let meter = &meter;
let signature = string_to_null(r, data, meter)?;
let format = r.read_u32()?;
let version_player = string_to_null(r, data, meter)?;
let version_engine = string_to_null(r, data, meter)?;
match signature.as_bytes() {
b"UnityArchive" => return Err(Error::Unsupported(Unsupported::UnityArchive)),
b"UnityWeb" | b"UnityRaw" if format != 6 => {
return Err(Error::Unsupported(Unsupported::WebRawLayout));
}
b"UnityWeb" | b"UnityRaw" | b"UnityFS" => {}
_ => {
return Err(Error::BundleSignature(RawStr::charged(
signature.as_bytes(),
meter,
)?));
}
}
let _size = r.read_i64()?;
let info_compressed = r.read_u32()?;
let info_uncompressed = r.read_u32()?;
let data_flags = r.read_u32()?;
if signature.as_bytes() != b"UnityFS" {
r.read_i8()?;
}
let engine = resolve_bundle(&version_engine, &ctx.version_policy(), charge)?;
let class = flags_class(&engine.version)?;
let mask = match class {
FlagsClass::Old => 0x200,
FlagsClass::New => 0x1400,
};
let encrypted = data_flags & mask != 0;
let unitycn = if encrypted {
if ctx.decryptor.is_some() {
r.read_u32()?;
for _ in 0..2 {
r.read_bytes_short(32);
r.set_position(r.position() + 1)?;
}
None
} else {
Some(UnityCnDecryptor::read_with_key(r, || {
ctx.runtime_config
.as_ref()
.map_or(Ok(ctx.assetbundle_decrypt_key), |config| {
config
.resolve_decrypt_key(charge.meter())
.map(|key| key.or(ctx.assetbundle_decrypt_key))
.map_err(Error::from)
})
})?)
}
} else {
None
};
let block_alignment = uses_block_alignment(format, &engine.version)?;
if block_alignment {
r.align(16)?;
}
Ok(FsHeader {
signature,
format,
version_player,
version_engine,
info_compressed,
info_uncompressed,
data_flags,
engine,
class,
encrypted,
block_alignment,
unitycn,
})
}
#[allow(clippy::type_complexity)]
fn read_blocks_info(
info: &Bytes,
format: u32,
meter: &Arc<Meter>,
) -> Result<(MeteredVec<BlockInfo>, MeteredVec<DirEntry>, MeteredVec<u64>), Error> {
let mut r = Reader::new(info, Endian::Big);
r.read_bytes_short(16);
let mut blocks = MeteredVec::new(meter);
let mut offsets = MeteredVec::new(meter);
for _ in 0..r.read_i32()?.max(0) {
let uncompressed = r.read_u32()?;
let compressed = r.read_u32()?;
let flags = u32::from(r.read_u16()?);
if format >= 9 {
offsets.push(r.read_u64()?)?;
}
blocks.push(BlockInfo {
uncompressed,
compressed,
bytes_read: 0,
flags,
})?;
}
let mut directory = MeteredVec::new(meter);
for _ in 0..r.read_i32()?.max(0) {
let offset = r.read_i64()?;
let size = r.read_i64()?;
let flags = r.read_u32()?;
let path = string_to_null(&mut r, info, meter)?;
directory.push(DirEntry {
offset,
size,
flags: Some(flags),
path,
})?;
}
Ok((blocks, directory, offsets))
}
pub(crate) fn files_dict(
dir: &MeteredVec<DirEntry>,
meter: &Arc<Meter>,
) -> Result<MeteredVec<FileSlot>, Error> {
let rows = dir.as_slice();
let mut perm: MeteredVec<usize> = MeteredVec::with_capacity(meter, rows.len())?;
for i in 0..rows.len() {
perm.push(i)?;
}
let path = |i: &usize| rows.get(*i).map(|d| d.path.as_bytes()).unwrap_or_default();
perm.as_mut_slice()
.sort_unstable_by(|a, b| path(a).cmp(path(b)).then(a.cmp(b)));
let mut groups: MeteredVec<(usize, usize)> = MeteredVec::new(meter);
let all = perm.as_slice();
let mut at = 0;
while let Some(first) = all.get(at) {
let mut last = *first;
let mut end = at + 1;
while let Some(next) = all.get(end).filter(|n| path(n) == path(first)) {
last = *next;
end += 1;
}
groups.push((*first, last))?;
at = end;
}
groups.as_mut_slice().sort_unstable_by_key(|g| g.0);
let mut files = MeteredVec::with_capacity(meter, groups.len())?;
for (first, last) in groups.as_slice() {
files.push(FileSlot {
name: rows.get(*first).map(|d| d.path.clone()).unwrap_or_default(),
dir_index: *last,
})?;
}
Ok(files)
}
pub(super) fn twins(rows: &[DirEntry], meter: &Arc<Meter>) -> Result<MeteredVec<u32>, Error> {
let mut keys: MeteredVec<(i64, i64, bool, u32)> = MeteredVec::with_capacity(meter, rows.len())?;
let mut twins: MeteredVec<u32> = MeteredVec::with_capacity(meter, rows.len())?;
for (i, d) in rows.iter().enumerate() {
let i = u32::try_from(i).unwrap_or(u32::MAX);
keys.push((d.offset, d.size, raw_by_name(d.path.as_bytes()), i))?;
twins.push(i)?;
}
keys.as_mut_slice().sort_unstable();
let mut first = None;
for &(offset, size, raw, i) in keys.as_slice() {
match first {
Some((key, f)) if key == (offset, size, raw) => {
if let Some(t) = usize::try_from(i)
.ok()
.and_then(|i| twins.as_mut_slice().get_mut(i))
{
*t = f;
}
}
_ => first = Some(((offset, size, raw), i)),
}
}
Ok(twins)
}
pub(crate) fn keep<T>(table: MeteredVec<T>, charge: &mut Charge) -> Result<Box<[T]>, Error> {
let (b, c) = table.into_boxed_slice()?;
charge.absorb(c);
Ok(b)
}
fn legacy_layout(data: &Bytes, kind: ReaderKind) -> Result<bool, Error> {
if !(data.starts_with(b"UnityWeb\0") || data.starts_with(b"UnityRaw\0")) {
return Ok(false);
}
let mut r = Reader::with_kind(data, Endian::Big, kind);
r.set_position(9)?;
Ok(r.read_u32()? != 6)
}
fn entry_cells(
n: usize,
meter: &Arc<Meter>,
) -> Result<MeteredVec<super::super::teardown::FileCell>, Error> {
let mut cells = MeteredVec::new(meter);
for _ in 0..n {
cells.push(super::super::teardown::FileCell::new())?;
}
Ok(cells)
}