use crate::types::{
Confidence, DiscDescriptor, DiscType, Platform, TrackDescriptor, TrackType, VolumeInfo,
};
use std::io::{Read, Seek, SeekFrom};
pub fn inspect_harddisk<R: Read + Seek>(reader: &mut R, file_size: u64) -> Option<DiscDescriptor> {
if file_size < 512 || !file_size.is_multiple_of(512) {
return None;
}
if reader.seek(SeekFrom::Start(0)).is_err() {
return None;
}
let mut sector0 = [0u8; 512];
if reader.read_exact(&mut sector0).is_err() {
return None;
}
let total_sectors = file_size / 512;
if let Some(arcade_name) = inspect_arcade_hd_banner(§or0) {
return Some(make_harddisk_descriptor(
Confidence::Definitive,
total_sectors,
file_size,
Platform::ArcadeHardDisk,
Some(arcade_name.to_string()),
format!(
"Arcade Hard Disk image ({arcade_name}): 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
if §or0[0..4] == b"RDSK" {
return Some(make_harddisk_descriptor(
Confidence::Definitive,
total_sectors,
file_size,
Platform::Generic,
Some("Amiga RDB".to_string()),
format!(
"Amiga Rigid Disk Block (RDB) Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
if file_size >= 1024 {
let mut sector1 = [0u8; 512];
if reader.seek(SeekFrom::Start(512)).is_ok()
&& reader.read_exact(&mut sector1).is_ok()
&& §or1[0..8] == b"EFI PART"
{
return Some(make_harddisk_descriptor(
Confidence::Definitive,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"GPT partitioned Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
}
if sector0[510] == 0x55 && sector0[511] == 0xAA {
if let Some(valid_partitions) = validate_mbr_partitions(§or0[446..510], total_sectors) {
return Some(make_harddisk_descriptor(
Confidence::Definitive,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"MBR partitioned Hard Disk image ({} active partitions): 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
valid_partitions,
file_size as f64 / (1024.0 * 1024.0)
),
));
}
if §or0[3..11] == b"NTFS " {
return Some(make_harddisk_descriptor(
Confidence::High,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"Raw NTFS filesystem Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
if §or0[3..11] == b"EXFAT " {
return Some(make_harddisk_descriptor(
Confidence::High,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"Raw exFAT filesystem Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
if is_fat_vbr(§or0, file_size) {
return Some(make_harddisk_descriptor(
Confidence::High,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"Raw FAT filesystem Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
}
if file_size >= 2048 && reader.seek(SeekFrom::Start(1024)).is_ok() {
let mut superblock = [0u8; 1024];
if reader.read_exact(&mut superblock).is_ok()
&& superblock[56] == 0x53
&& superblock[57] == 0xEF
{
return Some(make_harddisk_descriptor(
Confidence::High,
total_sectors,
file_size,
Platform::PcHardDisk,
None,
format!(
"Linux ext2/3/4 filesystem Hard Disk image: 512 bytes/sector, {total_sectors} sectors ({:.2} MiB)",
file_size as f64 / (1024.0 * 1024.0)
),
));
}
}
None
}
fn make_harddisk_descriptor(
confidence: Confidence,
total_sectors: u64,
file_size: u64,
platform: Platform,
volume_id: Option<String>,
summary: String,
) -> DiscDescriptor {
let track = TrackDescriptor {
track_number: 1,
track_type: TrackType::HardDiskSector512,
sector_size: 512,
start_lba: 0,
sector_count: Some(total_sectors),
file_path: None,
pregap_sectors: None,
};
let vol = VolumeInfo {
platform: Some(platform),
volume_identifier: volume_id,
..Default::default()
};
DiscDescriptor {
disc_type: DiscType::HardDisk,
confidence,
primary_sector_size: 512,
total_sectors: Some(total_sectors),
total_size_bytes: Some(file_size),
tracks: vec![track],
volume_info: Some(Box::new(vol)),
summary,
chd_plan: None,
}
}
fn inspect_arcade_hd_banner(sector0: &[u8; 512]) -> Option<&'static str> {
let slice = §or0[0..128];
let contains_needle =
|needle: &[u8]| -> bool { slice.windows(needle.len()).any(|w| w == needle) };
if contains_needle(b"Killer Instinct") || contains_needle(b"Rare Ltd") {
return Some("Killer Instinct");
}
if contains_needle(b"MIDWAY") || contains_needle(b"Midway Games") {
return Some("Midway Arcade");
}
if contains_needle(b"KONAMI") {
return Some("Konami Arcade");
}
if contains_needle(b"NAMCO") {
return Some("Namco Arcade");
}
if contains_needle(b"CAPCOM") {
return Some("Capcom Arcade");
}
if contains_needle(b"SEGA ENTERPRISES") && sector0[0..16] != *b"SEGA SEGAKATANA " {
return Some("Sega Arcade");
}
None
}
fn validate_mbr_partitions(entries: &[u8], total_sectors: u64) -> Option<usize> {
if entries.len() != 64 {
return None;
}
let mut valid_count = 0;
for i in 0..4 {
let entry = &entries[i * 16..(i + 1) * 16];
let status = entry[0];
let part_type = entry[4];
if status != 0x00 && status != 0x80 {
return None;
}
if part_type != 0x00 {
let start_lba = u32::from_le_bytes([entry[8], entry[9], entry[10], entry[11]]) as u64;
let count = u32::from_le_bytes([entry[12], entry[13], entry[14], entry[15]]) as u64;
if count == 0 || start_lba + count > total_sectors.saturating_add(64) {
return None;
}
valid_count += 1;
}
}
if valid_count > 0 {
Some(valid_count)
} else {
None
}
}
fn is_fat_vbr(sector0: &[u8; 512], file_size: u64) -> bool {
let jmp = sector0[0];
let is_jmp = jmp == 0xEB || jmp == 0xE9;
let bps = u16::from_le_bytes([sector0[11], sector0[12]]);
let sig = sector0[510] == 0x55 && sector0[511] == 0xAA;
let is_hdd_sized = file_size >= 10 * 1024 * 1024;
let has_fat_label = §or0[54..59] == b"FAT12"
|| §or0[54..59] == b"FAT16"
|| §or0[82..87] == b"FAT32";
is_jmp && bps == 512 && sig && (is_hdd_sized || has_fat_label)
}