1use super::{Environment, load::Target};
5use crate::{
6 Bytes, Error, File, RawStr,
7 budget::Reservation,
8 detect::{FileType, check_file_type_with_reader, detect_at_position},
9 files::parse_file_with_reader,
10 limits::Meter,
11 stream::ReaderKind,
12};
13
14impl Environment {
15 #[allow(clippy::needless_pass_by_value)]
21 pub fn load_observed(
22 &self,
23 source: super::Source,
24 observe: impl FnOnce(&Bytes, &std::sync::Arc<Meter>) -> Result<(), Error>,
25 ) -> Result<File, Error> {
26 let name = super::source_name(&source);
27 #[cfg(feature = "test-counters")]
28 let load_id = crate::counters::LoadId::draw(&name);
29 let ctx = self.ctx();
30 let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
31 let (data, reader) = super::registry::read_source(&source, &meter, ctx)?;
32 observe(&data, &meter)?;
33 let ty = check_file_type_with_reader(&data, &ctx.limits, reader)?;
34 let parsed = parse_file_with_reader(name.clone(), data, ty, None, &meter, ctx, reader);
35 #[cfg(feature = "test-counters")]
36 crate::testing::adopt(&parsed, || crate::testing::Key::load(load_id));
37 let file = parsed?;
38 let load = self.register_file(&name, &file, &mut Target::Caller)?;
39 self.list(name, file.clone(), false, load, &meter)?;
40 self.inner
41 .loaded
42 .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
43 Ok(file)
44 }
45
46 pub fn parse_reader(
50 &self,
51 name: &RawStr,
52 data: Bytes,
53 reader: ReaderKind,
54 ty: FileType,
55 parent_file: Option<&File>,
56 ) -> Result<File, Error> {
57 self.parse_reader_with_state(name, data, reader, ty, parent_file, &mut None)
58 }
59
60 pub fn parse_reader_with_state(
62 &self,
63 name: &RawStr,
64 data: Bytes,
65 reader: ReaderKind,
66 ty: FileType,
67 parent_file: Option<&File>,
68 endian: &mut Option<crate::stream::Endian>,
69 ) -> Result<File, Error> {
70 use crate::files::{Parent, ParentKind};
71 let ctx = self.ctx();
72 super::within_input_bytes(data.len() as u64, &ctx.limits)?;
73 let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
74 let parent = match parent_file {
75 Some(File::Bundle(file)) => Some(Parent {
76 name: file.name().clone(),
77 kind: ParentKind::Bundle {
78 version_engine: file.header().version_engine.clone(),
79 bundle: std::sync::Arc::downgrade(file),
80 dir_index: usize::MAX,
81 },
82 depth: file.parent().map_or(1, |p| p.depth.saturating_add(1)),
83 pinned: data.len() as u64,
84 }),
85 Some(File::Web(file)) => Some(Parent {
86 name: file.name().clone(),
87 kind: ParentKind::Web {
88 web: std::sync::Arc::downgrade(file),
89 },
90 depth: file.parent().map_or(1, |p| p.depth.saturating_add(1)),
91 pinned: data.len() as u64,
92 }),
93 _ => None,
94 };
95 let file = crate::files::parse_file_with_state(
96 name.clone(),
97 data,
98 ty,
99 parent,
100 &meter,
101 ctx,
102 reader,
103 0,
104 endian,
105 )?;
106 if matches!(file, File::Bundle(_) | File::Web(_)) {
107 self.register_file(name, &file, &mut Target::Caller)?;
108 }
109 Ok(file)
110 }
111
112 pub fn load_reader(
118 &self,
119 name: RawStr,
120 data: Bytes,
121 reader: ReaderKind,
122 is_dependency: bool,
123 ) -> Result<Option<File>, Error> {
124 self.load_reader_at_position(name, data, reader, is_dependency, 0)
125 }
126
127 pub fn load_reader_at_position(
130 &self,
131 name: RawStr,
132 data: Bytes,
133 reader: ReaderKind,
134 is_dependency: bool,
135 position: i128,
136 ) -> Result<Option<File>, Error> {
137 let ctx = self.ctx();
138 super::within_input_bytes(data.len() as u64, &ctx.limits)?;
139 let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
140 let ty = detect_at_position(&data, &ctx.limits, None, reader, position)?;
141 if ty == FileType::Zip {
142 self.load_zip_data(data, &meter)?;
143 self.list_zip_none(name, &meter)?;
144 return Ok(None);
145 }
146 let file = parse_file_with_reader(name.clone(), data, ty, None, &meter, ctx, reader)?;
147 let load = self.register_file(&name, &file, &mut Target::Caller)?;
148 self.list(name, file.clone(), is_dependency, load, &meter)?;
149 self.inner
150 .loaded
151 .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
152 Ok(Some(file))
153 }
154}
155
156#[cfg(test)]
157mod tests {
158 use super::*;
159 use crate::detect::check_file_type_with_reader;
160 #[test]
161 fn forced_web_bypasses_detection_without_listing_a_root_file() {
162 let env = Environment::new(super::super::EnvOptions::unitypy());
163 let data = Bytes::from_static(b"UnityWebData\0\x11\0\0\0");
164 assert_eq!(
165 check_file_type_with_reader(&data, &env.ctx().limits, ReaderKind::Memory).unwrap(),
166 FileType::ResourceFile
167 );
168 let file = env
169 .parse_reader(
170 &"forced".into(),
171 data,
172 ReaderKind::Memory,
173 FileType::WebFile,
174 None,
175 )
176 .unwrap();
177 assert!(matches!(file, File::Web(_)));
178 assert_eq!(env.files().count(), 0);
179 }
180
181 #[test]
182 fn forced_reader_enforces_input_limit_before_parsing() {
183 let mut options = super::super::EnvOptions::unitypy();
184 let mut context = crate::FileContext::unitypy();
185 context.limits.max_input_bytes = 2;
186 options.context = std::sync::Arc::new(context);
187 let env = Environment::new(options);
188 assert!(matches!(
189 env.parse_reader(
190 &"forced".into(),
191 Bytes::from_static(b"raw"),
192 ReaderKind::Memory,
193 FileType::AssetsFile,
194 None,
195 ),
196 Err(Error::Limit(_))
197 ));
198 assert_eq!(env.files().count(), 0);
199 }
200
201 #[test]
202 fn memory_and_stream_origins_keep_their_detection_rules() {
203 let env = Environment::new(super::super::EnvOptions::unitypy());
204 let data = Bytes::from_static(b"AAAAAAAAAAAAAAAAAAAA");
205 assert!(matches!(
206 env.load_reader("memory".into(), data.clone(), ReaderKind::Memory, false),
207 Err(Error::Detect(crate::detect::DetectError::Unterminated))
208 ));
209 let file = env
210 .load_reader("stream".into(), data, ReaderKind::Stream, false)
211 .unwrap()
212 .unwrap();
213 let File::Raw(raw) = file else {
214 panic!("expected raw reader")
215 };
216 assert_eq!(raw.reader_kind(), ReaderKind::Stream);
217 assert_eq!(env.files().count(), 1);
218 }
219 #[test]
220 fn observed_load_sees_exact_joined_split_source_and_its_input_meter() {
221 let tmp = unityrs_testkit::scratch::Scratch::new("observed-split");
222 let data = unityrs_testkit::ngui::file(
223 &[],
224 &[unityrs_testkit::ngui::Object::new(
225 1,
226 49,
227 unityrs_testkit::ngui::st(
228 "TextAsset",
229 vec![("m_Name", unityrs_testkit::ngui::s("snapshot"))],
230 ),
231 )],
232 true,
233 )
234 .unwrap();
235 let split = data.len() / 2;
236 std::fs::write(tmp.join("source.assets.split0"), &data[..split]).unwrap();
237 std::fs::write(tmp.join("source.assets.split1"), &data[split..]).unwrap();
238 for name in ["source.assets", "source.assets.split0"] {
239 let env = Environment::new(super::super::EnvOptions::unitypy());
240 let mut observed = Vec::new();
241 let mut input_meter = None;
242 let file = env
243 .load_observed(
244 super::super::Source::Path(tmp.join(name)),
245 |bytes, meter| {
246 assert_eq!(env.files().count(), 0);
247 observed.extend_from_slice(bytes);
248 input_meter = Some(meter.clone());
249 meter.count_decode(bytes.len() as u64)?;
250 Ok(())
251 },
252 )
253 .unwrap();
254 assert_eq!(observed, data);
255 assert!(matches!(file, File::Serialized(_)));
256 assert!(std::sync::Arc::ptr_eq(file.meter(), &input_meter.unwrap()));
257 assert_eq!(env.files().count(), 1);
258 }
259 }
260
261 #[test]
262 fn observed_load_refusal_happens_before_detection_or_registration() {
263 let mut opts = super::super::EnvOptions::unitypy();
264 let mut context = (*opts.context).clone();
265 context.limits.max_decode_work = 0;
266 opts.context = std::sync::Arc::new(context);
267 let env = Environment::new(opts);
268 let result = env.load_observed(
269 super::super::Source::Bytes {
270 name: "malformed".into(),
271 data: Bytes::from_static(b"AAAAAAAAAAAAAAAAAAAA"),
272 },
273 |_, meter| {
274 meter.count_decode(1)?;
275 Ok(())
276 },
277 );
278 assert!(matches!(result, Err(Error::Limit(e)) if e.kind() == crate::LimitKind::DecodeWork));
279 assert_eq!(env.files().count(), 0);
280 assert_eq!(env.registry().keys().count(), 0);
281 }
282
283 #[test]
284 fn observed_load_sees_compressed_web_source_before_inflation() {
285 let source = unityrs_testkit::web::plain("UnityWebData1.0", &[("entry.resS", &[42; 256])]);
286 let compressed = unityrs_testkit::web::gzip(&source);
287 let env = Environment::new(super::super::EnvOptions::unitypy());
288 let mut observed = Vec::new();
289 let file = env
290 .load_observed(
291 super::super::Source::Bytes {
292 name: "compressed.web".into(),
293 data: Bytes::copy_from_slice(&compressed),
294 },
295 |bytes, _| {
296 observed.extend_from_slice(bytes);
297 Ok(())
298 },
299 )
300 .unwrap();
301 assert_eq!(observed, compressed);
302 let File::Web(web) = file else {
303 panic!("expected WebFile")
304 };
305 assert_eq!(web.data().as_ref(), source);
306 assert_eq!(env.files().count(), 1);
307 }
308}