use crate::linearization::part1::PLACEHOLDER_WIDTH;
use crate::linearization::writer::{LinearizedDocument, LinearizedOffsets, PREV_PLACEHOLDER_WIDTH};
use crate::Result;
const MAX_PLACEHOLDER_VALUE: u64 = {
10_000_000_000 - 1
};
pub fn back_patch_param_dict(bytes: &mut [u8], offsets: &LinearizedOffsets) -> Result<()> {
if !offsets.part1_placeholders.all_valid() {
return Err(crate::Error::Unsupported(
"back_patch_param_dict: Part1Placeholders are invalid (wrong width or overlapping)"
.to_string(),
));
}
let ph = &offsets.part1_placeholders;
let patches: &[(&std::ops::Range<usize>, u64, &str)] = &[
(&ph.l, offsets.file_length as u64, "/L"),
(&ph.h_offset, offsets.hint_stream_offset as u64, "/H[0]"),
(&ph.h_length, offsets.hint_stream_length as u64, "/H[1]"),
(&ph.o, u64::from(offsets.first_page_object_new_num), "/O"),
(&ph.e, offsets.end_of_first_page_offset as u64, "/E"),
(&ph.t, offsets.last_xref_offset as u64, "/T"),
(&ph.n, u64::from(offsets.page_count), "/N"),
];
for (range, value, key_name) in patches {
if range.end > bytes.len() {
return Err(crate::Error::Unsupported(format!(
"back_patch_param_dict: {} placeholder range {:?} out of bounds for buffer length {}",
key_name,
range,
bytes.len()
)));
}
if *value > MAX_PLACEHOLDER_VALUE {
return Err(crate::Error::Unsupported(format!(
"back_patch_param_dict: {} value {} exceeds maximum \
{PLACEHOLDER_WIDTH}-digit placeholder value ({})",
key_name, value, MAX_PLACEHOLDER_VALUE,
)));
}
}
let prev_range = &offsets.first_trailer_prev_range;
if !prev_range.is_empty() {
if prev_range.end > bytes.len() {
return Err(crate::Error::Unsupported(format!(
"back_patch_param_dict: /Prev placeholder range {:?} out of bounds for buffer length {}",
prev_range,
bytes.len()
)));
}
if prev_range.len() != PREV_PLACEHOLDER_WIDTH {
return Err(crate::Error::Unsupported(format!(
"back_patch_param_dict: /Prev placeholder range has length {} (expected {})",
prev_range.len(),
PREV_PLACEHOLDER_WIDTH,
)));
}
}
for (range, value, _key_name) in patches {
let formatted = format!("{value:0PLACEHOLDER_WIDTH$}");
debug_assert_eq!(
formatted.len(),
PLACEHOLDER_WIDTH,
"formatted value '{formatted}' must be exactly {PLACEHOLDER_WIDTH} bytes",
);
bytes[(*range).clone()].copy_from_slice(formatted.as_bytes());
}
if !prev_range.is_empty() {
let prev_value = offsets.last_xref_keyword_offset;
let formatted = format!("{prev_value:<PREV_PLACEHOLDER_WIDTH$}");
debug_assert_eq!(
formatted.len(),
PREV_PLACEHOLDER_WIDTH,
"formatted /Prev value must be exactly {PREV_PLACEHOLDER_WIDTH} bytes",
);
bytes[prev_range.clone()].copy_from_slice(formatted.as_bytes());
}
Ok(())
}
impl LinearizedDocument {
pub fn back_patch(&mut self) -> Result<()> {
back_patch_param_dict(&mut self.bytes, &self.offsets)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::part1::{Part1Bytes, PLACEHOLDER_WIDTH};
use crate::linearization::plan::{LinearizationPlan, PageHintEntry};
use crate::linearization::renumber::RenumberMap;
use crate::linearization::writer::{write_linearized, LinearizedDocument, LinearizedOffsets};
use crate::writer::WriteOptions;
use crate::{ObjectRef, Pdf};
use std::collections::BTreeMap;
use std::io::Cursor;
fn tiny_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!(
"trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_tiny_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(tiny_pdf_bytes())).expect("tiny PDF should parse")
}
fn build_linearized() -> LinearizedDocument {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = open_tiny_pdf();
write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default())
.expect("write_linearized")
}
fn minimal_plan() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(3, 0), ObjectRef::new(2, 0)],
part4_rest: vec![ObjectRef::new(1, 0)],
total_object_count: 3,
root_ref: Some(ObjectRef::new(1, 0)),
page_hints: vec![PageHintEntry::placeholder(ObjectRef::new(3, 0))],
..Default::default()
}
}
fn minimal_offsets(part1: &Part1Bytes, file_length: usize) -> LinearizedOffsets {
LinearizedOffsets {
file_length,
hint_stream_offset: 1234,
hint_stream_length: 567,
first_page_object_new_num: 2,
end_of_first_page_offset: 9876,
last_xref_keyword_offset: 49990,
last_xref_offset: 50000,
page_count: 1,
part1_placeholders: part1.placeholders.clone(),
xref_offsets: BTreeMap::new(),
first_trailer_prev_range: 0..0,
}
}
#[test]
fn back_patch_writes_values_at_correct_ranges() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let mut bytes = part1.bytes.clone();
let file_len = bytes.len() + 99_999; let offsets = minimal_offsets(&part1, file_len);
back_patch_param_dict(&mut bytes, &offsets).expect("back_patch should succeed");
let ph = &offsets.part1_placeholders;
let check = |range: &std::ops::Range<usize>, expected: u64, name: &str| {
let s = std::str::from_utf8(&bytes[range.clone()]).expect("UTF-8");
let parsed: u64 = s.trim_start_matches('0').parse().unwrap_or(0);
assert_eq!(parsed, expected, "{name}: expected {expected}, got '{s}'");
assert_eq!(
s.len(),
PLACEHOLDER_WIDTH,
"{name}: length must be {PLACEHOLDER_WIDTH}"
);
};
check(&ph.l, file_len as u64, "/L");
check(&ph.h_offset, 1234, "/H[0]");
check(&ph.h_length, 567, "/H[1]");
check(&ph.o, 2, "/O");
check(&ph.e, 9876, "/E");
check(&ph.t, 50000, "/T");
check(&ph.n, 1, "/N");
}
#[test]
fn back_patch_leaves_non_placeholder_bytes_unchanged() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let original = part1.bytes.clone();
let mut bytes = original.clone();
let offsets = minimal_offsets(&part1, bytes.len() + 1);
back_patch_param_dict(&mut bytes, &offsets).expect("back_patch");
let ph = &offsets.part1_placeholders;
let mut all_ranges: Vec<std::ops::Range<usize>> = ph.as_slice().to_vec();
all_ranges.sort_by_key(|r| r.start);
let placeholder_positions: std::collections::HashSet<usize> =
all_ranges.iter().flat_map(|r| r.clone()).collect();
for (i, (&orig, &patched)) in original.iter().zip(bytes.iter()).enumerate() {
if !placeholder_positions.contains(&i) {
assert_eq!(
orig, patched,
"byte at index {i} (outside placeholders) was modified"
);
}
}
}
#[test]
fn after_back_patch_placeholders_are_all_digits() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let mut bytes = part1.bytes.clone();
let offsets = minimal_offsets(&part1, bytes.len() + 42);
back_patch_param_dict(&mut bytes, &offsets).expect("back_patch");
let ph = &offsets.part1_placeholders;
for range in ph.as_slice() {
for &b in &bytes[range.clone()] {
assert!(
b.is_ascii_digit(),
"byte {b} at position in {range:?} is not an ASCII digit"
);
}
}
}
#[test]
fn overflow_file_length_returns_err() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let mut bytes = part1.bytes.clone();
let mut offsets = minimal_offsets(&part1, 10_000_000_000);
offsets.file_length = 10_000_000_000;
let result = back_patch_param_dict(&mut bytes, &offsets);
assert!(
result.is_err(),
"back_patch must return Err when /L value overflows 10 digits"
);
}
#[test]
fn overflow_hint_stream_offset_returns_err() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let mut bytes = part1.bytes.clone();
let mut offsets = minimal_offsets(&part1, 100);
offsets.hint_stream_offset = 10_000_000_000;
let result = back_patch_param_dict(&mut bytes, &offsets);
assert!(result.is_err(), "back_patch must Err on /H[0] overflow");
}
#[test]
fn overflow_last_xref_offset_returns_err() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let mut bytes = part1.bytes.clone();
let mut offsets = minimal_offsets(&part1, 100);
offsets.last_xref_offset = 10_000_000_001;
let result = back_patch_param_dict(&mut bytes, &offsets);
assert!(result.is_err(), "back_patch must Err on /T overflow");
}
#[test]
fn overflow_on_late_field_leaves_bytes_unchanged() {
let plan = minimal_plan();
let renumber = RenumberMap::from_plan(&plan);
let part1 = Part1Bytes::build(&plan, &renumber, "1.4");
let original = part1.bytes.clone();
let mut bytes = original.clone();
let mut offsets = minimal_offsets(&part1, 100);
offsets.file_length = 12345; offsets.last_xref_offset = 10_000_000_000;
let result = back_patch_param_dict(&mut bytes, &offsets);
assert!(result.is_err(), "back_patch must Err on /T overflow");
assert_eq!(
bytes, original,
"overflow on a late field must NOT leave earlier placeholders mutated \
(preflight-then-write contract)"
);
}
#[test]
fn linearized_document_back_patch_method_works() {
let mut doc = build_linearized();
doc.back_patch().expect("LinearizedDocument::back_patch");
let expected_l = format!("{:010}", doc.offsets.file_length);
let ph = &doc.offsets.part1_placeholders;
let actual_l = std::str::from_utf8(&doc.bytes[ph.l.clone()]).expect("UTF-8");
assert_eq!(
actual_l, expected_l,
"/L must be back-patched to file_length"
);
}
#[test]
fn output_contains_l_substring() {
let mut doc = build_linearized();
doc.back_patch().expect("back_patch");
let expected_value = format!("{:010}", doc.offsets.file_length);
let needle = format!("/L {}", expected_value);
assert!(
doc.bytes
.windows(needle.len())
.any(|w| w == needle.as_bytes()),
"back-patched bytes must contain '{needle}'"
);
}
#[test]
fn round_trip_back_patch_then_open() {
let mut doc = build_linearized();
doc.back_patch().expect("back_patch");
Pdf::open(Cursor::new(doc.bytes))
.expect("back-patched linearized PDF must be parseable by Pdf::open");
}
#[test]
fn t_value_matches_last_xref_offset() {
let mut doc = build_linearized();
doc.back_patch().expect("back_patch");
let ph = &doc.offsets.part1_placeholders;
let t_bytes = &doc.bytes[ph.t.clone()];
let t_str = std::str::from_utf8(t_bytes).expect("UTF-8");
let t_val: usize = t_str.trim_start_matches('0').parse().unwrap_or(0);
assert_eq!(
t_val, doc.offsets.last_xref_offset,
"/T back-patched value must equal last_xref_offset"
);
}
#[test]
fn n_value_matches_page_count() {
let mut doc = build_linearized();
doc.back_patch().expect("back_patch");
let ph = &doc.offsets.part1_placeholders;
let n_bytes = &doc.bytes[ph.n.clone()];
let n_str = std::str::from_utf8(n_bytes).expect("UTF-8");
let n_val: u32 = n_str.trim_start_matches('0').parse().unwrap_or(0);
assert_eq!(n_val, doc.offsets.page_count, "/N must equal page_count");
}
#[test]
fn back_patch_is_idempotent() {
let mut doc1 = build_linearized();
doc1.back_patch().expect("first back_patch");
let after_first = doc1.bytes.clone();
back_patch_param_dict(&mut doc1.bytes, &doc1.offsets).expect("second back_patch");
assert_eq!(doc1.bytes, after_first, "back_patch must be idempotent");
}
}