use super::{ParseError, get_u8, get_u16, get_u32, put_u8, put_u16, put_u32};
pub const DIR_TAIL_LEN: usize = 12;
const DIR_TAIL_FT: u8 = 0xde;
#[must_use]
pub fn min_rec_len(name_len: usize) -> u16 {
debug_assert!(name_len <= 255, "a directory name is at most 255 bytes");
(8 + name_len).next_multiple_of(4).min(u16::MAX as usize) as u16
}
#[must_use]
pub fn rec_len_from_disk(disk: u16, block_size: usize) -> usize {
if block_size < 65536 {
return disk as usize;
}
if disk == 0xffff || disk == 0 {
return block_size;
}
(disk as usize & 0xfffc) | ((disk as usize & 3) << 16)
}
#[must_use]
pub fn rec_len_to_disk(len: usize, block_size: usize) -> u16 {
if block_size < 65536 || len < 65536 {
return len as u16;
}
0xffff
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum FileType {
Unknown,
RegFile,
Dir,
CharDev,
BlockDev,
Fifo,
Socket,
Symlink,
}
impl FileType {
#[must_use]
pub const fn to_u8(self) -> u8 {
match self {
FileType::Unknown => 0,
FileType::RegFile => 1,
FileType::Dir => 2,
FileType::CharDev => 3,
FileType::BlockDev => 4,
FileType::Fifo => 5,
FileType::Socket => 6,
FileType::Symlink => 7,
}
}
#[must_use]
pub const fn from_u8(v: u8) -> Self {
match v {
1 => FileType::RegFile,
2 => FileType::Dir,
3 => FileType::CharDev,
4 => FileType::BlockDev,
5 => FileType::Fifo,
6 => FileType::Socket,
7 => FileType::Symlink,
_ => FileType::Unknown,
}
}
#[must_use]
pub const fn from_mode(mode: u16) -> Self {
match mode & 0o170000 {
0o100000 => FileType::RegFile,
0o040000 => FileType::Dir,
0o020000 => FileType::CharDev,
0o060000 => FileType::BlockDev,
0o010000 => FileType::Fifo,
0o140000 => FileType::Socket,
0o120000 => FileType::Symlink,
_ => FileType::Unknown,
}
}
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct DirEntry {
pub inode: u32,
pub file_type: FileType,
pub name: Vec<u8>,
}
impl DirEntry {
pub fn write_to(
&self,
buf: &mut [u8],
rec_len: usize,
block_size: usize,
) -> Result<(), ParseError> {
if self.name.len() > 255 {
return Err(ParseError::InvalidField {
structure: "DirEntry",
field: "name_len",
value: self.name.len() as u64,
});
}
if rec_len < min_rec_len(self.name.len()) as usize || !rec_len.is_multiple_of(4) {
return Err(ParseError::InvalidField {
structure: "DirEntry",
field: "rec_len",
value: rec_len as u64,
});
}
if buf.len() < rec_len {
return Err(ParseError::TooShort {
structure: "DirEntry",
need: rec_len,
got: buf.len(),
});
}
put_u32(buf, 0, self.inode);
put_u16(buf, 4, rec_len_to_disk(rec_len, block_size));
put_u8(buf, 6, self.name.len() as u8);
put_u8(buf, 7, self.file_type.to_u8());
buf[8..8 + self.name.len()].copy_from_slice(&self.name);
Ok(())
}
pub fn read_from(buf: &[u8], block_size: usize) -> Result<(Self, usize), ParseError> {
if buf.len() < 8 {
return Err(ParseError::TooShort {
structure: "DirEntry",
need: 8,
got: buf.len(),
});
}
let inode = get_u32(buf, 0);
let rec_len = rec_len_from_disk(get_u16(buf, 4), block_size);
let name_len = get_u8(buf, 6) as usize;
let file_type = FileType::from_u8(get_u8(buf, 7));
if !rec_len.is_multiple_of(4) || rec_len < 8 + name_len {
return Err(ParseError::InvalidField {
structure: "DirEntry",
field: "rec_len",
value: rec_len as u64,
});
}
if buf.len() < rec_len {
return Err(ParseError::TooShort {
structure: "DirEntry",
need: rec_len,
got: buf.len(),
});
}
Ok((
Self {
inode,
file_type,
name: buf[8..8 + name_len].to_vec(),
},
rec_len,
))
}
}
pub fn write_dir_tail(buf: &mut [u8], checksum: u32) -> Result<(), ParseError> {
if buf.len() < DIR_TAIL_LEN {
return Err(ParseError::TooShort {
structure: "DirEntryTail",
need: DIR_TAIL_LEN,
got: buf.len(),
});
}
put_u32(buf, 0, 0); put_u16(buf, 4, DIR_TAIL_LEN as u16); put_u8(buf, 6, 0); put_u8(buf, 7, DIR_TAIL_FT); put_u32(buf, 8, checksum); Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn min_rec_len_rounds_up_to_four() {
assert_eq!(min_rec_len(1), 12); assert_eq!(min_rec_len(2), 12); assert_eq!(min_rec_len(4), 12); assert_eq!(min_rec_len(5), 16); assert_eq!(min_rec_len(255), 264);
}
#[test]
fn entry_round_trips() {
let e = DirEntry {
inode: 11,
file_type: FileType::Dir,
name: b"lost+found".to_vec(),
};
let mut buf = [0u8; 32];
e.write_to(&mut buf, 20, 4096).unwrap();
let (back, rec_len) = DirEntry::read_from(&buf, 4096).unwrap();
assert_eq!(back, e);
assert_eq!(rec_len, 20);
}
#[test]
fn dot_entries_round_trip() {
for (name, ino) in [(b"." as &[u8], 2u32), (b".." as &[u8], 2u32)] {
let e = DirEntry {
inode: ino,
file_type: FileType::Dir,
name: name.to_vec(),
};
let mut buf = [0u8; 12];
e.write_to(&mut buf, 12, 4096).unwrap();
let (back, rec_len) = DirEntry::read_from(&buf, 4096).unwrap();
assert_eq!(back, e);
assert_eq!(rec_len, 12);
}
}
#[test]
fn oversize_name_and_bad_rec_len_are_rejected() {
let e = DirEntry {
inode: 1,
file_type: FileType::RegFile,
name: vec![b'a'; 300],
};
let mut buf = [0u8; 512];
assert!(matches!(
e.write_to(&mut buf, 320, 4096),
Err(ParseError::InvalidField {
field: "name_len",
..
})
));
let e = DirEntry {
inode: 1,
file_type: FileType::RegFile,
name: b"abc".to_vec(),
};
assert!(matches!(
e.write_to(&mut buf, 10, 4096),
Err(ParseError::InvalidField {
field: "rec_len",
..
})
));
}
#[test]
fn tail_is_a_zero_inode_slot_with_the_marker() {
let mut buf = [0xffu8; DIR_TAIL_LEN];
write_dir_tail(&mut buf, 0).unwrap();
assert_eq!(get_u32(&buf, 0), 0, "reads as an unused slot");
assert_eq!(get_u16(&buf, 4), DIR_TAIL_LEN as u16);
assert_eq!(get_u8(&buf, 6), 0);
assert_eq!(get_u8(&buf, 7), DIR_TAIL_FT);
let (entry, rec_len) = DirEntry::read_from(&buf, 4096).unwrap();
assert_eq!(entry.inode, 0);
assert_eq!(rec_len, DIR_TAIL_LEN);
assert!(entry.name.is_empty());
}
#[test]
fn file_type_from_mode() {
assert_eq!(FileType::from_mode(0o100644), FileType::RegFile);
assert_eq!(FileType::from_mode(0o040755), FileType::Dir);
assert_eq!(FileType::from_mode(0o120777), FileType::Symlink);
assert_eq!(FileType::from_mode(0o020600), FileType::CharDev);
assert_eq!(
FileType::from_u8(FileType::Symlink.to_u8()),
FileType::Symlink
);
}
#[test]
fn rec_len_decodes_the_64k_block_encoding() {
assert_eq!(rec_len_from_disk(20, 4096), 20);
assert_eq!(rec_len_from_disk(0, 4096), 0);
assert_eq!(rec_len_from_disk(0xffff, 4096), 0xffff);
const BS: usize = 65536;
assert_eq!(
rec_len_from_disk(0xffff, BS),
BS,
"sentinel spans the block"
);
assert_eq!(rec_len_from_disk(0, BS), BS, "zero also spans the block");
assert_eq!(
rec_len_from_disk(12, BS),
12,
"a short record decodes plainly"
);
assert_eq!(rec_len_from_disk(0xfffc, BS), 65532);
assert_eq!(rec_len_from_disk(5, BS), 65540);
}
#[test]
fn rec_len_encode_is_the_decode_inverse() {
for &bs in &[1024usize, 2048, 4096] {
for len in (4..=bs).step_by(4) {
assert_eq!(rec_len_to_disk(len, bs) as usize, len);
assert_eq!(rec_len_from_disk(rec_len_to_disk(len, bs), bs), len);
}
}
const BS: usize = 65536;
assert_eq!(rec_len_to_disk(BS, BS), 0xffff);
assert_eq!(rec_len_from_disk(rec_len_to_disk(BS, BS), BS), BS);
for len in [12usize, 4096, 32768, 65532] {
assert_eq!(rec_len_from_disk(rec_len_to_disk(len, BS), BS), len);
}
}
#[test]
fn a_full_block_record_in_a_64k_directory_parses() {
const BS: usize = 65536;
let mut buf = vec![0u8; BS];
put_u16(&mut buf, 4, 0xffff); let (entry, rec_len) = DirEntry::read_from(&buf, BS).expect("the sentinel decodes");
assert_eq!(rec_len, BS, "the record spans the whole 64 KiB block");
assert_eq!(entry.inode, 0);
assert!(entry.name.is_empty());
}
}