Share asset decoding validation and reject truncated payloads
This commit is contained in:
@@ -885,3 +885,232 @@ fn ending_a_session_releases_a_completed_unconsumed_request() {
|
||||
assert!(s.take_idle_card().unwrap().is_some());
|
||||
controller.stop().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
||||
use crate::memcard::session::{RequestState, Session};
|
||||
use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController};
|
||||
use prometeu_drivers::{
|
||||
AssetManager, GlyphBankPoolAccess, MemoryBanks, SceneBankPoolAccess, SoundBankPoolAccess,
|
||||
};
|
||||
use prometeu_hal::{
|
||||
AssetBridge,
|
||||
asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus},
|
||||
background_work::{AssetWork, BackgroundWork, WorkUnavailable},
|
||||
cartridge::AssetsPayloadSource,
|
||||
};
|
||||
use std::{
|
||||
sync::mpsc,
|
||||
thread,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
type Events = Arc<Mutex<Vec<(&'static str, thread::ThreadId)>>>;
|
||||
struct ObservedLane {
|
||||
lane: Arc<AsyncWorkLane>,
|
||||
events: Events,
|
||||
paused: mpsc::Sender<()>,
|
||||
resume: Mutex<Option<mpsc::Receiver<()>>>,
|
||||
}
|
||||
impl BackgroundWork for ObservedLane {
|
||||
fn submit_asset(&self, mut work: AssetWork) -> std::result::Result<(), WorkUnavailable> {
|
||||
let events = self.events.clone();
|
||||
let paused = self.paused.clone();
|
||||
let resume = self.resume.lock().unwrap().take().unwrap();
|
||||
let mut step = 0;
|
||||
self.lane.submit_asset(Box::new(move |canceled| {
|
||||
let result = work(canceled);
|
||||
step += 1;
|
||||
events.lock().unwrap().push(("asset", thread::current().id()));
|
||||
if step == 4 {
|
||||
paused.send(()).unwrap();
|
||||
resume.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||
}
|
||||
result
|
||||
}))
|
||||
}
|
||||
}
|
||||
struct ObservedStore {
|
||||
inner: Store,
|
||||
events: Events,
|
||||
}
|
||||
impl MemcardStorage for ObservedStore {
|
||||
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
||||
self.inner.len()
|
||||
}
|
||||
fn read_only(&self) -> bool {
|
||||
false
|
||||
}
|
||||
fn read_at(
|
||||
&mut self,
|
||||
offset: u64,
|
||||
out: &mut [u8],
|
||||
) -> std::result::Result<(), MemcardIoError> {
|
||||
self.inner.read_at(offset, out)
|
||||
}
|
||||
fn write_at(
|
||||
&mut self,
|
||||
offset: u64,
|
||||
bytes: &[u8],
|
||||
) -> std::result::Result<(), MemcardIoError> {
|
||||
self.events.lock().unwrap().push(("save write", thread::current().id()));
|
||||
self.inner.write_at(offset, bytes)
|
||||
}
|
||||
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
||||
self.events.lock().unwrap().push(("save sync", thread::current().id()));
|
||||
self.inner.sync()
|
||||
}
|
||||
}
|
||||
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] {
|
||||
let (card, disk) = formatted();
|
||||
drop(card);
|
||||
let events: Events = Arc::default();
|
||||
let mut card = Card::mount(Box::new(ObservedStore {
|
||||
inner: Store(disk.clone()),
|
||||
events: events.clone(),
|
||||
}))
|
||||
.unwrap();
|
||||
add(&mut card, 1, 1);
|
||||
let mut session = Session::default();
|
||||
let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap();
|
||||
session.write(context, 0, 0, b"persistent under asset pressure").unwrap();
|
||||
events.lock().unwrap().clear();
|
||||
let (bytes, decoded_size, metadata) = match kind {
|
||||
BankType::GLYPH => {
|
||||
let mut bytes = vec![0x12; 16384];
|
||||
bytes.extend([255; 64]);
|
||||
(
|
||||
bytes,
|
||||
32768 + 64,
|
||||
serde_json::json!({"tile_size":8,"width":256,"height":128,"palette_count":1,"palette_authored":1}),
|
||||
)
|
||||
}
|
||||
BankType::SOUNDS => {
|
||||
(vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1}))
|
||||
}
|
||||
BankType::SCENE => {
|
||||
let mut bytes = vec![0; 140];
|
||||
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
||||
for start in [12, 44, 76, 108] {
|
||||
bytes[start + 5] = 8;
|
||||
}
|
||||
bytes[12] = 1;
|
||||
bytes[28..32].copy_from_slice(&4097_u32.to_le_bytes());
|
||||
bytes[32..36].copy_from_slice(&1_u32.to_le_bytes());
|
||||
bytes[36..40].copy_from_slice(&4097_u32.to_le_bytes());
|
||||
bytes.splice(44..44, std::iter::repeat_n([7, 3, 0x34, 0x12], 4097).flatten());
|
||||
(
|
||||
bytes,
|
||||
64 + 4097 * size_of::<prometeu_hal::tile::Tile>() as u64,
|
||||
serde_json::json!({}),
|
||||
)
|
||||
}
|
||||
};
|
||||
let entry = AssetEntry {
|
||||
asset_id: 1,
|
||||
asset_name: "pressure".into(),
|
||||
bank_type: kind,
|
||||
offset: 0,
|
||||
size: bytes.len() as u64,
|
||||
decoded_size,
|
||||
codec: AssetCodec::None,
|
||||
metadata,
|
||||
};
|
||||
let banks = Arc::new(MemoryBanks::new());
|
||||
let mut manager = AssetManager::new(
|
||||
vec![entry],
|
||||
AssetsPayloadSource::from_bytes(bytes),
|
||||
banks.clone(),
|
||||
banks.clone(),
|
||||
banks.clone(),
|
||||
);
|
||||
let lane = Arc::new(AsyncWorkLane::default());
|
||||
let (paused_tx, paused_rx) = mpsc::channel();
|
||||
let (resume_tx, resume_rx) = mpsc::channel();
|
||||
let observed = Arc::new(ObservedLane {
|
||||
lane: lane.clone(),
|
||||
events: events.clone(),
|
||||
paused: paused_tx,
|
||||
resume: Mutex::new(Some(resume_rx)),
|
||||
});
|
||||
assert!(manager.bind_background_work(observed));
|
||||
let mut controller =
|
||||
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
||||
let handle = manager.load(1, 0).unwrap();
|
||||
paused_rx.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||
assert_eq!(manager.status(handle), LoadStatus::LOADING);
|
||||
assert!(
|
||||
banks.glyph_bank_slot(0).is_none()
|
||||
&& banks.sound_bank_slot(0).is_none()
|
||||
&& banks.scene_bank_slot(0).is_none()
|
||||
);
|
||||
let request = session.commit(context, 0, 7, Instant::now(), &lane).unwrap();
|
||||
resume_tx.send(()).unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
loop {
|
||||
session.poll(Instant::now());
|
||||
if session.query(context, request).unwrap().state != RequestState::Pending
|
||||
&& manager.status(handle) == LoadStatus::READY
|
||||
{
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "save/asset did not complete for {kind:?}");
|
||||
thread::yield_now();
|
||||
}
|
||||
assert_eq!(session.query(context, request).unwrap().state, RequestState::Success);
|
||||
assert!(
|
||||
banks.glyph_bank_slot(0).is_none()
|
||||
&& banks.sound_bank_slot(0).is_none()
|
||||
&& banks.scene_bank_slot(0).is_none()
|
||||
);
|
||||
assert_eq!(manager.commit(handle), AssetOpStatus::Ok);
|
||||
manager.apply_commits();
|
||||
match kind {
|
||||
BankType::GLYPH => {
|
||||
let bank = banks.glyph_bank_slot(0).unwrap();
|
||||
assert_eq!((bank.width, bank.height), (256, 128));
|
||||
assert_eq!(
|
||||
bank.pixel_indices,
|
||||
(0..32768).map(|i| 1 + (i % 2) as u8).collect::<Vec<_>>()
|
||||
);
|
||||
assert!(bank.palettes[0].iter().all(|c| c.raw() == 0xffffffff));
|
||||
}
|
||||
BankType::SOUNDS => {
|
||||
let bank = banks.sound_bank_slot(0).unwrap();
|
||||
assert_eq!(bank.samples[0].sample_rate, 44100);
|
||||
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
|
||||
}
|
||||
BankType::SCENE => {
|
||||
let bank = banks.scene_bank_slot(0).unwrap();
|
||||
assert_eq!(
|
||||
(bank.layers[0].tilemap.width, bank.layers[0].tilemap.height),
|
||||
(4097, 1)
|
||||
);
|
||||
assert!(bank.layers[0].active);
|
||||
assert_eq!(bank.layers[0].tilemap.tiles.len(), 4097);
|
||||
assert!(bank.layers[0].tilemap.tiles.iter().all(|t| t.active
|
||||
&& t.flip_x
|
||||
&& t.flip_y
|
||||
&& t.glyph.glyph_id == 0x1234
|
||||
&& t.glyph.palette_id == 3));
|
||||
assert!(bank.layers[1..].iter().all(|l| l.tilemap.tiles.is_empty()));
|
||||
}
|
||||
}
|
||||
controller.stop().unwrap();
|
||||
let observed = events.lock().unwrap();
|
||||
assert_eq!(observed[..4].iter().map(|e| e.0).collect::<Vec<_>>(), vec!["asset"; 4]);
|
||||
assert_eq!(observed[4].0, "save write");
|
||||
let resumed = observed[4..].iter().position(|e| e.0 == "asset").unwrap() + 4;
|
||||
assert_eq!(observed[resumed - 1].0, "save sync");
|
||||
assert!(observed[resumed..].iter().all(|e| e.0 == "asset"));
|
||||
let worker = observed[0].1;
|
||||
assert_ne!(worker, thread::current().id());
|
||||
assert!(observed.iter().all(|e| e.1 == worker));
|
||||
drop(observed);
|
||||
drop(session);
|
||||
let mut recovered = Session::default();
|
||||
let c = recovered.load_card(reboot(&disk), 1, 1, 1024 * 1024).unwrap();
|
||||
let mut saved = [0; 64];
|
||||
let n = recovered.read(c, 0, 0, &mut saved).unwrap();
|
||||
assert_eq!(&saved[..n], b"persistent under asset pressure");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user