cfb.rs

//! 複合ファイルの容れ物 (MS-CFB)
//!
//! .doc、.xls、.ppt はどれも、この容れ物の中にストリームを並べたものである。
//! ZIP がパートを並べるのと同じ役目だが、作りはファイルシステムに近い。
//! 中身をセクタに切り、次のセクタの番号をつないだ表 (FAT) でたどる。
//!
//! # 小さいストリーム
//!
//! セクタは 512 バイト (版によっては 4096) あるので、小さなストリームを 1 つずつ入れると
//! 隙間だらけになる。そこで 4096 バイトに満たないものは、64 バイトずつに切って
//! ミニストリームという 1 本のストリームにまとめ、別の表 (ミニ FAT) でたどる。

use crate::error::Error;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
use std::path::Path;


/// 複合ファイルの印
const SIGNATURE: [u8; 8] = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];

/// つながりの終わり
const END: u32 = 0xfffffffe;

/// 使っていないセクタ
const FREE: u32 = 0xffffffff;

/// ミニストリームの 1 かたまり
const MINI: usize = 64;

/// ディレクトリの 1 項目の大きさ
const ENTRY: usize = 128;


/// 中に入っているストリームや入れ物
#[derive(Debug, Clone)]
pub struct Item {
    /// 名前
    pub name: String,
    /// 種類。1 が入れ物、2 がストリーム、5 が根
    pub kind: u8,
    /// 最初のセクタ
    start: u32,
    /// 長さ
    pub size: u64,
}


/// 読むために開いた複合ファイル
pub struct Compound {
    file: File,
    /// セクタの大きさ
    sector: usize,
    /// セクタのつながり
    fat: Vec<u32>,
    /// ミニストリームのつながり
    mini_fat: Vec<u32>,
    /// ミニストリームの中身
    mini: Vec<u8>,
    /// これより小さいものはミニストリームに入る
    cutoff: u64,
    /// 根の直下にあるもの
    item: Vec<Item>,
    place: HashMap<String, usize>,
}


impl Compound {
    /// ファイルを開いて、入っているものを読む
    pub fn open(path: &Path) -> Result<Compound, Error> {
        let mut file = File::open(path)?;
        let mut header = [0u8; 512];
        file.read_exact(&mut header)?;

        if header[..8] != SIGNATURE {
            return Err(Error::new("複合ファイルの印が見つかりません"));
        }

        let shift = u16(&header, 30)? as u32;

        if shift != 9 && shift != 12 {
            return Err(Error::new(format!("知らないセクタの大きさです (2 の {shift} 乗)")));
        }

        let sector = 1usize << shift;
        let cutoff = u32(&header, 56)? as u64;
        let fat_count = u32(&header, 44)? as usize;
        let mut chain = Vec::with_capacity(fat_count);

        for index in 0..109.min(fat_count) {
            chain.push(u32(&header, 76 + index * 4)?);
        }

        // 109 個で足りないときは、続きが別のセクタに並んでいる
        let mut next = u32(&header, 68)?;
        let per = sector / 4 - 1;

        while next != END && next != FREE && chain.len() < fat_count {
            let piece = read_sector(&mut file, sector, next)?;

            for index in 0..per {
                if chain.len() >= fat_count {
                    break;
                }

                chain.push(u32(&piece, index * 4)?);
            }

            next = u32(&piece, per * 4)?;
        }

        let mut fat = Vec::with_capacity(chain.len() * sector / 4);

        for one in &chain {
            let piece = read_sector(&mut file, sector, *one)?;

            for index in 0..sector / 4 {
                fat.push(u32(&piece, index * 4)?);
            }
        }

        let mut result = Compound {
            file,
            sector,
            fat,
            mini_fat: Vec::new(),
            mini: Vec::new(),
            cutoff,
            item: Vec::new(),
            place: HashMap::new(),
        };

        let mini_start = u32(&header, 60)?;
        let mini_count = u32(&header, 64)? as usize;
        result.mini_fat = result.read_links(mini_start, mini_count)?;

        let directory = u32(&header, 48)?;
        let region = result.follow(directory, u64::MAX)?;
        let all = read_directory(&region)?;

        if all.is_empty() {
            return Err(Error::new("複合ファイルに何も入っていません"));
        }

        // 根の中身がミニストリームである
        result.mini = result.follow(all[0].start, all[0].size)?;
        let child = u32(&region, 76)?;
        result.item = gather(&region, &all, child)?;

        for (index, one) in result.item.iter().enumerate() {
            result.place.insert(one.name.clone(), index);
        }

        Ok(result)
    }

    /// 先頭にあるものの一覧
    pub fn item(&self) -> &[Item] {
        &self.item
    }

    /// その名前のストリームがあるか
    pub fn has(&self, name: &str) -> bool {
        self.place.contains_key(name)
    }

    /// ストリームの中身を全部読む
    pub fn read(&mut self, name: &str) -> Result<Vec<u8>, Error> {
        let Some(index) = self.place.get(name) else {
            return Err(Error::at("ストリームが見つかりません", name));
        };

        let one = self.item[*index].clone();

        if one.size < self.cutoff {
            return read_mini(&self.mini, &self.mini_fat, one.start, one.size)
                .map_err(|error| error.within(&one.name));
        }

        self.follow(one.start, one.size).map_err(|error| error.within(&one.name))
    }

    /// つながりをたどって中身を集める
    fn follow(&mut self, start: u32, size: u64) -> Result<Vec<u8>, Error> {
        let mut result = Vec::new();
        let mut next = start;
        let mut seen = 0;

        while next != END && next != FREE {
            if next as usize >= self.fat.len() {
                return Err(Error::new("複合ファイルのつながりが範囲を超えています"));
            }

            let piece = read_sector(&mut self.file, self.sector, next)?;
            result.extend_from_slice(&piece);
            next = self.fat[next as usize];
            seen += 1;

            if seen > self.fat.len() {
                return Err(Error::new("複合ファイルのつながりが輪になっています"));
            }
        }

        if size != u64::MAX && (size as usize) < result.len() {
            result.truncate(size as usize);
        }

        Ok(result)
    }

    /// 表そのものを読む
    fn read_links(&mut self, start: u32, count: usize) -> Result<Vec<u32>, Error> {
        let mut result = Vec::with_capacity(count * self.sector / 4);
        let mut next = start;
        let mut seen = 0;

        while next != END && next != FREE && seen < count {
            let piece = read_sector(&mut self.file, self.sector, next)?;

            for index in 0..self.sector / 4 {
                result.push(u32(&piece, index * 4)?);
            }

            if next as usize >= self.fat.len() {
                break;
            }

            next = self.fat[next as usize];
            seen += 1;
        }

        Ok(result)
    }
}


/// 先頭が複合ファイルかどうか
pub fn is_compound(path: &Path) -> bool {
    let Ok(mut file) = File::open(path) else {
        return false;
    };

    let mut head = [0u8; 8];

    match file.read_exact(&mut head) {
        Ok(()) => head == SIGNATURE,
        Err(_) => false,
    }
}


/// セクタを 1 つ読む
fn read_sector(file: &mut File, sector: usize, number: u32) -> Result<Vec<u8>, Error> {
    let offset = (number as u64 + 1) * sector as u64;
    file.seek(SeekFrom::Start(offset))?;
    let mut piece = vec![0u8; sector];
    file.read_exact(&mut piece)?;
    Ok(piece)
}


/// ミニストリームからつながりをたどる
fn read_mini(mini: &[u8], links: &[u32], start: u32, size: u64) -> Result<Vec<u8>, Error> {
    let mut result = Vec::with_capacity(size as usize);
    let mut next = start;
    let mut seen = 0;

    while next != END && next != FREE && (result.len() as u64) < size {
        let from = next as usize * MINI;

        if from + MINI > mini.len() {
            return Err(Error::new("ミニストリームが範囲を超えています"));
        }

        result.extend_from_slice(&mini[from..from + MINI]);

        if next as usize >= links.len() {
            break;
        }

        next = links[next as usize];
        seen += 1;

        if seen > links.len() {
            return Err(Error::new("ミニストリームのつながりが輪になっています"));
        }
    }

    result.truncate(size as usize);
    Ok(result)
}


/// ディレクトリの項目を全部読む
fn read_directory(region: &[u8]) -> Result<Vec<Item>, Error> {
    let mut result = Vec::with_capacity(region.len() / ENTRY);

    for start in (0..region.len()).step_by(ENTRY) {
        if start + ENTRY > region.len() {
            break;
        }

        let kind = region[start + 66];
        let length = u16(region, start + 64)? as usize;
        let mut name = String::new();

        // 名前は UTF-16 で、末尾の 0 も長さに入っている
        if length >= 2 {
            for index in (0..length - 2).step_by(2) {
                let value = u16(region, start + index)?;

                if let Some(one) = char::from_u32(value as u32) {
                    name.push(one);
                }
            }
        }

        result.push(Item {
            name,
            kind,
            start: u32(region, start + 116)?,
            size: u64_at(region, start + 120)?,
        });
    }

    Ok(result)
}


/// 根の直下にあるものを、木をたどって集める
fn gather(region: &[u8], all: &[Item], child: u32) -> Result<Vec<Item>, Error> {
    let mut result = Vec::new();
    let mut stack = vec![child];
    let mut seen = 0;

    while let Some(index) = stack.pop() {
        if index == FREE || index as usize >= all.len() {
            continue;
        }

        seen += 1;

        if seen > all.len() {
            return Err(Error::new("複合ファイルのディレクトリが輪になっています"));
        }

        let start = index as usize * ENTRY;

        if start + ENTRY > region.len() {
            continue;
        }

        stack.push(u32(region, start + 68)?);
        stack.push(u32(region, start + 72)?);
        result.push(all[index as usize].clone());
    }

    Ok(result)
}


/// 2 バイトを読む
fn u16(region: &[u8], offset: usize) -> Result<u16, Error> {
    if offset + 2 > region.len() {
        return Err(Error::new("複合ファイルの記録が途中で終わっています"));
    }

    Ok(u16::from_le_bytes([region[offset], region[offset + 1]]))
}


/// 4 バイトを読む
fn u32(region: &[u8], offset: usize) -> Result<u32, Error> {
    if offset + 4 > region.len() {
        return Err(Error::new("複合ファイルの記録が途中で終わっています"));
    }

    Ok(u32::from_le_bytes([
        region[offset],
        region[offset + 1],
        region[offset + 2],
        region[offset + 3],
    ]))
}


/// 8 バイトを読む
fn u64_at(region: &[u8], offset: usize) -> Result<u64, Error> {
    if offset + 8 > region.len() {
        return Err(Error::new("複合ファイルの記録が途中で終わっています"));
    }

    let mut value = [0u8; 8];
    value.copy_from_slice(&region[offset..offset + 8]);
    Ok(u64::from_le_bytes(value))
}