pdb-bindgen-codegen 0.1.0

Build-time discovery, PDB acquisition, and binding generation for pdb-bindgen.
Documentation
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)
}