Share asset decoding validation and reject truncated payloads

This commit is contained in:
2026-10-14 13:08:34 +01:00
parent 418e574ac8
commit bb6f212779
7 changed files with 1024 additions and 308 deletions
@@ -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");
}
}