cpt/

structs.rs

use binrw::{binread, BinRead, BinReaderExt};
use bitflags::bitflags;
use macintosh_utils::{chrono, decode_string, FinderFlags, Fork, FourCC};

use crate::entry_reader::{CompressionMethod, StreamDescription};

/// General file header
#[derive(BinRead, Debug)]
#[br(big)]
pub struct ArchiveHeader {
    /// File identifier, 0x01
    pub magic: u8,
    /// Volume number (meaning is not entirely clear, set to `0x01` for single-volume archives)
    pub volume: u8,
    /// Cross-volume magic number (meaning not entirely clear)
    pub cross_volume_magic: u16,
    /// Offset to catalog header from beginning of file
    pub header_offset: u32,
}

impl ArchiveHeader {
    /// Total size of archive header on the wire
    pub const PACKED_SIZE: usize = 8;
}

/// Header describing archive contents
#[binread]
#[derive(Debug)]
#[br(big)]
pub struct CatalogHeader {
    /// CRC-32 of the header
    pub header_checksum: u32,
    /// Total number of files and directories
    pub entry_count: u16,
    /// Archive comment
    #[br(map(macintosh_utils::string))]
    pub comment: String,
}

/// A generic archive entry
#[derive(Debug, Clone)]
pub enum Entry {
    File(File),
    Directory(Directory),
}

impl Entry {
    pub fn name(&self) -> &str {
        match self {
            Entry::File(file_header) => &file_header.name,
            Entry::Directory(dir_header) => &dir_header.name,
        }
    }

    pub fn is_file(&self) -> bool {
        matches!(self, Entry::File(_))
    }

    pub fn is_directory(&self) -> bool {
        matches!(self, Entry::Directory(_))
    }

    pub fn as_file(&self) -> Option<&File> {
        match self {
            Entry::File(file) => Some(file),
            Entry::Directory(_) => None,
        }
    }

    pub fn as_directory(&self) -> Option<&Directory> {
        match self {
            Entry::File(_) => None,
            Entry::Directory(directory) => Some(directory),
        }
    }

    pub(crate) fn spec(&self, fork: Fork) -> StreamDescription {
        match self {
            Entry::File(file) => file.spec(fork),
            Entry::Directory(_) => StreamDescription::default(),
        }
    }
}

impl BinRead for Entry {
    type Args<'a> = ();

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        _: binrw::Endian,
        _: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        let name_len_and_type: u8 = reader.read_be()?;
        let is_directory = (name_len_and_type & 0x80) != 0;
        let name_len = name_len_and_type & !0x80;

        if is_directory {
            Ok(Entry::Directory(reader.read_be_args((name_len,))?))
        } else {
            Ok(Entry::File(reader.read_be_args((name_len,))?))
        }
    }
}

/// File entry
#[derive(BinRead, Debug, Clone)]
#[br(import(name_len: u8), big)]
pub struct File {
    #[br(count(name_len), map(decode_string))]
    pub name: String,
    /// Volume number (meaning not entirely clear)
    pub volume: u8,
    /// Offset to file data from beginning of file
    pub offset: u32,
    /// Mac OS file type code
    pub file_code: FourCC,
    /// Mac OS file creator code
    pub creator_code: FourCC,
    /// Creation date in classic Mac OS format (seconds since 1904)
    #[br(map(macintosh_utils::date))]
    pub created_at: chrono::DateTime<chrono::Utc>,
    /// Modification date in classic Mac OS format (seconds since 1904)
    #[br(map(macintosh_utils::date))]
    pub modified_at: chrono::DateTime<chrono::Utc>,
    /// Mac OS Finder flags
    pub finder_flags: FinderFlags,
    /// Uncompressed file data CRC.
    ///
    /// The value is calculated by concatenating the resource and data forks.
    pub crc32: u32,
    /// File flags
    #[br(map(|v: u16| Flags::from_bits_retain(v)))]
    pub flags: Flags,
    /// Length of uncompressed resource fork in bytes
    pub rsrc_uncompressed_size: u32,
    /// Length of uncompressed data fork in bytes
    pub data_uncompressed_size: u32,
    /// Byte-length of compressed resource data in the archive
    pub rsrc_compressed_size: u32,
    /// Byte-length of compressed data-fork data in the archive
    pub data_compressed_size: u32,
}

impl File {
    pub(crate) fn spec(&self, fork: Fork) -> StreamDescription {
        let method = if fork.is_data() {
            if self.flags.contains(Flags::DATA_LZH_COMPRESSED) {
                CompressionMethod::Lzh
            } else {
                CompressionMethod::Rle
            }
        } else if self.flags.contains(Flags::RSRC_LZH_COMPRESSED) {
            CompressionMethod::Lzh
        } else {
            CompressionMethod::Rle
        };

        match fork {
            Fork::Data => StreamDescription {
                method,
                uncompressed_len: self.data_uncompressed_size as usize,
                _compressed_len: self.data_compressed_size as usize,
                offset: self.offset as u64 + self.rsrc_compressed_size as u64,
            },
            Fork::Resource => StreamDescription {
                method,
                uncompressed_len: self.rsrc_uncompressed_size as usize,
                _compressed_len: self.rsrc_compressed_size as usize,
                offset: self.offset as u64,
            },
        }
    }
}

bitflags! {
    /// Flags describing compressed data streams
    #[derive(Debug, Clone)]
    pub struct Flags: u16 {
        /// Data is encrypted
        const ENCRYPTED = 1<<0;
        /// Resource data uses lzh compression
        const RSRC_LZH_COMPRESSED = 1<<1;
        /// Data-fork data uses lzh compression
        const DATA_LZH_COMPRESSED = 1<<2;
    }
}

/// Directory entry
///
/// Stored data does not include any meta data like creation date or labels
#[derive(BinRead, Debug, Clone)]
#[br(import(name_len: u8), big)]
pub struct Directory {
    #[br(count(name_len), map(decode_string))]
    pub name: String,
    /// Number of children of the directory
    pub child_count: u16,
}