use crate::bytes::{ascii, le_u32, le_u64, u8_at};
use crate::error::RefsError;
use crate::superblock::REFS_SUPERBLOCK_CLUSTER;
pub const REFS_SIGNATURE: &[u8; 8] = b"ReFS\x00\x00\x00\x00";
pub const REFS_FSRS: &[u8; 4] = b"FSRS";
const BOOT_MIN_LEN: usize = 72;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct BootSector {
pub signature: [u8; 8],
pub fsrs: [u8; 4],
pub num_sectors: u64,
pub bytes_per_sector: u32,
pub sectors_per_cluster: u32,
pub major_version: u8,
pub minor_version: u8,
pub volume_serial: u64,
pub container_size: u64,
}
impl BootSector {
pub fn parse(data: &[u8]) -> Result<Self, RefsError> {
let mut signature = [0u8; 8];
if let Some(s) = data.get(3..11) {
signature.copy_from_slice(s);
}
if &signature != REFS_SIGNATURE {
return Err(RefsError::BadSignature { found: signature });
}
let mut fsrs = [0u8; 4];
if let Some(s) = data.get(16..20) {
fsrs.copy_from_slice(s);
}
if &fsrs != REFS_FSRS {
return Err(RefsError::BadFsrs {
found: fsrs,
found_ascii: ascii(&fsrs),
});
}
if data.len() < BOOT_MIN_LEN {
return Err(RefsError::Truncated {
structure: "boot VBR",
need: BOOT_MIN_LEN,
have: data.len(),
});
}
Ok(Self {
signature,
fsrs,
num_sectors: le_u64(data, 24),
bytes_per_sector: le_u32(data, 32),
sectors_per_cluster: le_u32(data, 36),
major_version: u8_at(data, 40),
minor_version: u8_at(data, 41),
volume_serial: le_u64(data, 56),
container_size: le_u64(data, 64),
})
}
#[must_use]
pub fn cluster_size(&self) -> u64 {
u64::from(self.bytes_per_sector).saturating_mul(u64::from(self.sectors_per_cluster))
}
#[must_use]
pub fn is_v3(&self) -> bool {
self.major_version == 3
}
#[must_use]
pub fn superblock_offset(&self) -> u64 {
REFS_SUPERBLOCK_CLUSTER.saturating_mul(self.cluster_size())
}
pub fn require_v3(&self) -> Result<(), RefsError> {
if self.is_v3() {
Ok(())
} else {
Err(RefsError::UnsupportedVersion {
major: self.major_version,
minor: self.minor_version,
})
}
}
}