haggis-rs/src/filetype.rs

use {
    crate::{Error, File, Special},
    std::io::{Read, Write},
};

#[repr(u8)]
pub(crate) enum Flag {
    Normal = 0,
    HardLink = 1,
    SoftLink = 2,
    Directory = 3,
    Character = 4,
    Block = 5,
    Fifo = 6,
    Eof = 7,
}

impl TryFrom<u8> for Flag {
    type Error = Error;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::Normal),
            1 => Ok(Self::HardLink),
            2 => Ok(Self::SoftLink),
            3 => Ok(Self::Directory),
            4 => Ok(Self::Character),
            5 => Ok(Self::Block),
            6 => Ok(Self::Fifo),
            7 => Ok(Self::Eof),
            8 => Err(Error::UnknownFileType),
        }
    }
}

impl From<&FileType> for Flag {
    fn from(value: &FileType) -> Self {
        match value {
            FileType::Normal(_) => Self::Normal,
            FileType::HardLink(_) => Self::HardLink,
            FileType::SoftLink(_) => Self::SoftLink,
            FileType::Directory => Self::Directory,
            FileType::Character(_) => Self::Character,
            FileType::Block(_) => Self::Block,
            FileType::Fifo => Self::Fifo,
            FileType::Eof => Self::Eof,
        }
    }
}

impl Flag {
    pub(crate) fn append_mode(&self, mode: u16) -> u16 {
        let mask: u16 = u16::from(*self as u8) << 13;
        mode & mask
    }
}

/// An enum representing the type of file of an archive member
#[derive(Debug)]
pub enum FileType {
    /// A normal file and it's contained data
    Normal(File),
    /// A hard link to another file in this archive
    HardLink(String),
    /// A soft link to another file
    SoftLink(String),
    /// A directory inode
    Directory,
    /// A character (buffered) device
    Character(Special),
    /// A block device
    Block(Special),
    /// A Unix named pipe (fifo)
    Fifo,
    /// End of archive
    Eof,
}

impl FileType {
    pub(crate) fn read<T: Read>(reader: &mut T, flag: Flag) -> Result<Self, Error> {
        match flag {
            Flag::Normal => {
                let file = File::read(reader)?;
                Ok(Self::Normal(file))
            }
            Flag::HardLink => {
                let mut len = [0; 2];
                reader.read_exact(&mut len)?;
                let len = u16::from_le_bytes(len);
                let mut buf = Vec::with_capacity(len.into());
                let mut handle = reader.take(len.into());
                handle.read_exact(&mut buf)?;
                let s = String::from_utf8(buf)?;
                Ok(Self::HardLink(s))
            }
            Flag::SoftLink => {
                let mut len = [0; 2];
                reader.read_exact(&mut len)?;
                let len = u16::from_le_bytes(len);
                let mut buf = Vec::with_capacity(len.into());
                let mut handle = reader.take(len.into());
                handle.read_exact(&mut buf)?;
                let s = String::from_utf8(buf)?;
                Ok(Self::SoftLink(s))
            }
            Flag::Directory => Ok(Self::Directory),
            Flag::Character => {
                let sp = Special::read(reader)?;
                Ok(Self::Character(sp))
            }
            Flag::Block => {
                let sp = Special::read(reader)?;
                Ok(Self::Block(sp))
            }
            Flag::Fifo => Ok(Self::Fifo),
            Flag::Eof => Ok(Self::Eof),
        }
    }

    pub(crate) fn write<T: Write>(&self, writer: &mut T) -> Result<(), Error> {
        match self {
            Self::Normal(f) => {
                writer.write_all(&[0])?;
                f.write(writer)?;
            }
            Self::HardLink(s) => {
                writer.write_all(&[1])?;
                let len = s.len() as u64;
                writer.write_all(&len.to_le_bytes())?;
                writer.write_all(s.as_bytes())?;
            }
            Self::SoftLink(s) => {
                writer.write_all(&[2])?;
                let len = s.len() as u64;
                writer.write_all(&len.to_le_bytes())?;
                writer.write_all(s.as_bytes())?;
            }
            Self::Directory => writer.write_all(&[3])?,
            Self::Character(s) => {
                writer.write_all(&[4])?;
                s.write(writer)?;
            }
            Self::Block(s) => {
                writer.write_all(&[5])?;
                s.write(writer)?;
            }
            Self::Fifo => writer.write_all(&[6])?,
            Self::Eof => {}
        }
        Ok(())
    }
}