130 lines
3.8 KiB
Rust
130 lines
3.8 KiB
Rust
use {
|
|
crate::{Error, File, Special},
|
|
std::io::{Read, Write},
|
|
};
|
|
|
|
pub(crate) enum Flag {
|
|
Normal,
|
|
HardLink,
|
|
SoftLink,
|
|
Directory,
|
|
Character,
|
|
Block,
|
|
Fifo,
|
|
Eof,
|
|
}
|
|
|
|
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),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 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(())
|
|
}
|
|
}
|