use super::error::{ActualIdentity, Error};
use crate::PdbGuid;
use std::io::{Read, Seek, SeekFrom};
pub(super) const SUPERBLOCK_LEN: usize = 56;
const MAGIC: &[u8; 32] = b"Microsoft C/C++ MSF 7.00\r\n\x1aDS\0\0\0";
const NIL: u32 = u32::MAX;
#[derive(Clone, Copy)]
pub(crate) struct Superblock {
pub(super) block_size: u32,
pub(super) num_blocks: u32,
pub(super) directory_bytes: u32,
pub(super) block_map: u32,
}
pub(super) struct PdbStream {
pub(super) size: u32,
pub(super) blocks: Vec<u32>,
}
fn malformed(reason: &'static str) -> Error {
Error::Msf { reason }
}
fn le32(bytes: &[u8], at: usize) -> Result<u32, Error> {
let end = at
.checked_add(4)
.ok_or_else(|| malformed("offset overflow"))?;
let value = bytes
.get(at..end)
.ok_or_else(|| malformed("truncated integer"))?;
Ok(u32::from_le_bytes(
value
.try_into()
.map_err(|_| malformed("truncated integer"))?,
))
}
fn le16(bytes: &[u8], at: usize) -> Result<u16, Error> {
let end = at
.checked_add(2)
.ok_or_else(|| malformed("offset overflow"))?;
let value = bytes
.get(at..end)
.ok_or_else(|| malformed("truncated integer"))?;
Ok(u16::from_le_bytes(
value
.try_into()
.map_err(|_| malformed("truncated integer"))?,
))
}
impl Superblock {
pub(super) fn total(self) -> Result<u64, Error> {
u64::from(self.block_size)
.checked_mul(u64::from(self.num_blocks))
.ok_or_else(|| malformed("file size overflow"))
}
pub(super) fn block_range(self, block: u32) -> Result<(u64, u64), Error> {
check_block(self, block)?;
let start = u64::from(block)
.checked_mul(u64::from(self.block_size))
.ok_or_else(|| malformed("block offset overflow"))?;
let end = start
.checked_add(u64::from(self.block_size))
.and_then(|n| n.checked_sub(1))
.ok_or_else(|| malformed("block range overflow"))?;
Ok((start, end))
}
}
pub(crate) fn parse_superblock(bytes: &[u8]) -> Result<Superblock, Error> {
if bytes.len() < SUPERBLOCK_LEN {
return Err(malformed("truncated superblock"));
}
if &bytes[..32] != MAGIC {
return Err(malformed("wrong MSF 7 magic"));
}
let superblock = Superblock {
block_size: le32(bytes, 32)?,
num_blocks: le32(bytes, 40)?,
directory_bytes: le32(bytes, 44)?,
block_map: le32(bytes, 52)?,
};
if !matches!(superblock.block_size, 512 | 1024 | 2048 | 4096)
|| !matches!(le32(bytes, 36)?, 1 | 2)
|| superblock.num_blocks == 0
|| superblock.block_map >= superblock.num_blocks
{
return Err(malformed("invalid superblock"));
}
Ok(superblock)
}
fn block_count(bytes: u32, block_size: u32) -> Result<usize, Error> {
usize::try_from(u64::from(bytes).div_ceil(u64::from(block_size)))
.map_err(|_| malformed("block count overflow"))
}
fn check_block(superblock: Superblock, block: u32) -> Result<(), Error> {
if block < superblock.num_blocks {
Ok(())
} else {
Err(malformed("block index outside file"))
}
}
pub(super) fn directory_map_len(superblock: Superblock) -> Result<usize, Error> {
let count = block_count(superblock.directory_bytes, superblock.block_size)?;
let bytes = count
.checked_mul(4)
.ok_or_else(|| malformed("map overflow"))?;
if bytes > superblock.block_size as usize {
return Err(malformed("directory map exceeds map block"));
}
Ok(bytes)
}
pub(super) fn directory_blocks(superblock: Superblock, map: &[u8]) -> Result<Vec<u32>, Error> {
let bytes = directory_map_len(superblock)?;
if map.len() != bytes {
return Err(malformed("truncated directory map"));
}
let mut blocks = Vec::with_capacity(bytes / 4);
for at in (0..bytes).step_by(4) {
let block = le32(map, at)?;
check_block(superblock, block)?;
blocks.push(block);
}
Ok(blocks)
}
pub(crate) fn coalesce(superblock: Superblock, blocks: &[u32]) -> Result<Vec<(u64, u64)>, Error> {
let mut blocks = blocks.to_vec();
blocks.sort_unstable();
blocks.dedup();
let mut ranges: Vec<(u64, u64)> = Vec::new();
for block in blocks {
let (start, end) = superblock.block_range(block)?;
if let Some(previous) = ranges.last_mut()
&& previous.1.checked_add(1) == Some(start)
{
previous.1 = end;
continue;
}
ranges.push((start, end));
}
Ok(ranges)
}
pub(super) fn pdb_stream(superblock: Superblock, directory: &[u8]) -> Result<PdbStream, Error> {
let streams =
usize::try_from(le32(directory, 0)?).map_err(|_| malformed("stream count overflow"))?;
if streams < 2 {
return Err(malformed("missing PDB information stream"));
}
let sizes_bytes = streams
.checked_mul(4)
.ok_or_else(|| malformed("stream sizes overflow"))?;
let mut at = 4usize;
let sizes_end = at
.checked_add(sizes_bytes)
.ok_or_else(|| malformed("stream sizes overflow"))?;
if sizes_end > directory.len() {
return Err(malformed("truncated stream sizes"));
}
let mut sizes = Vec::with_capacity(streams);
for offset in (at..sizes_end).step_by(4) {
sizes.push(le32(directory, offset)?);
}
at = sizes_end;
let mut pdb = None;
for (stream, size) in sizes.into_iter().enumerate() {
if size == NIL {
continue;
}
let count = block_count(size, superblock.block_size)?;
let bytes = count
.checked_mul(4)
.ok_or_else(|| malformed("block list overflow"))?;
let end = at
.checked_add(bytes)
.ok_or_else(|| malformed("block list overflow"))?;
if end > directory.len() {
return Err(malformed("truncated stream block list"));
}
let mut blocks = Vec::with_capacity(count);
for offset in (at..end).step_by(4) {
let block = le32(directory, offset)?;
check_block(superblock, block)?;
blocks.push(block);
}
if stream == 1 {
if size < 28 {
return Err(malformed("short PDB information stream"));
}
pdb = Some(PdbStream { size, blocks });
}
at = end;
}
if at != directory.len() {
return Err(malformed("trailing directory bytes"));
}
pdb.ok_or_else(|| malformed("missing PDB information stream"))
}
pub(super) fn header_identity(bytes: &[u8]) -> Result<ActualIdentity, Error> {
if bytes.len() < 28 {
return Err(malformed("short PDB information stream"));
}
if !matches!(
le32(bytes, 0)?,
20_000_404 | 20_030_901 | 20_091_201 | 20_140_508
) {
return Err(malformed("unsupported PDB information version"));
}
Ok(ActualIdentity {
age: le32(bytes, 8)?,
guid: PdbGuid::from_fields(
le32(bytes, 12)?,
le16(bytes, 16)?,
le16(bytes, 18)?,
bytes[20..28]
.try_into()
.map_err(|_| malformed("short GUID"))?,
),
})
}
fn read_at<R: Read + Seek>(reader: &mut R, at: u64, len: usize) -> Result<Vec<u8>, Error> {
reader
.seek(SeekFrom::Start(at))
.map_err(|source| Error::MsfIo {
operation: "seek",
source,
})?;
let mut bytes = vec![0; len];
reader
.read_exact(&mut bytes)
.map_err(|source| Error::MsfIo {
operation: "read",
source,
})?;
Ok(bytes)
}
pub(crate) fn validate<R: Read + Seek>(
reader: &mut R,
length: u64,
) -> Result<ActualIdentity, Error> {
let superblock = parse_superblock(&read_at(reader, 0, SUPERBLOCK_LEN)?)?;
if superblock.total()? != length {
return Err(malformed("file length differs from MSF superblock"));
}
let map_len = directory_map_len(superblock)?;
let (map_start, _) = superblock.block_range(superblock.block_map)?;
let map = read_at(reader, map_start, map_len)?;
let directory_blocks = directory_blocks(superblock, &map)?;
let mut directory = Vec::with_capacity(superblock.directory_bytes as usize);
for block in directory_blocks {
let (start, _) = superblock.block_range(block)?;
directory.extend_from_slice(&read_at(reader, start, superblock.block_size as usize)?);
}
directory.truncate(superblock.directory_bytes as usize);
let pdb = pdb_stream(superblock, &directory)?;
let mut header = Vec::with_capacity(28);
for block in pdb.blocks {
let (start, _) = superblock.block_range(block)?;
header.extend_from_slice(&read_at(reader, start, superblock.block_size as usize)?);
if header.len() >= 28 {
break;
}
}
header_identity(&header)
}