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
//! ISO 9660 Primary Volume Descriptor (PVD), Volume Recognition Sequence (VRS), and UDF parsing.

use crate::types::VolumeInfo;
use std::io::{Read, Seek, SeekFrom};

/// Standard ISO 9660 volume descriptor identifier ("CD001").
pub const ISO9660_ID: [u8; 5] = *b"CD001";

/// UDF Beginning Extended Area Descriptor identifier ("BEA01").
pub const UDF_BEA01_ID: [u8; 5] = *b"BEA01";

/// UDF Non-Sequential Record identifier ("NSR02" - UDF 1.50).
pub const UDF_NSR02_ID: [u8; 5] = *b"NSR02";

/// UDF Non-Sequential Record identifier ("NSR03" - UDF 2.0x).
pub const UDF_NSR03_ID: [u8; 5] = *b"NSR03";

/// Inspects a potential 2048-byte ISO 9660 Primary Volume Descriptor using strict ECMA-119 validation.
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(&sector[8..40]);
    let volume_id = clean_iso_string(&sector[40..72]);
    let volume_set_id = clean_iso_string(&sector[190..318]);
    let publisher_id = clean_iso_string(&sector[318..446]);
    let application_id = clean_iso_string(&sector[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,
    })
}

/// Scans sectors 16 through 31 for ISO 9660 and ECMA-167 / UDF Volume Recognition Sequence tags.
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)
}

/// Discovered filesystem flags and metadata from root directory scanning.
#[derive(Debug, Clone, Default)]
pub(crate) struct RootDirMetadata {
    pub has_video_ts: bool,
    pub has_audio_ts: bool,
    pub ps_serial: Option<String>,
}

/// Scans root directory entries of an ISO 9660 filesystem to look for VIDEO_TS/AUDIO_TS directories
/// and PlayStation boot serials (e.g. SLUS-XXXXX).
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
}

/// Checks for the UDF Anchor Volume Descriptor Pointer (AVDP) at LBA 256.
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()
}