unityrs_core/files/bundle/
write_legacy.rs1use 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 pub fn save_web_raw(&self, options: SaveOptions) -> Result<Bytes, SaveError> {
16 self.save_web_raw_impl(options, None, &self.header)
17 }
18
19 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 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 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}