Skip to main content

unityrs_core/files/bundle/
write_legacy.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/files/BundleFile.py. See THIRD_PARTY_LICENSES.
2//! Legacy directory and header (`files/BundleFile.py:395-487`). The version
3//! guard is removed for Tier C writing; formats 4+ retain their hash and CRC.
4use super::write::{add, aligned};
5use super::{BundleFile, BundleHeader, LayoutKind};
6use crate::codec::{Codec, encode};
7use crate::files::save::{SaveError, SaveLayout, SaveOptions, Writer, narrow, required};
8use crate::stream::Endian;
9use bytes::Bytes;
10
11impl BundleFile {
12    /// Save UnityRaw or UnityWeb's legacy layout, with one level and a
13    /// directory padded to four bytes. UnityWeb uses a size-prefixed raw
14    /// LZMA1 stream. Format 6 belongs to `save_fs` instead.
15    pub fn save_web_raw(&self, options: SaveOptions) -> Result<Bytes, SaveError> {
16        self.save_web_raw_impl(options, None, &self.header)
17    }
18
19    /// Save legacy layout using caller-owned, metered serialized child snapshots.
20    pub fn save_web_raw_with_entries(
21        &self,
22        options: SaveOptions,
23        entries: &[(crate::RawStr, u32, Bytes)],
24    ) -> Result<Bytes, SaveError> {
25        self.save_web_raw_impl(options, Some(entries), &self.header)
26    }
27
28    /// Save a charged legacy directory and current caller-owned header.
29    pub fn save_web_raw_with_snapshot(
30        &self,
31        options: SaveOptions,
32        entries: &[(crate::RawStr, u32, Bytes)],
33        header: &BundleHeader,
34    ) -> Result<Bytes, SaveError> {
35        self.save_web_raw_impl(options, Some(entries), header)
36    }
37
38    pub(super) fn save_web_raw_impl(
39        &self,
40        options: SaveOptions,
41        entries: Option<&[(crate::RawStr, u32, Bytes)]>,
42        header: &BundleHeader,
43    ) -> Result<Bytes, SaveError> {
44        Self::save_version(header)?;
45        if header.layout != LayoutKind::WebRaw {
46            return Err(SaveError::Unsupported("legacy layout on an FS bundle"));
47        }
48        let mut directory_size = 4usize;
49        let cabs = if entries.is_some() {
50            crate::limits::MeteredVec::new(self.meter())
51        } else {
52            self.writeable_cabs()?
53        };
54        for cab in cabs.as_slice() {
55            cab.validate_name(options.layout, false)?;
56        }
57        for slot in self.files.iter().filter(|_| entries.is_none()) {
58            self.meter().count_decode(8)?;
59            let nul = usize::from(
60                options.layout != SaveLayout::Semantic
61                    || slot.name.len() != crate::stream::STRING_TO_NULL_WINDOW,
62            );
63            directory_size = add(directory_size, add(slot.name.len(), 8 + nul)?)?;
64        }
65        for cab in cabs.as_slice() {
66            let nul = usize::from(
67                options.layout != SaveLayout::Semantic
68                    || cab.name().len() != crate::stream::STRING_TO_NULL_WINDOW,
69            );
70            directory_size = add(directory_size, add(cab.name().len(), 8 + nul)?)?;
71        }
72        if let Some(entries) = entries {
73            for (name, _, _) in entries {
74                self.meter().count_decode(8)?;
75                let nul = usize::from(
76                    options.layout != SaveLayout::Semantic
77                        || name.len() != crate::stream::STRING_TO_NULL_WINDOW,
78                );
79                directory_size = add(directory_size, add(name.len(), 8 + nul)?)?;
80            }
81        }
82        directory_size = aligned(directory_size, 4)?;
83        let mut directory = Writer::metadata(self.meter(), Endian::Big, options.layout)?;
84        let mut payload = Writer::new(self.meter(), Endian::Big)?;
85        directory.count(entries.map_or_else(
86            || add(self.files.len(), cabs.len()),
87            |entries| Ok(entries.len()),
88        )?)?;
89        for slot in self.files.iter().filter(|_| entries.is_none()) {
90            self.meter().count_decode(8)?;
91            let bytes = self.save_child(slot.dir_index, options)?;
92            directory.cstr(slot.name.as_bytes())?;
93            directory.u32(narrow(
94                add(directory_size, payload.len())?,
95                "legacy entry offset",
96            )?)?;
97            directory.u32(narrow(bytes.len(), "legacy entry size")?)?;
98            payload.bytes(&bytes)?;
99        }
100        if let Some(entries) = entries {
101            for (name, _, bytes) in entries {
102                self.meter().count_decode(8)?;
103                directory.cstr(name.as_bytes())?;
104                directory.u32(narrow(
105                    add(directory_size, payload.len())?,
106                    "legacy entry offset",
107                )?)?;
108                directory.u32(narrow(bytes.len(), "legacy entry size")?)?;
109                payload.bytes(bytes)?;
110            }
111        }
112        for cab in cabs.as_slice() {
113            let bytes = cab.save()?;
114            directory.cstr(cab.name().as_bytes())?;
115            directory.u32(narrow(
116                add(directory_size, payload.len())?,
117                "legacy entry offset",
118            )?)?;
119            directory.u32(narrow(bytes.len(), "legacy entry size")?)?;
120            payload.bytes(&bytes)?;
121        }
122        directory.align(4)?;
123        // A full-window last name is followed by its numeric fields, so
124        // there is no unterminated string at the end of this directory.
125        directory.bytes(payload.slice())?;
126        drop(payload);
127        self.save_legacy_content(options, directory_size, directory, header)
128    }
129
130    fn save_legacy_content(
131        &self,
132        options: SaveOptions,
133        directory_size: usize,
134        directory: Writer,
135        header: &BundleHeader,
136    ) -> Result<Bytes, SaveError> {
137        let uncompressed_size = directory.len();
138        let data = if header.signature.as_bytes() == b"UnityWeb" {
139            let compressed = encode::registered_compress(
140                directory.slice(),
141                Codec::Lzma,
142                &self.context().codecs,
143                self.meter(),
144            )?;
145            let mut prefixed = Writer::new(self.meter(), Endian::Little)?;
146            prefixed.bytes(required(compressed.get(..5), "LZMA properties")?)?;
147            prefixed.u64(narrow(uncompressed_size, "LZMA content size")?)?;
148            prefixed.bytes(required(compressed.get(5..), "LZMA stream")?)?;
149            prefixed.finish()?
150        } else {
151            directory.finish()?
152        };
153        let mut out = self.save_header(options, header)?;
154        let version = header.format;
155        let extra = 24
156            + usize::from(version >= 2) * 4
157            + usize::from(version >= 3) * 4
158            + usize::from(version >= 4) * 20;
159        let header_size = aligned(add(out.len(), extra)?, 4)?;
160        let total = narrow(add(header_size, data.len())?, "legacy bundle size")?;
161        if version >= 4 {
162            out.bytes(&required(header.hash, "legacy hash")?)?;
163            out.u32(required(header.crc, "legacy CRC")?)?;
164        }
165        out.u32(total)?;
166        out.u32(narrow(header_size, "legacy header size")?)?;
167        out.u32(1)?;
168        out.i32(1)?;
169        out.u32(narrow(data.len(), "legacy compressed size")?)?;
170        out.u32(narrow(uncompressed_size, "legacy uncompressed size")?)?;
171        if version >= 2 {
172            out.u32(total)?;
173        }
174        if version >= 3 {
175            out.u32(narrow(directory_size, "legacy directory size")?)?;
176        }
177        out.align(4)?;
178        out.bytes(&data)?;
179        out.finish()
180    }
181}