cfb 0.15.0

Read/write Compound File Binary (structured storage) files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use cfb::CompoundFile;
use std::io::{Cursor, Read, Write};

/// Writes `count` mini streams of `len` bytes each, named `s{i}`, whose
/// contents identify the stream.
fn write_streams(
    comp: &mut CompoundFile<Cursor<Vec<u8>>>,
    count: u32,
    len: usize,
) {
    for i in 0..count {
        let data = vec![(i % 251) as u8; len];
        let mut stream = comp.create_stream(format!("/s{i}")).unwrap();
        stream.write_all(&data).unwrap();
    }
}

fn assert_stream(
    comp: &mut CompoundFile<Cursor<Vec<u8>>>,
    i: u32,
    len: usize,
) {
    let mut data = Vec::new();
    comp.open_stream(format!("/s{i}"))
        .unwrap()
        .read_to_end(&mut data)
        .unwrap();
    assert_eq!(data.len(), len, "stream s{} length", i);
    assert!(
        data.iter().all(|&b| b == (i % 251) as u8),
        "stream s{} contents",
        i
    );
}

/// Many small streams grow the mini stream across many regular sectors,
/// freeing some shrinks it, and adding more grows it again; every stream
/// must read back intact through all of it, whether the file is the one
/// being written or reopened from its bytes.
#[test]
fn many_mini_streams_grow_shrink_and_regrow() {
    let mut comp = CompoundFile::create(Cursor::new(Vec::new())).unwrap();
    write_streams(&mut comp, 800, 300);
    for i in 0..800 {
        assert_stream(&mut comp, i, 300);
    }

    // Free every third stream, then add a second batch.
    for i in (0..800).step_by(3) {
        comp.remove_stream(format!("/s{i}")).unwrap();
    }
    for i in 800..1000 {
        let data = vec![(i % 251) as u8; 300];
        let mut stream = comp.create_stream(format!("/s{i}")).unwrap();
        stream.write_all(&data).unwrap();
    }
    comp.flush().unwrap();

    let check = |comp: &mut CompoundFile<Cursor<Vec<u8>>>| {
        for i in 0..1000u32 {
            if i < 800 && i % 3 == 0 {
                assert!(
                    !comp.is_stream(format!("/s{i}")),
                    "s{} was removed",
                    i
                );
            } else {
                assert_stream(comp, i, 300);
            }
        }
    };
    check(&mut comp);

    // The same file reopened from its bytes.
    let bytes = comp.into_inner().into_inner();
    let mut reopened = CompoundFile::open(Cursor::new(bytes)).unwrap();
    check(&mut reopened);
}

/// A mini stream that grows past the mini-stream cutoff moves to the regular
/// sectors; a stream truncated back below it returns. Both transitions keep
/// the other mini streams readable.
#[test]
fn a_stream_crossing_the_mini_cutoff_keeps_its_neighbours_intact() {
    let mut comp = CompoundFile::create(Cursor::new(Vec::new())).unwrap();
    write_streams(&mut comp, 100, 200);

    let mut big = comp.create_stream("/big").unwrap();
    big.write_all(&[7u8; 100]).unwrap();
    big.write_all(&vec![7u8; 10_000]).unwrap();
    big.set_len(50).unwrap();
    drop(big);

    for i in 0..100 {
        assert_stream(&mut comp, i, 200);
    }
    let mut data = Vec::new();
    comp.open_stream("/big").unwrap().read_to_end(&mut data).unwrap();
    assert_eq!(data, vec![7u8; 50]);
}

/// A mini stream written in one go lands in one run of mini sectors, one
/// appended in pieces crosses mini sector boundaries mid-write, and one
/// created after others were removed reuses their scattered mini sectors;
/// all of them read back intact, also from a strictly reopened file.
#[test]
fn mini_streams_written_whole_in_pieces_and_into_reused_sectors() {
    let mut comp = CompoundFile::create(Cursor::new(Vec::new())).unwrap();
    let whole: Vec<u8> = (0..3000).map(|i| (i % 253) as u8).collect();
    comp.create_stream("/whole").unwrap().write_all(&whole).unwrap();

    let mut pieces = Vec::new();
    {
        let mut stream = comp.create_stream("/pieces").unwrap();
        for (i, len) in
            [10usize, 60, 100, 1, 63, 64, 65, 500].iter().enumerate()
        {
            let piece = vec![i as u8 + 1; *len];
            stream.write_all(&piece).unwrap();
            pieces.extend_from_slice(&piece);
        }
    }

    write_streams(&mut comp, 20, 200);
    for i in (0..20).step_by(2) {
        comp.remove_stream(format!("/s{i}")).unwrap();
    }
    let reused: Vec<u8> = (0..2500).map(|i| (i % 7) as u8).collect();
    comp.create_stream("/reused").unwrap().write_all(&reused).unwrap();

    let check = |comp: &mut CompoundFile<Cursor<Vec<u8>>>| {
        let mut read = |path: &str| {
            let mut data = Vec::new();
            comp.open_stream(path).unwrap().read_to_end(&mut data).unwrap();
            data
        };
        assert_eq!(read("/whole"), whole);
        assert_eq!(read("/pieces"), pieces);
        assert_eq!(read("/reused"), reused);
        for i in (1..20).step_by(2) {
            assert_stream(comp, i, 200);
        }
    };
    check(&mut comp);
    let bytes = comp.into_inner().into_inner();
    let mut comp = CompoundFile::open_strict(Cursor::new(bytes)).unwrap();
    check(&mut comp);
}

/// Enough mini sectors to need more than one MiniFAT sector (1024 entries
/// per V4 sector) still link up and reopen strictly.
#[test]
fn mini_streams_beyond_one_minifat_sector() {
    let mut comp = CompoundFile::create(Cursor::new(Vec::new())).unwrap();
    // 40 streams of 4000 bytes take 63 mini sectors each: 2520 entries.
    write_streams(&mut comp, 40, 4000);
    let bytes = comp.into_inner().into_inner();
    let mut comp = CompoundFile::open_strict(Cursor::new(bytes)).unwrap();
    for i in 0..40 {
        assert_stream(&mut comp, i, 4000);
    }
}