structured-pades 0.21.3

Original-source PDF signatures and provider-neutral PAdES baseline validation
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

//! Trusted small PDF writers shared by source/permission integration tests.

extern crate std;
use self::std::io::Write;
use alloc::vec::Vec;
use core::{
    future::Future,
    pin::pin,
    task::{Context, Poll, Waker},
};

pub fn ready<F: Future>(future: F) -> F::Output {
    let mut future = pin!(future);
    let mut context = Context::from_waker(Waker::noop());
    match future.as_mut().poll(&mut context) {
        Poll::Ready(value) => value,
        Poll::Pending => panic!("the slice fixture performs no suspended acquisition"),
    }
}

pub struct Pdf {
    pub bytes: Vec<u8>,
    xref: usize,
    size: usize,
    free: alloc::collections::BTreeSet<usize>,
}
impl Pdf {
    pub fn new(objects: &[(usize, &[u8])]) -> Self {
        let size = objects
            .iter()
            .map(|value| value.0)
            .max()
            .expect("fixture root")
            + 1;
        let mut bytes = b"%PDF-1.7\n".to_vec();
        let mut offsets = alloc::vec![0; size];
        for &(number, body) in objects {
            offsets[number] = bytes.len();
            writeln!(bytes, "{number} 0 obj").unwrap();
            bytes.extend_from_slice(body);
            writeln!(bytes, "\nendobj").unwrap();
        }
        let xref = bytes.len();
        writeln!(bytes, "xref\n0 {size}\n0000000000 65535 f ").unwrap();
        for offset in &offsets[1..] {
            assert!(*offset > 0, "base fixture object numbers are contiguous");
            writeln!(bytes, "{offset:010} 00000 n ").unwrap();
        }
        writeln!(
            bytes,
            "trailer\n<< /Size {size} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF"
        )
        .unwrap();
        Self {
            bytes,
            xref,
            size,
            free: alloc::collections::BTreeSet::new(),
        }
    }
    pub fn append(&mut self, objects: &[(usize, &[u8])]) {
        let old_size = self.size;
        let mut offsets = Vec::new();
        for &(number, body) in objects {
            self.size = self.size.max(number + 1);
            offsets.push((number, self.bytes.len()));
            writeln!(self.bytes, "{number} 0 obj").unwrap();
            self.bytes.extend_from_slice(body);
            writeln!(self.bytes, "\nendobj").unwrap();
        }
        for number in old_size..self.size {
            self.free.insert(number);
        }
        for &(number, _) in objects {
            self.free.remove(&number);
        }
        let xref = self.bytes.len();
        writeln!(self.bytes, "xref").unwrap();
        for (number, offset) in offsets {
            writeln!(self.bytes, "{number} 1\n{offset:010} 00000 n ").unwrap();
        }
        let mut free = self.free.iter().peekable();
        writeln!(
            self.bytes,
            "0 1\n{:010} 65535 f ",
            free.peek().map_or(0, |&&number| number)
        )
        .unwrap();
        while let Some(&number) = free.next() {
            writeln!(
                self.bytes,
                "{number} 1\n{:010} 00000 f ",
                free.peek().map_or(0, |&&number| number)
            )
            .unwrap();
        }
        writeln!(
            self.bytes,
            "trailer\n<< /Size {} /Root 1 0 R /Prev {} >>\nstartxref\n{xref}\n%%EOF",
            self.size, self.xref
        )
        .unwrap();
        self.xref = xref;
    }
}