disclady 0.4.0

Pure Rust library and CLI utility for optical and storage disc image heuristics, inspection, and format detection (CD, DVD, GDI, Hard Disk, LaserDisc, CHD).
Documentation
//! Hard Disk raw image inspection (compatible with CHD containers).

use crate::types::{
    Confidence, DiscDescriptor, DiscType, Platform, TrackDescriptor, TrackType, VolumeInfo,
};
use std::io::{Read, Seek, SeekFrom};

/// Inspects a seekable stream to detect raw hard disk images.
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(&sector0) {
        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 &sector0[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()
            && &sector1[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(&sector0[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 &sector0[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 &sector0[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(&sector0, 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,
    }
}

/// Inspects sector 0 for known arcade raw hard drive titles and copyright banners.
fn inspect_arcade_hd_banner(sector0: &[u8; 512]) -> Option<&'static str> {
    let slice = &sector0[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
}

/// Validates MBR partition table entries against disk sector count.
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
    }
}

/// Checks if sector 0 represents a FAT12/16/32 Volume Boot Record.
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 = &sector0[54..59] == b"FAT12"
        || &sector0[54..59] == b"FAT16"
        || &sector0[82..87] == b"FAT32";

    is_jmp && bps == 512 && sig && (is_hdd_sized || has_fat_label)
}