Skip to main content

rustium_pdf/
parser.rs

1//! File structure: header, cross-reference tables and streams, object streams, trailer chain,
2//! and a brute-force recovery scan for files whose xref is wrong — which is common enough that
3//! every serious reader has one.
4
5use std::collections::{HashMap, HashSet};
6use std::sync::{Arc, Mutex};
7
8use crate::crypt::Decryptor;
9use crate::error::{Error, Result};
10use crate::filters;
11use crate::lexer::{find, rfind, Cursor};
12use crate::object::{Dict, ObjRef, Object, Stream};
13
14/// The `(object number, byte offset)` index of one object stream's members.
15type ObjStmIndex = Arc<Vec<(u32, usize)>>;
16
17#[derive(Debug, Clone, Copy)]
18enum XrefEntry {
19    /// Byte offset of `n g obj` from the start of the (header-adjusted) buffer.
20    Offset { offset: usize, gen: u16 },
21    /// Object lives inside an object stream.
22    InStream { stream_num: u32, index: u32 },
23}
24
25/// The parsed file: bytes plus the object map. All access is by object number.
26///
27/// Interior caches are mutex-guarded, so `&PdfFile` is usable from multiple threads.
28pub struct PdfFile {
29    data: Vec<u8>,
30    xref: HashMap<u32, XrefEntry>,
31    pub trailer: Dict,
32    pub decryptor: Option<Decryptor>,
33    /// The /Encrypt dictionary's own ref: its strings are not encrypted.
34    encrypt_ref: Option<ObjRef>,
35    cache: Mutex<HashMap<u32, Arc<Object>>>,
36    /// Decoded object streams, keyed by stream object number.
37    objstm_cache: Mutex<HashMap<u32, ObjStmIndex>>,
38    objstm_data: Mutex<HashMap<u32, Arc<[u8]>>>,
39}
40
41impl PdfFile {
42    pub fn load(mut data: Vec<u8>, password: Option<&str>) -> Result<Self> {
43        // The header may be preceded by junk; all offsets are then relative to `%PDF`.
44        let header =
45            find(&data, 0, b"%PDF-").ok_or_else(|| Error::Parse("no %PDF header".into()))?;
46        if header > 0 {
47            data.drain(..header);
48        }
49
50        let (xref, trailer) = match Self::read_xref_chain(&data) {
51            Ok(ok) if ok.1.contains("Root") => ok,
52            _ => Self::rebuild_by_scan(&data)?,
53        };
54
55        let mut file = Self {
56            data,
57            xref,
58            trailer,
59            decryptor: None,
60            encrypt_ref: None,
61            cache: Mutex::new(HashMap::new()),
62            objstm_cache: Mutex::new(HashMap::new()),
63            objstm_data: Mutex::new(HashMap::new()),
64        };
65
66        // A rebuilt xref can still miss /Root if the catalog hides in an object stream that the
67        // scan indexed; that resolves through the normal path below, so only a missing entry is
68        // fatal here.
69        if !file.trailer.contains("Root") {
70            return Err(Error::Parse("trailer has no /Root".into()));
71        }
72
73        if let Some(enc) = file.trailer.get("Encrypt").cloned() {
74            file.encrypt_ref = enc.as_ref_id();
75            let enc_dict = file
76                .resolve(&enc)
77                .as_dict()
78                .cloned()
79                .ok_or_else(|| Error::Parse("encrypt entry is not a dictionary".into()))?;
80            let ids = file
81                .trailer
82                .get("ID")
83                .map(|o| file.resolve(o))
84                .and_then(|o| o.as_array().and_then(|a| a.first().cloned()))
85                .and_then(|o| o.as_string().map(<[u8]>::to_vec))
86                .unwrap_or_default();
87            let resolve = |o: &Object| file.resolve(o);
88            file.decryptor = Some(Decryptor::new(&enc_dict, &ids, password, &resolve)?);
89            // The cache may hold objects loaded before the decryptor existed (the encrypt dict
90            // itself); drop them so nothing encrypted is served stale.
91            file.cache.lock().unwrap().clear();
92        }
93
94        Ok(file)
95    }
96
97    pub fn data(&self) -> &[u8] {
98        &self.data
99    }
100
101    // ---- xref reading ----------------------------------------------------------------------
102
103    fn read_xref_chain(data: &[u8]) -> Result<(HashMap<u32, XrefEntry>, Dict)> {
104        let tail_start = data.len().saturating_sub(2048);
105        let sx = rfind(&data[tail_start..], b"startxref")
106            .map(|p| p + tail_start)
107            .ok_or_else(|| Error::Parse("no startxref".into()))?;
108        let mut c = Cursor::at(data, sx + b"startxref".len());
109        c.skip_ws();
110        let offset = match Cursor::parse_number(c.read_regular()) {
111            Some(Object::Int(i)) if i >= 0 => i as usize,
112            _ => return Err(Error::Parse("bad startxref offset".into())),
113        };
114
115        let mut xref = HashMap::new();
116        let mut trailer = Dict::new();
117        let mut visited = HashSet::new();
118        let mut queue = vec![offset];
119
120        while let Some(off) = queue.pop() {
121            if off >= data.len() || !visited.insert(off) {
122                continue;
123            }
124            let mut c = Cursor::at(data, off);
125            c.skip_ws();
126            if c.eat_keyword(b"xref") {
127                let section_trailer = Self::read_xref_table(&mut c, &mut xref)?;
128                // Hybrid files put newer entries in an /XRefStm; those must win over the table
129                // they accompany but lose to entries already seen, which insert-if-absent gives
130                // us as long as the stream is processed before /Prev. Push order: Prev first.
131                if let Some(prev) = section_trailer.get("Prev").and_then(|o| o.as_int()) {
132                    queue.insert(0, prev as usize);
133                }
134                if let Some(x) = section_trailer.get("XRefStm").and_then(|o| o.as_int()) {
135                    queue.push(x as usize);
136                }
137                merge_trailer(&mut trailer, section_trailer);
138            } else {
139                let dict = Self::read_xref_stream(data, off, &mut xref)?;
140                if let Some(prev) = dict.get("Prev").and_then(|o| o.as_int()) {
141                    queue.insert(0, prev as usize);
142                }
143                merge_trailer(&mut trailer, dict);
144            }
145        }
146        Ok((xref, trailer))
147    }
148
149    fn read_xref_table(c: &mut Cursor, xref: &mut HashMap<u32, XrefEntry>) -> Result<Dict> {
150        loop {
151            c.skip_ws();
152            if c.eat_keyword(b"trailer") {
153                c.skip_ws();
154                let t = c
155                    .read_object()
156                    .and_then(|o| o.as_dict().cloned())
157                    .ok_or_else(|| Error::Parse("xref table without trailer dict".into()))?;
158                return Ok(t);
159            }
160            // Subsection header: `start count`.
161            let start = match Cursor::parse_number(c.read_regular()) {
162                Some(Object::Int(i)) if i >= 0 => i as u32,
163                _ => return Err(Error::Parse("bad xref subsection".into())),
164            };
165            c.skip_ws();
166            let count = match Cursor::parse_number(c.read_regular()) {
167                Some(Object::Int(i)) if i >= 0 => i as u32,
168                _ => return Err(Error::Parse("bad xref subsection count".into())),
169            };
170            for i in 0..count {
171                c.skip_ws();
172                let f1 = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
173                c.skip_ws();
174                let f2 = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
175                c.skip_ws();
176                let kind = c.read_regular();
177                let (Some(offset), Some(gen)) = (f1, f2) else {
178                    return Err(Error::Parse("bad xref entry".into()));
179                };
180                // `start` and `count` are both attacker-controlled; a subsection claiming to
181                // begin near u32::MAX has no valid object numbers left, so skip what overflows.
182                if kind == b"n" {
183                    let Some(num) = start.checked_add(i) else {
184                        continue;
185                    };
186                    xref.entry(num).or_insert(XrefEntry::Offset {
187                        offset: offset as usize,
188                        gen: gen.clamp(0, u16::MAX as i64) as u16,
189                    });
190                }
191            }
192        }
193    }
194
195    fn read_xref_stream(
196        data: &[u8],
197        off: usize,
198        xref: &mut HashMap<u32, XrefEntry>,
199    ) -> Result<Dict> {
200        let mut c = Cursor::at(data, off);
201        c.skip_ws();
202        // `n g obj`
203        let _num = c.read_regular();
204        c.skip_ws();
205        let _gen = c.read_regular();
206        c.skip_ws();
207        if !c.eat_keyword(b"obj") {
208            return Err(Error::Parse(
209                "startxref points at neither table nor stream".into(),
210            ));
211        }
212        let obj = c
213            .read_object()
214            .ok_or_else(|| Error::Parse("empty xref stream object".into()))?;
215        let Object::Dict(dict) = obj else {
216            return Err(Error::Parse("xref stream object is not a stream".into()));
217        };
218        c.skip_ws();
219        if !c.eat_keyword(b"stream") {
220            return Err(Error::Parse("xref stream without stream body".into()));
221        }
222        let length = dict
223            .get("Length")
224            .and_then(|o| o.as_int())
225            .map(|l| l.max(0) as usize);
226        let Object::Stream(stream) = c.read_stream_data(dict, length) else {
227            unreachable!()
228        };
229
230        // Xref streams are never encrypted, so plain filter decode is correct here.
231        let no_resolve = |o: &Object| o.clone();
232        let decoded = filters::decode(&stream.dict, &stream.raw, &no_resolve)?;
233        let content = decoded.data;
234
235        let w: Vec<usize> = stream
236            .dict
237            .get("W")
238            .and_then(|o| o.as_array())
239            .map(|a| {
240                a.iter()
241                    .filter_map(|o| o.as_int())
242                    .map(|i| i.max(0) as usize)
243                    .collect()
244            })
245            .unwrap_or_default();
246        if w.len() < 3 {
247            return Err(Error::Parse("xref stream missing /W".into()));
248        }
249        let row = w.iter().sum::<usize>();
250        if row == 0 {
251            return Err(Error::Parse("xref stream /W is all zero".into()));
252        }
253        let size = stream
254            .dict
255            .get("Size")
256            .and_then(|o| o.as_int())
257            .unwrap_or(0);
258        let index: Vec<i64> = stream
259            .dict
260            .get("Index")
261            .and_then(|o| o.as_array())
262            .map(|a| a.iter().filter_map(|o| o.as_int()).collect())
263            .unwrap_or_else(|| vec![0, size]);
264
265        let read_field =
266            |bytes: &[u8]| -> u64 { bytes.iter().fold(0u64, |acc, &b| (acc << 8) | b as u64) };
267
268        let mut rows = content.chunks_exact(row);
269        for pair in index.chunks(2) {
270            let [start, count] = pair else { break };
271            for i in 0..*count {
272                let Some(r) = rows.next() else { break };
273                let (t, rest) = r.split_at(w[0]);
274                let (f2, f3) = rest.split_at(w[1]);
275                // A zero-width type field defaults to type 1.
276                let t = if w[0] == 0 { 1 } else { read_field(t) };
277                let f2 = read_field(f2);
278                let f3 = read_field(&f3[..w[2]]);
279                let num = (*start + i) as u32;
280                match t {
281                    1 => {
282                        xref.entry(num).or_insert(XrefEntry::Offset {
283                            offset: f2 as usize,
284                            gen: f3.min(u16::MAX as u64) as u16,
285                        });
286                    }
287                    2 => {
288                        xref.entry(num).or_insert(XrefEntry::InStream {
289                            stream_num: f2 as u32,
290                            index: f3 as u32,
291                        });
292                    }
293                    _ => {} // 0 = free; anything else per spec is a null reference.
294                }
295            }
296        }
297        Ok(stream.dict)
298    }
299
300    /// Rebuilds the object map by scanning the whole file for `n g obj`, taking the *last*
301    /// definition of each object (later definitions supersede in incremental updates), and
302    /// hunting for a trailer or catalog.
303    fn rebuild_by_scan(data: &[u8]) -> Result<(HashMap<u32, XrefEntry>, Dict)> {
304        let mut xref = HashMap::new();
305        let mut objstms = Vec::new();
306        let mut pos = 0usize;
307        while let Some(hit) = find(data, pos, b"obj") {
308            pos = hit + 3;
309            // `obj` must be a standalone keyword.
310            if data
311                .get(hit + 3)
312                .is_some_and(|&b| crate::lexer::is_regular(b))
313            {
314                continue;
315            }
316            // Walk backwards over ws, generation digits, ws, object digits.
317            let mut i = hit;
318            let step_back_digits = |mut i: usize| -> Option<(usize, u64)> {
319                while i > 0 && crate::lexer::is_whitespace(data[i - 1]) {
320                    i -= 1;
321                }
322                let end = i;
323                while i > 0 && data[i - 1].is_ascii_digit() {
324                    i -= 1;
325                }
326                if i == end {
327                    return None;
328                }
329                let v = std::str::from_utf8(&data[i..end])
330                    .ok()?
331                    .parse::<u64>()
332                    .ok()?;
333                Some((i, v))
334            };
335            let Some((gi, gen)) = step_back_digits(i) else {
336                continue;
337            };
338            i = gi;
339            let Some((ni, num)) = step_back_digits(i) else {
340                continue;
341            };
342            if num > u32::MAX as u64 || gen > u16::MAX as u64 {
343                continue;
344            }
345            xref.insert(
346                num as u32,
347                XrefEntry::Offset {
348                    offset: ni,
349                    gen: gen as u16,
350                },
351            );
352            // Remember object streams so their members can be indexed afterwards.
353            let mut c = Cursor::at(data, hit + 3);
354            c.skip_ws();
355            if let Some(Object::Dict(d)) = c.clone().read_object() {
356                if d.get("Type").and_then(|o| o.as_name()) == Some("ObjStm") {
357                    objstms.push(num as u32);
358                }
359            }
360        }
361        if xref.is_empty() {
362            return Err(Error::Parse("no objects found in scan".into()));
363        }
364
365        // Index object-stream members: any member not already defined at top level.
366        let probe = PdfFile {
367            data: data.to_vec(),
368            xref: xref.clone(),
369            trailer: Dict::new(),
370            decryptor: None,
371            encrypt_ref: None,
372            cache: Mutex::new(HashMap::new()),
373            objstm_cache: Mutex::new(HashMap::new()),
374            objstm_data: Mutex::new(HashMap::new()),
375        };
376        for sn in objstms {
377            if let Ok(members) = probe.objstm_index(sn) {
378                for (i, (num, _)) in members.iter().enumerate() {
379                    xref.entry(*num).or_insert(XrefEntry::InStream {
380                        stream_num: sn,
381                        index: i as u32,
382                    });
383                }
384            }
385        }
386
387        // Prefer the last real trailer dict; otherwise find a /Type /Catalog object.
388        let mut trailer = Dict::new();
389        let mut tpos = 0usize;
390        let mut last_trailer = None;
391        while let Some(hit) = find(data, tpos, b"trailer") {
392            tpos = hit + 7;
393            let mut c = Cursor::at(data, tpos);
394            c.skip_ws();
395            if let Some(Object::Dict(d)) = c.read_object() {
396                last_trailer = Some(d);
397            }
398        }
399        if let Some(t) = last_trailer {
400            merge_trailer(&mut trailer, t);
401        }
402        if !trailer.contains("Root") {
403            let probe = PdfFile {
404                xref: xref.clone(),
405                ..probe
406            };
407            let mut nums: Vec<u32> = xref.keys().copied().collect();
408            nums.sort_unstable();
409            for num in nums {
410                if let Object::Dict(d) | Object::Stream(Stream { dict: d, .. }) =
411                    probe.get(num).as_ref()
412                {
413                    if d.get("Type").and_then(|o| o.as_name()) == Some("Catalog") {
414                        trailer.insert("Root", Object::Ref(ObjRef::new(num, 0)));
415                        break;
416                    }
417                }
418            }
419        }
420        Ok((xref, trailer))
421    }
422
423    // ---- object access ---------------------------------------------------------------------
424
425    /// Fetches object `num`, from cache when possible. Returns `Object::Null` for anything
426    /// missing or malformed: a dangling reference is data-level damage, not a hard error.
427    pub fn get(&self, num: u32) -> Arc<Object> {
428        if let Some(hit) = self.cache.lock().unwrap().get(&num) {
429            return hit.clone();
430        }
431        let obj = Arc::new(self.load_object(num, &mut HashSet::new()));
432        self.cache.lock().unwrap().insert(num, obj.clone());
433        obj
434    }
435
436    /// Resolves an object one level: a `Ref` becomes its target, everything else is cloned.
437    pub fn resolve(&self, obj: &Object) -> Object {
438        let mut current = obj.clone();
439        let mut hops = 0;
440        while let Object::Ref(r) = current {
441            if hops > 32 {
442                return Object::Null;
443            }
444            hops += 1;
445            current = (*self.get(r.num)).clone();
446        }
447        current
448    }
449
450    fn load_object(&self, num: u32, in_flight: &mut HashSet<u32>) -> Object {
451        if !in_flight.insert(num) {
452            return Object::Null; // Reference cycle in /Length or an object stream.
453        }
454        let entry = match self.xref.get(&num) {
455            Some(e) => *e,
456            None => return Object::Null,
457        };
458        let obj = match entry {
459            XrefEntry::Offset { offset, gen } => self.load_at_offset(num, gen, offset, in_flight),
460            XrefEntry::InStream { stream_num, index } => {
461                self.load_from_objstm(stream_num, index, num, in_flight)
462            }
463        };
464        in_flight.remove(&num);
465        obj
466    }
467
468    fn load_at_offset(
469        &self,
470        num: u32,
471        gen: u16,
472        offset: usize,
473        in_flight: &mut HashSet<u32>,
474    ) -> Object {
475        if offset >= self.data.len() {
476            return Object::Null;
477        }
478        let mut c = Cursor::at(&self.data, offset);
479        c.skip_ws();
480        let n_tok = c.read_regular().to_vec();
481        c.skip_ws();
482        let _g = c.read_regular();
483        c.skip_ws();
484        if !c.eat_keyword(b"obj") {
485            return Object::Null;
486        }
487        // An xref that points at the wrong object is a damaged file; serving the wrong object
488        // corrupts everything downstream, so verify the number.
489        match Cursor::parse_number(&n_tok) {
490            Some(Object::Int(n)) if n == num as i64 => {}
491            _ => return Object::Null,
492        }
493
494        let Some(mut obj) = c.read_object() else {
495            return Object::Null;
496        };
497
498        if let Object::Dict(dict) = obj {
499            c.skip_ws();
500            if c.eat_keyword(b"stream") {
501                let length = dict.get("Length").and_then(|len| match len {
502                    Object::Int(i) => Some((*i).max(0) as usize),
503                    Object::Ref(r) => self
504                        .load_object(r.num, in_flight)
505                        .as_int()
506                        .map(|i| i.max(0) as usize),
507                    _ => None,
508                });
509                obj = c.read_stream_data(dict, length);
510            } else {
511                obj = Object::Dict(dict);
512            }
513        }
514
515        self.decrypt_in_place(&mut obj, num, gen);
516        obj
517    }
518
519    fn decrypt_in_place(&self, obj: &mut Object, num: u32, gen: u16) {
520        let Some(dec) = &self.decryptor else { return };
521        if self.encrypt_ref.is_some_and(|r| r.num == num) {
522            return;
523        }
524        fn walk(obj: &mut Object, dec: &Decryptor, num: u32, gen: u16) {
525            match obj {
526                Object::String(s) => *s = dec.decrypt_string(num, gen, s),
527                Object::Array(items) => {
528                    for i in items {
529                        walk(i, dec, num, gen);
530                    }
531                }
532                Object::Dict(d) => {
533                    for v in d.0.values_mut() {
534                        walk(v, dec, num, gen);
535                    }
536                }
537                Object::Stream(s) => {
538                    for v in s.dict.0.values_mut() {
539                        walk(v, dec, num, gen);
540                    }
541                    // XRef streams are never encrypted; /Metadata is exempt when
542                    // EncryptMetadata is false, which the decryptor knows.
543                    let ty = s.dict.get("Type").and_then(|o| o.as_name());
544                    if ty != Some("XRef") && dec.stream_needs_decrypt(ty) {
545                        s.raw = dec.decrypt_stream(num, gen, &s.raw).into();
546                    }
547                }
548                _ => {}
549            }
550        }
551        walk(obj, dec, num, gen);
552    }
553
554    // ---- object streams --------------------------------------------------------------------
555
556    /// The `(object number, byte offset)` index of an object stream's members.
557    fn objstm_index(&self, stream_num: u32) -> Result<ObjStmIndex> {
558        if let Some(hit) = self.objstm_cache.lock().unwrap().get(&stream_num) {
559            return Ok(hit.clone());
560        }
561        let container = self.get(stream_num);
562        let Object::Stream(stream) = container.as_ref() else {
563            return Err(Error::Parse(format!("object stream {stream_num} missing")));
564        };
565        let resolve = |o: &Object| self.resolve(o);
566        let decoded = filters::decode(&stream.dict, &stream.raw, &resolve)?;
567        let data: Arc<[u8]> = decoded.data.into();
568
569        let n = stream
570            .dict
571            .get("N")
572            .map(|o| self.resolve(o))
573            .and_then(|o| o.as_int())
574            .unwrap_or(0)
575            .max(0) as usize;
576        let first = stream
577            .dict
578            .get("First")
579            .map(|o| self.resolve(o))
580            .and_then(|o| o.as_int())
581            .unwrap_or(0)
582            .max(0) as usize;
583
584        let mut pairs = Vec::with_capacity(n);
585        let mut c = Cursor::new(&data);
586        for _ in 0..n {
587            c.skip_ws();
588            let num = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
589            c.skip_ws();
590            let off = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
591            let (Some(num), Some(off)) = (num, off) else {
592                break;
593            };
594            if num >= 0 && off >= 0 {
595                pairs.push((num as u32, first + off as usize));
596            }
597        }
598
599        let pairs = Arc::new(pairs);
600        self.objstm_cache
601            .lock()
602            .unwrap()
603            .insert(stream_num, pairs.clone());
604        self.objstm_data.lock().unwrap().insert(stream_num, data);
605        Ok(pairs)
606    }
607
608    fn load_from_objstm(
609        &self,
610        stream_num: u32,
611        index: u32,
612        expect_num: u32,
613        _in_flight: &mut HashSet<u32>,
614    ) -> Object {
615        let Ok(pairs) = self.objstm_index(stream_num) else {
616            return Object::Null;
617        };
618        // The xref's index is authoritative, but scan-recovered files may have it wrong, so
619        // fall back to searching by object number.
620        let slot = pairs
621            .get(index as usize)
622            .filter(|(n, _)| *n == expect_num)
623            .or_else(|| pairs.iter().find(|(n, _)| *n == expect_num));
624        let Some(&(_, offset)) = slot else {
625            return Object::Null;
626        };
627        let data = self.objstm_data.lock().unwrap().get(&stream_num).cloned();
628        let Some(data) = data else {
629            return Object::Null;
630        };
631        let mut c = Cursor::at(&data, offset);
632        // Members of an object stream are never streams themselves and are not individually
633        // encrypted: the container already was.
634        c.read_object().unwrap_or(Object::Null)
635    }
636
637    /// Decodes a stream's filter chain (after any decryption, which happened at load).
638    pub fn decode_stream(&self, stream: &Stream) -> Result<filters::Decoded> {
639        let resolve = |o: &Object| self.resolve(o);
640        filters::decode(&stream.dict, &stream.raw, &resolve)
641    }
642}
643
644/// First trailer wins for the keys that matter; the chain is walked newest-first.
645fn merge_trailer(into: &mut Dict, from: Dict) {
646    for (k, v) in from.0 {
647        into.0.entry(k).or_insert(v);
648    }
649}
650
651#[cfg(test)]
652pub(crate) mod tests {
653    use super::*;
654
655    /// A minimal one-page PDF with a classic xref table, built by hand.
656    pub fn tiny_pdf() -> Vec<u8> {
657        let mut out: Vec<u8> = Vec::new();
658        let mut offsets = [0usize; 6];
659        out.extend_from_slice(b"%PDF-1.4\n");
660        let content = b"BT /F1 12 Tf 72 720 Td (Hi) Tj ET";
661        let objs: Vec<(usize, String)> = vec![
662            (1, "<< /Type /Catalog /Pages 2 0 R >>".into()),
663            (2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into()),
664            (
665                3,
666                "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R \
667                 /Resources << /Font << /F1 5 0 R >> >> >>"
668                    .into(),
669            ),
670            (
671                4,
672                format!(
673                    "<< /Length {} >>\nstream\n{}\nendstream",
674                    content.len(),
675                    std::str::from_utf8(content).unwrap()
676                ),
677            ),
678            (
679                5,
680                "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".into(),
681            ),
682        ];
683        for (num, body) in &objs {
684            offsets[*num] = out.len();
685            out.extend_from_slice(format!("{num} 0 obj\n{body}\nendobj\n").as_bytes());
686        }
687        let xref_at = out.len();
688        out.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
689        for offset in &offsets[1..6] {
690            out.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
691        }
692        out.extend_from_slice(b"trailer\n<< /Size 6 /Root 1 0 R >>\n");
693        out.extend_from_slice(format!("startxref\n{xref_at}\n%%EOF\n").as_bytes());
694        out
695    }
696
697    #[test]
698    fn loads_classic_xref() {
699        let file = PdfFile::load(tiny_pdf(), None).unwrap();
700        let root = file.trailer.get("Root").unwrap().as_ref_id().unwrap();
701        let cat = file.get(root.num);
702        assert_eq!(
703            cat.as_dict().unwrap().get("Type").unwrap().as_name(),
704            Some("Catalog")
705        );
706        let content = file.get(4);
707        let s = content.as_stream().unwrap();
708        let d = file.decode_stream(s).unwrap();
709        assert!(d.data.starts_with(b"BT"));
710    }
711
712    #[test]
713    fn survives_broken_startxref() {
714        let mut pdf = tiny_pdf();
715        // Corrupt the startxref offset.
716        let sx = rfind(&pdf, b"startxref").unwrap();
717        pdf[sx + 10] = b'9';
718        pdf[sx + 11] = b'9';
719        let file = PdfFile::load(pdf, None).unwrap();
720        assert!(file.trailer.contains("Root"));
721        assert!(file.get(3).as_dict().is_some());
722    }
723
724    #[test]
725    fn survives_junk_before_header() {
726        let mut pdf = b"GARBAGE BYTES ".to_vec();
727        pdf.extend_from_slice(&tiny_pdf());
728        let file = PdfFile::load(pdf, None).unwrap();
729        assert!(file.get(1).as_dict().is_some());
730    }
731
732    #[test]
733    fn wrong_length_falls_back_to_endstream_scan() {
734        let pdf = tiny_pdf();
735        let s = String::from_utf8(pdf)
736            .unwrap()
737            .replace("/Length 33", "/Length 4");
738        let file = PdfFile::load(s.into_bytes(), None).unwrap();
739        let content = file.get(4);
740        let stream = content.as_stream().unwrap();
741        assert!(stream.raw.starts_with(b"BT"));
742        assert!(stream.raw.ends_with(b"ET"));
743    }
744
745    #[test]
746    fn missing_object_is_null() {
747        let file = PdfFile::load(tiny_pdf(), None).unwrap();
748        assert!(file.get(99).is_null());
749        assert_eq!(file.resolve(&Object::Ref(ObjRef::new(99, 0))), Object::Null);
750    }
751}