use crate::types::VolumeInfo;
use std::io::{Read, Seek, SeekFrom};
pub const ISO9660_ID: [u8; 5] = *b"CD001";
pub const UDF_BEA01_ID: [u8; 5] = *b"BEA01";
pub const UDF_NSR02_ID: [u8; 5] = *b"NSR02";
pub const UDF_NSR03_ID: [u8; 5] = *b"NSR03";
pub(crate) fn parse_iso_pvd(sector: &[u8]) -> Option<VolumeInfo> {
if sector.len() < 2048 {
return None;
}
if sector[0] != 0x01 || sector[1..6] != ISO9660_ID || sector[6] != 0x01 {
return None;
}
let le_space = u32::from_le_bytes(sector[80..84].try_into().ok()?);
let be_space = u32::from_be_bytes(sector[84..88].try_into().ok()?);
if le_space != be_space || le_space == 0 {
return None;
}
let le_block_size = u16::from_le_bytes(sector[128..130].try_into().ok()?);
let be_block_size = u16::from_be_bytes(sector[130..132].try_into().ok()?);
if le_block_size != be_block_size || le_block_size != 2048 {
return None;
}
let system_id = clean_iso_string(§or[8..40]);
let volume_id = clean_iso_string(§or[40..72]);
let volume_set_id = clean_iso_string(§or[190..318]);
let publisher_id = clean_iso_string(§or[318..446]);
let application_id = clean_iso_string(§or[574..702]);
let volume_opt = if volume_id.is_empty() {
None
} else {
Some(volume_id)
};
let title = volume_opt.clone();
Some(VolumeInfo {
system_identifier: if system_id.is_empty() {
None
} else {
Some(system_id)
},
volume_identifier: volume_opt,
volume_set_identifier: if volume_set_id.is_empty() {
None
} else {
Some(volume_set_id)
},
publisher_identifier: if publisher_id.is_empty() {
None
} else {
Some(publisher_id)
},
application_identifier: if application_id.is_empty() {
None
} else {
Some(application_id)
},
volume_space_size: Some(le_space as u64),
logical_block_size: Some(le_block_size as u32),
has_iso9660: true,
has_udf: false,
has_dvd_video: false,
has_dvd_audio: false,
platform: None,
disc_id: None,
title,
metadata: None,
})
}
pub(crate) fn scan_volume_recognition_sequence<R: Read + Seek>(
reader: &mut R,
sector_size: u32,
) -> (bool, bool) {
let mut has_iso = false;
let mut has_udf = false;
let mut buf = [0u8; 2048];
for sector in 16..32 {
let offset = (sector as u64) * (sector_size as u64);
if reader.seek(SeekFrom::Start(offset)).is_err() {
break;
}
if reader.read_exact(&mut buf).is_err() {
break;
}
if buf[1..6] == ISO9660_ID {
has_iso = true;
} else if buf[1..6] == UDF_BEA01_ID
|| buf[1..6] == UDF_NSR02_ID
|| buf[1..6] == UDF_NSR03_ID
{
has_udf = true;
}
}
(has_iso, has_udf)
}
#[derive(Debug, Clone, Default)]
pub(crate) struct RootDirMetadata {
pub has_video_ts: bool,
pub has_audio_ts: bool,
pub ps_serial: Option<String>,
}
pub(crate) fn scan_root_directory<R: Read + Seek>(
reader: &mut R,
pvd_sector: &[u8],
sector_size: u32,
) -> RootDirMetadata {
let mut meta = RootDirMetadata::default();
if pvd_sector.len() < 2048 {
return meta;
}
let root_record = &pvd_sector[156..190];
let root_lba = u32::from_le_bytes(root_record[2..6].try_into().unwrap_or_default()) as u64;
let root_len = u32::from_le_bytes(root_record[10..14].try_into().unwrap_or_default()) as usize;
if root_lba == 0 || root_len == 0 || root_len > 65536 {
return meta;
}
let root_offset = root_lba * (sector_size as u64);
if reader.seek(SeekFrom::Start(root_offset)).is_err() {
return meta;
}
let mut dir_buf = vec![0u8; root_len];
if reader.read_exact(&mut dir_buf).is_err() {
return meta;
}
let mut system_cnf_record: Option<(u64, usize)> = None;
let mut pos = 0;
while pos < dir_buf.len() {
let len = dir_buf[pos] as usize;
if len == 0 {
pos = (pos + 2048) / 2048 * 2048;
continue;
}
if pos + len > dir_buf.len() || len < 33 {
break;
}
let name_len = dir_buf[pos + 32] as usize;
if pos + 33 + name_len <= dir_buf.len() {
let name_bytes = &dir_buf[pos + 33..pos + 33 + name_len];
if name_bytes.eq_ignore_ascii_case(b"VIDEO_TS")
|| name_bytes.eq_ignore_ascii_case(b"VIDEO_TS;1")
{
meta.has_video_ts = true;
} else if name_bytes.eq_ignore_ascii_case(b"AUDIO_TS")
|| name_bytes.eq_ignore_ascii_case(b"AUDIO_TS;1")
{
meta.has_audio_ts = true;
} else if name_bytes.eq_ignore_ascii_case(b"SYSTEM.CNF")
|| name_bytes.eq_ignore_ascii_case(b"SYSTEM.CNF;1")
{
let cnf_lba =
u32::from_le_bytes(dir_buf[pos + 2..pos + 6].try_into().unwrap_or_default())
as u64;
let cnf_len =
u32::from_le_bytes(dir_buf[pos + 10..pos + 14].try_into().unwrap_or_default())
as usize;
system_cnf_record = Some((cnf_lba, cnf_len));
} else if meta.ps_serial.is_none() {
if let Some(serial) = crate::console::parse_ps_serial(name_bytes) {
meta.ps_serial = Some(serial);
}
}
}
pos += len;
}
if let Some((cnf_lba, cnf_len)) = system_cnf_record {
if cnf_lba > 0 && cnf_len > 0 && cnf_len <= 4096 {
let cnf_offset = cnf_lba * (sector_size as u64);
if reader.seek(SeekFrom::Start(cnf_offset)).is_ok() {
let mut cnf_buf = vec![0u8; cnf_len];
if reader.read_exact(&mut cnf_buf).is_ok() {
if let Some(serial) = crate::console::parse_ps_serial_from_system_cnf(&cnf_buf)
{
meta.ps_serial = Some(serial);
}
}
}
}
}
meta
}
pub(crate) fn check_udf_avdp<R: Read + Seek>(reader: &mut R, sector_size: u32) -> bool {
let offset = 256u64 * (sector_size as u64);
if reader.seek(SeekFrom::Start(offset)).is_err() {
return false;
}
let mut buf = [0u8; 16];
if reader.read_exact(&mut buf).is_err() {
return false;
}
if u16::from_le_bytes([buf[0], buf[1]]) != 0x0002 {
return false;
}
let tag_location = u32::from_le_bytes([buf[8], buf[9], buf[10], buf[11]]);
if tag_location != 256 {
return false;
}
let mut sum: u8 = 0;
for (i, &byte) in buf.iter().enumerate().take(16) {
if i != 4 {
sum = sum.wrapping_add(byte);
}
}
sum == buf[4]
}
fn clean_iso_string(bytes: &[u8]) -> String {
let s = String::from_utf8_lossy(bytes);
s.trim_matches(|c: char| c.is_whitespace() || c == '\0')
.to_string()
}