#[cfg(test)]
use std::collections::HashMap;
use std::collections::{BTreeSet, VecDeque};
use std::io::{Read, Seek};
use crate::object_ref::ObjectRef;
use crate::parser::MAX_PARSE_DEPTH;
#[cfg(test)]
use crate::qpdf_obj_gen::QpdfObjGen;
#[cfg(test)]
use crate::writer::object_streams::sort_source_backed_members_qpdf_order;
#[cfg(test)]
use crate::writer::object_streams::ObjectStreamGroup;
use crate::Error;
use crate::Pdf;
#[cfg(test)]
use crate::XrefEntry;
type LinearizedStreamParameterOmission<'a> =
Option<&'a dyn Fn(&crate::ObjectHandle) -> crate::Result<bool>>;
#[cfg(test)]
pub(crate) trait NewNumberLookup {
fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef>;
}
#[cfg(test)]
impl NewNumberLookup for ObjectStreamRenumber {
fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef> {
self.old_to_new.get(&original).copied()
}
}
#[cfg(test)]
impl NewNumberLookup for HashMap<ObjectRef, ObjectRef> {
fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef> {
self.get(&original).copied()
}
}
#[cfg(test)]
fn qpdf_source_objstm_containers<R: Read + Seek>(pdf: &Pdf<R>) -> BTreeSet<ObjectRef> {
pdf.source_xref_entries()
.into_values()
.filter_map(|entry| match entry {
XrefEntry::Compressed { stream, .. } => Some(ObjectRef::new(stream, 0)),
XrefEntry::Free { .. } | XrefEntry::Uncompressed { .. } => None,
})
.collect()
}
#[cfg(test)]
fn writer_local_raw_ref(raw: QpdfObjGen) -> Option<ObjectRef> {
let object = u32::try_from(raw.get_obj()).ok()?;
if object == 0 {
return None;
}
Some(ObjectRef::new(u32::MAX - object, 0))
}
#[cfg(test)]
pub(crate) struct CanonicalCatalogFirstRenumber {
old_to_new: HashMap<ObjectRef, ObjectRef>,
order: Vec<ObjectRef>,
#[cfg(test)]
raw_sources: HashMap<ObjectRef, QpdfObjGen>,
}
#[cfg(test)]
impl NewNumberLookup for CanonicalCatalogFirstRenumber {
fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef> {
self.old_to_new.get(&original).copied()
}
}
#[cfg(test)]
impl CanonicalCatalogFirstRenumber {
pub(crate) fn new_for_original(&self, original: ObjectRef) -> Option<ObjectRef> {
self.old_to_new.get(&original).copied()
}
pub(crate) fn pairs(&self) -> impl Iterator<Item = (ObjectRef, ObjectRef)> + '_ {
self.order
.iter()
.enumerate()
.map(|(index, &source)| (ObjectRef::new(index as u32 + 1, 0), source))
}
#[cfg(test)]
pub(crate) fn raw_source_for(&self, source: ObjectRef) -> Option<QpdfObjGen> {
self.raw_sources.get(&source).copied()
}
pub(crate) fn build_qpdf<R: Read + Seek>(
pdf: &mut Pdf<R>,
skip_length: bool,
preserve_unreferenced_objects: bool,
removed_refs: &BTreeSet<ObjectRef>,
) -> crate::Result<Self> {
let root_ref = pdf.root_ref();
let direct_root = if root_ref.is_none() {
let candidate = pdf.trailer_key_handle(b"Root");
if candidate.try_is_null()? {
return Err(Error::Unsupported(
"plain rewrite: trailer has no /Root".to_string(),
));
}
Some(pdf.root_handle()?)
} else {
None
};
let mut raw_sources = HashMap::new();
let mut seeds = if preserve_unreferenced_objects {
let mut seeds = Vec::new();
let source_objstm_containers = qpdf_source_objstm_containers(pdf);
for handle in pdf.get_all_objects()? {
let object_ref = if let Some(object_ref) = handle.object_ref() {
object_ref
} else if let Some(raw) = handle.qpdf_obj_gen().filter(|raw| raw.is_indirect()) {
let Some(local_ref) = writer_local_raw_ref(raw) else {
continue;
};
raw_sources.insert(local_ref, raw);
local_ref
} else {
continue;
};
if object_ref.number == 0
|| removed_refs.contains(&object_ref)
|| source_objstm_containers.contains(&object_ref)
{
continue;
}
seeds.push(object_ref);
}
seeds
} else {
Vec::new()
};
if let Some(root) = root_ref {
seeds.push(root);
} else if let Some(root) = &direct_root {
collect_canonical_enqueue_refs(pdf, root, 0, skip_length, &mut seeds)?;
}
let trailer = pdf.trailer();
let trailer_entries = trailer.try_as_dictionary()?.unwrap_or_default();
for (key, value) in trailer_entries {
if matches!(
key.as_slice(),
b"/ID" | b"/Encrypt" | b"/Prev" | b"/Root" | b"/Size"
) {
continue;
}
if !value.try_is_null()? {
collect_canonical_enqueue_refs(pdf, &value, 0, skip_length, &mut seeds)?;
}
}
let mut old_to_new = HashMap::new();
let mut order = Vec::new();
let mut queue = VecDeque::new();
for seed in seeds {
if !removed_refs.contains(&seed) {
enqueue(seed, &mut old_to_new, &mut order, &mut queue);
}
}
while let Some(source) = queue.pop_front() {
let handle = raw_sources
.get(&source)
.map(|raw| pdf.get_object_handle_by_raw_identity(raw.get_obj(), raw.get_gen()))
.unwrap_or_else(|| pdf.get_object_handle(source));
let mut found = Vec::new();
collect_canonical_children(pdf, &handle, 0, skip_length, &mut found)?;
for reference in found {
if !removed_refs.contains(&reference) {
enqueue(reference, &mut old_to_new, &mut order, &mut queue);
}
}
}
Ok(Self {
old_to_new,
order,
#[cfg(test)]
raw_sources,
})
}
}
pub(crate) fn collect_canonical_enqueue_refs<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &crate::ObjectHandle,
depth: usize,
skip_length: bool,
found: &mut Vec<ObjectRef>,
) -> crate::Result<()> {
collect_canonical_enqueue_refs_with_linearized_omission(
pdf,
handle,
depth,
skip_length,
found,
None,
)
}
fn collect_canonical_enqueue_refs_with_linearized_omission<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &crate::ObjectHandle,
depth: usize,
skip_length: bool,
found: &mut Vec<ObjectRef>,
stream_parameter_omission: LinearizedStreamParameterOmission<'_>,
) -> crate::Result<()> {
if let Some(object_ref) = handle.object_ref() {
ensure_canonical_owner(pdf, handle)?;
if object_ref.number != 0 {
found.push(object_ref);
}
return Ok(());
}
collect_canonical_children_with_linearized_omission(
pdf,
handle,
depth,
skip_length,
found,
stream_parameter_omission,
)
}
#[cfg(test)]
pub(crate) fn collect_canonical_children<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &crate::ObjectHandle,
depth: usize,
skip_length: bool,
found: &mut Vec<ObjectRef>,
) -> crate::Result<()> {
collect_canonical_children_with_linearized_omission(
pdf,
handle,
depth,
skip_length,
found,
None,
)
}
fn collect_canonical_children_with_linearized_omission<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &crate::ObjectHandle,
depth: usize,
skip_length: bool,
found: &mut Vec<ObjectRef>,
stream_parameter_omission: LinearizedStreamParameterOmission<'_>,
) -> crate::Result<()> {
if depth > MAX_PARSE_DEPTH {
return Err(Error::Unsupported(
"plain rewrite: inline object nesting exceeds MAX_PARSE_DEPTH during canonical enqueue collection"
.to_string(),
));
}
if let Some(items) = handle.try_as_array()? {
for item in items {
collect_canonical_enqueue_refs_with_linearized_omission(
pdf,
&item,
depth + 1,
skip_length,
found,
stream_parameter_omission,
)?; }
return Ok(());
}
if let Some(entries) = handle.try_as_dictionary()? {
for (_, value) in entries {
if !value.try_is_null()? {
collect_canonical_enqueue_refs_with_linearized_omission(
pdf,
&value,
depth + 1,
skip_length,
found,
stream_parameter_omission,
)?; }
}
return Ok(());
}
if let Some(stream_dict) = handle.as_stream_dict() {
let skip_stream_parameters = stream_parameter_omission
.map(|predicate| predicate(handle))
.transpose()?
.unwrap_or(false);
if let Some(entries) = stream_dict.try_as_dictionary()? {
for (key, value) in entries {
if skip_length && key.as_slice() == b"/Length" {
continue;
}
if skip_stream_parameters && matches!(key.as_slice(), b"/Filter" | b"/DecodeParms")
{
continue;
}
if !value.try_is_null()? {
collect_canonical_enqueue_refs_with_linearized_omission(
pdf,
&value,
depth + 1,
skip_length,
found,
stream_parameter_omission,
)?; }
}
} }
Ok(())
}
pub(crate) fn ensure_canonical_owner<R: Read + Seek>(
pdf: &Pdf<R>,
handle: &crate::ObjectHandle,
) -> crate::Result<()> {
if !pdf.is_canonical_object_handle(handle) {
return Err(Error::Internal(
"QPDFObjectHandle from different QPDF found while writing. Use QPDF::copyForeignObject to add objects from another file."
.to_string(),
));
}
Ok(())
}
pub(crate) fn reachable_object_set_with_stream_parameters<R: Read + Seek>(
pdf: &mut Pdf<R>,
skip_length: bool,
skipped_stream_parameter_streams: &BTreeSet<crate::qpdf_obj_gen::QpdfObjGen>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let root = pdf
.root_ref()
.ok_or_else(|| Error::Unsupported("reachability: trailer has no /Root".to_string()))?;
let mut seeds: Vec<ObjectRef> = vec![root];
let trailer_entries = pdf.trailer().try_as_dictionary()?.unwrap_or_default();
let skip_stream_parameters = |handle: &crate::ObjectHandle| -> crate::Result<bool> {
Ok(handle
.qpdf_obj_gen()
.is_some_and(|object_gen| skipped_stream_parameter_streams.contains(&object_gen)))
};
for (key, value) in trailer_entries {
if matches!(key.as_slice(), b"/ID" | b"/Prev" | b"/Root" | b"/Size") {
continue;
}
if !value.try_is_null()? {
collect_canonical_enqueue_refs_with_linearized_omission(
pdf,
&value,
0,
skip_length,
&mut seeds,
Some(&skip_stream_parameters),
)?; }
}
let mut reachable: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: VecDeque<ObjectRef> = VecDeque::new();
for seed in seeds {
if reachable.insert(seed) {
queue.push_back(seed);
}
}
while let Some(cur) = queue.pop_front() {
let handle = pdf.get_object_handle(cur);
let mut found = Vec::new();
collect_canonical_children_with_linearized_omission(
pdf,
&handle,
0,
skip_length,
&mut found,
Some(&skip_stream_parameters),
)?; for r in found {
if reachable.insert(r) {
queue.push_back(r);
}
}
}
Ok(reachable)
}
pub(crate) fn resurrectable_null_refs_excluding<R: Read + Seek>(
pdf: &mut Pdf<R>,
removed_refs: &BTreeSet<ObjectRef>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let root = pdf
.root_ref()
.ok_or_else(|| Error::Unsupported("resurrectable: trailer has no /Root".to_string()))?;
let mut result: BTreeSet<ObjectRef> = BTreeSet::new();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: VecDeque<ObjectRef> = VecDeque::from([root]);
let trailer_entries = pdf.trailer().try_as_dictionary()?.unwrap_or_default();
for (key, value) in trailer_entries {
if matches!(key.as_slice(), b"/ID" | b"/Prev" | b"/Root" | b"/Size") {
continue;
}
let mut follow: Vec<ObjectRef> = Vec::new();
let mut state = ResurrectableWalkState {
follow: &mut follow,
result: &mut result,
removed_refs,
};
walk_resurrectable_handle(&value, 0, false, true, &mut state)?;
queue.extend(follow);
}
while let Some(cur) = queue.pop_front() {
if !visited.insert(cur) {
continue;
}
let handle = pdf.get_object_handle(cur);
let mut follow: Vec<ObjectRef> = Vec::new();
let mut state = ResurrectableWalkState {
follow: &mut follow,
result: &mut result,
removed_refs,
};
walk_resurrectable_handle(&handle, 0, false, false, &mut state)?;
for r in follow {
if !visited.contains(&r) {
queue.push_back(r);
}
}
}
Ok(result)
}
struct ResurrectableWalkState<'a> {
follow: &'a mut Vec<ObjectRef>,
result: &'a mut BTreeSet<ObjectRef>,
removed_refs: &'a BTreeSet<ObjectRef>,
}
fn walk_resurrectable_handle(
handle: &crate::ObjectHandle,
depth: usize,
in_array: bool,
edge_context: bool,
state: &mut ResurrectableWalkState<'_>,
) -> crate::Result<()> {
if depth > MAX_PARSE_DEPTH {
return Err(Error::Unsupported(
"linearization: inline nesting exceeds MAX_PARSE_DEPTH during resurrectable walk"
.to_string(),
));
}
let is_null = handle.try_is_null()?;
let edge_ref = edge_context.then_some(handle.object_ref()).flatten();
if is_null {
if in_array {
if let Some(reference) = edge_ref {
if reference.number > 0 && !state.removed_refs.contains(&reference) {
state.result.insert(reference);
}
}
}
return Ok(());
}
if let Some(reference) = edge_ref {
if reference.number > 0 {
state.follow.push(reference);
}
return Ok(());
}
if let Some(elements) = handle.try_as_array()? {
for element in elements {
walk_resurrectable_handle(&element, depth + 1, true, true, state)?;
}
return Ok(());
}
if let Some(entries) = handle.try_as_dictionary()? {
for (_key, value) in entries {
walk_resurrectable_handle(&value, depth + 1, false, true, state)?;
}
return Ok(());
}
if let Some(stream_dict) = handle.as_stream_dict() {
if let Some(entries) = stream_dict.try_as_dictionary()? {
for (_key, value) in entries {
walk_resurrectable_handle(&value, depth + 1, false, true, state)?;
}
}
}
Ok(())
}
#[cfg(test)]
pub(crate) struct ObjectStreamRenumber {
old_to_new: HashMap<ObjectRef, ObjectRef>,
#[cfg(test)]
raw_sources: HashMap<ObjectRef, QpdfObjGen>,
container_new: Vec<Option<u32>>,
}
#[cfg(test)]
impl ObjectStreamRenumber {
pub(crate) fn container_number(&self, group_index: usize) -> Option<u32> {
self.container_new.get(group_index).copied().flatten()
}
#[cfg(test)]
pub(crate) fn raw_source_for(&self, source: ObjectRef) -> Option<QpdfObjGen> {
self.raw_sources.get(&source).copied()
}
pub(crate) fn pairs(&self) -> impl Iterator<Item = (ObjectRef, ObjectRef)> + '_ {
self.old_to_new.iter().map(|(&old, &new)| (new, old))
}
pub(crate) fn build<R: Read + Seek>(
pdf: &mut Pdf<R>,
groups: &[ObjectStreamGroup],
skip_length: bool,
removed_refs: &BTreeSet<ObjectRef>,
preserve_unreferenced_objects: bool,
) -> crate::Result<Self> {
Self::build_with_seed_policy(
pdf,
groups,
skip_length,
removed_refs,
preserve_unreferenced_objects,
)
}
fn build_with_seed_policy<R: Read + Seek>(
pdf: &mut Pdf<R>,
groups: &[ObjectStreamGroup],
skip_length: bool,
removed_refs: &BTreeSet<ObjectRef>,
preserve_unreferenced_objects: bool,
) -> crate::Result<Self> {
let mut member_to_group: HashMap<ObjectRef, usize> = HashMap::new();
let mut source_to_group: HashMap<ObjectRef, usize> = HashMap::new();
let mut groups_sorted: Vec<Vec<ObjectRef>> = Vec::with_capacity(groups.len());
for (gi, group) in groups.iter().enumerate() {
let mut sorted = group.members().to_vec();
if sorted.is_empty() {
return Err(Error::Unsupported(format!(
"object-stream renumber: group {gi} has no members"
)));
}
if matches!(group, ObjectStreamGroup::SourceBacked { .. }) {
sort_source_backed_members_qpdf_order(pdf, &mut sorted);
} else if pdf.writer_object_order.is_some() {
sorted.sort_unstable_by_key(|object_ref| pdf.writer_object_order_key(*object_ref));
} else {
sorted.sort_unstable_by_key(|r| (r.number, r.generation));
}
for &m in &sorted {
if let Some(previous) = member_to_group.insert(m, gi) {
return Err(Error::Unsupported(format!(
"object-stream renumber: member {m} occurs in groups {previous} and {gi}"
)));
}
}
let source = match group {
ObjectStreamGroup::SourceBacked { source, .. }
| ObjectStreamGroup::Generated { source, .. } => *source,
};
if let Some(previous) = source_to_group.insert(source, gi) {
return Err(Error::Unsupported(format!(
"object-stream renumber: source container {source} occurs in groups {previous} and {gi}"
)));
}
groups_sorted.push(sorted);
}
if let Some(source) = source_to_group
.keys()
.find(|source| member_to_group.contains_key(source))
{
return Err(Error::Unsupported(format!(
"object-stream renumber: source container {source} is also a member"
)));
}
let generated_container_sources: BTreeSet<ObjectRef> = groups
.iter()
.filter_map(|group| match group {
ObjectStreamGroup::Generated { source, .. } => Some(*source),
ObjectStreamGroup::SourceBacked { .. } => None,
})
.collect();
let mut old_to_new: HashMap<ObjectRef, ObjectRef> = HashMap::new();
let mut container_new: Vec<Option<u32>> = vec![None; groups.len()];
let mut next: u32 = 1;
let mut queue: VecDeque<RenumberWork> = VecDeque::new();
let root_ref = pdf.root_ref();
let direct_root = if root_ref.is_none() {
let candidate = pdf.trailer_key_handle(b"Root");
if candidate.try_is_null()? {
return Err(Error::Unsupported(
"object-stream renumber: trailer has no /Root".to_string(),
));
}
Some(pdf.root_handle()?)
} else {
None
};
let mut raw_sources = HashMap::new();
let mut seeds: Vec<ObjectRef> = if preserve_unreferenced_objects {
let mut seeds = Vec::new();
for handle in pdf.get_all_objects()? {
let source = if let Some(object_ref) = handle.object_ref() {
object_ref
} else if let Some(raw) = handle.qpdf_obj_gen().filter(|raw| raw.is_indirect()) {
let Some(local_ref) = writer_local_raw_ref(raw) else {
continue;
};
raw_sources.insert(local_ref, raw);
local_ref
} else {
continue;
};
if !removed_refs.contains(&source) && !generated_container_sources.contains(&source)
{
seeds.push(source);
}
}
seeds
} else {
Vec::new()
};
if let Some(root) = root_ref {
seeds.push(root);
} else if let Some(root) = &direct_root {
collect_canonical_enqueue_refs(pdf, root, 0, skip_length, &mut seeds)?;
} let trailer = pdf.trailer();
let trailer_entries = trailer.try_as_dictionary()?.unwrap_or_default();
for (key, value) in trailer_entries {
if matches!(
key.as_slice(),
b"/ID" | b"/Encrypt" | b"/Prev" | b"/Root" | b"/Size"
) {
continue;
}
if value.try_is_null()? {
continue;
}
collect_canonical_enqueue_refs(pdf, &value, 0, skip_length, &mut seeds)?;
}
seeds.retain(|reference| !removed_refs.contains(reference));
for seed in seeds {
enqueue_object_stream(
seed,
groups,
&member_to_group,
&source_to_group,
&groups_sorted,
&mut old_to_new,
&mut container_new,
&mut next,
&mut queue,
);
}
while let Some(work) = queue.pop_front() {
match work {
RenumberWork::Ordinary(cur) => {
let handle = raw_sources
.get(&cur)
.map(|raw| {
pdf.get_object_handle_by_raw_identity(raw.get_obj(), raw.get_gen())
})
.unwrap_or_else(|| pdf.get_object_handle(cur));
let mut found = Vec::new();
collect_canonical_children(pdf, &handle, 0, skip_length, &mut found)?; found.retain(|reference| !removed_refs.contains(reference));
for reference in found {
enqueue_object_stream(
reference,
groups,
&member_to_group,
&source_to_group,
&groups_sorted,
&mut old_to_new,
&mut container_new,
&mut next,
&mut queue,
);
}
}
RenumberWork::SourceContainer(source) => {
if removed_refs.contains(&source) {
continue;
}
let handle = pdf.get_object_handle(source);
if handle.try_is_null()? {
continue;
}
let stream_dict = handle.as_stream_dict().ok_or_else(|| {
Error::Unsupported(format!(
"object-stream renumber: source container {source} is not a stream"
))
})?;
let extends = stream_dict.try_get_key(b"/Extends")?.object_ref();
if let Some(extends) = extends.filter(|extends| !removed_refs.contains(extends))
{
enqueue_object_stream(
extends,
groups,
&member_to_group,
&source_to_group,
&groups_sorted,
&mut old_to_new,
&mut container_new,
&mut next,
&mut queue,
);
}
}
}
}
Ok(Self {
old_to_new,
container_new,
#[cfg(test)]
raw_sources,
})
}
}
#[derive(Clone, Copy, Debug)]
#[cfg(test)]
enum RenumberWork {
Ordinary(ObjectRef),
SourceContainer(ObjectRef),
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
fn enqueue_object_stream(
r: ObjectRef,
groups: &[ObjectStreamGroup],
member_to_group: &HashMap<ObjectRef, usize>,
source_to_group: &HashMap<ObjectRef, usize>,
groups_sorted: &[Vec<ObjectRef>],
old_to_new: &mut HashMap<ObjectRef, ObjectRef>,
container_new: &mut [Option<u32>],
next: &mut u32,
queue: &mut VecDeque<RenumberWork>,
) {
if old_to_new.contains_key(&r) {
return;
}
let group_index = member_to_group
.get(&r)
.or_else(|| source_to_group.get(&r))
.copied();
match group_index {
Some(gi) => {
let container = *next;
container_new[gi] = Some(container);
*next += 1;
let source = match &groups[gi] {
ObjectStreamGroup::SourceBacked { source, .. }
| ObjectStreamGroup::Generated { source, .. } => {
old_to_new.insert(*source, ObjectRef::new(container, 0));
Some(*source)
}
};
for &m in &groups_sorted[gi] {
old_to_new.insert(m, ObjectRef::new(*next, 0));
*next += 1;
queue.push_back(RenumberWork::Ordinary(m));
}
if let Some(source) = source {
queue.push_back(RenumberWork::SourceContainer(source));
}
}
None => {
old_to_new.insert(r, ObjectRef::new(*next, 0));
*next += 1;
queue.push_back(RenumberWork::Ordinary(r));
}
}
}
#[cfg(test)]
fn enqueue(
original: ObjectRef,
old_to_new: &mut HashMap<ObjectRef, ObjectRef>,
order: &mut Vec<ObjectRef>,
queue: &mut VecDeque<ObjectRef>,
) {
if old_to_new.contains_key(&original) {
return;
}
let new_ref = ObjectRef::new(order.len() as u32 + 1, 0);
old_to_new.insert(original, new_ref);
order.push(original);
queue.push_back(original);
}
#[cfg(test)]
mod tests {
use super::{
collect_canonical_children, ensure_canonical_owner, walk_resurrectable_handle,
writer_local_raw_ref, NewNumberLookup, ObjectStreamRenumber, ResurrectableWalkState,
};
use crate::parser::MAX_PARSE_DEPTH;
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::writer::object_streams::ObjectStreamGroup;
use crate::{Error, ObjectHandle, ObjectRef, Pdf};
use std::collections::{BTreeMap, BTreeSet};
use std::io::Cursor;
fn raw_stream_pdf() -> Vec<u8> {
let mut bytes = b"%PDF-1.4\n".to_vec();
let catalog_offset = bytes.len();
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let stream_offset = bytes.len();
bytes.extend_from_slice(
b"5 65536 obj\n<< /Length 3 >>\nstream\nabc\nendstream\nendobj\n%tail\n",
);
let xref_offset = bytes.len();
bytes.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
bytes.extend_from_slice(format!("{catalog_offset:010} 00000 n \n").as_bytes());
bytes.extend_from_slice(b"0000000000 00000 f \n0000000000 00000 f \n0000000000 00000 f \n");
bytes.extend_from_slice(format!("{stream_offset:010} 65536 n \n").as_bytes());
bytes.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n")
.as_bytes(),
);
bytes
}
#[test]
fn writer_local_raw_ref_rejects_qpdf_object_zero() {
assert_eq!(writer_local_raw_ref(QpdfObjGen::new(0, 65_536)), None);
}
#[test]
fn writer_local_raw_ref_keeps_a_raw_generation_stream_unregistered() {
let mut pdf = Pdf::open(Cursor::new(raw_stream_pdf())).expect("open raw stream PDF");
let handle = pdf
.get_all_objects()
.unwrap()
.into_iter()
.find(|handle| handle.qpdf_obj_gen() == Some(QpdfObjGen::new(5, 65_536)))
.expect("raw stream cache entry");
let raw = handle.qpdf_obj_gen().expect("raw identity");
assert_eq!(
writer_local_raw_ref(raw),
Some(ObjectRef::new(u32::MAX - 5, 0))
);
assert_eq!(pdf.get_all_objects().unwrap().len(), 2);
}
#[test]
fn preserve_walk_reuses_raw_qpdf_identity_for_an_ordinary_seed() {
let mut pdf = Pdf::open(Cursor::new(raw_stream_pdf())).expect("open raw stream PDF");
let local_ref = writer_local_raw_ref(QpdfObjGen::new(5, 65_536)).unwrap();
let renumber = ObjectStreamRenumber::build(&mut pdf, &[], false, &BTreeSet::new(), true)
.expect("preserve walk should resolve raw source seeds");
assert_eq!(
renumber.raw_source_for(local_ref),
Some(QpdfObjGen::new(5, 65_536))
);
}
#[test]
fn writer_foreign_owner_is_a_qpdf_logic_error() {
let mut first = Pdf::empty().expect("create first empty PDF");
let second = Pdf::empty().expect("create second empty PDF");
let root_ref = first.root_ref().expect("first PDF has a root");
let foreign_root = first.get_object_handle(root_ref);
let error = ensure_canonical_owner(&second, &foreign_root)
.expect_err("a foreign object must be rejected by the writer");
assert!(matches!(
error,
Error::Internal(message)
if message == "QPDFObjectHandle from different QPDF found while writing. Use QPDF::copyForeignObject to add objects from another file."
));
}
#[test]
fn object_stream_renumber_rejects_a_duplicate_source_container() {
let mut pdf = Pdf::empty().expect("create object-stream owner");
let source = pdf
.make_indirect_object_handle(ObjectHandle::null())
.expect("create source container")
.object_ref()
.unwrap();
let first = pdf
.make_indirect_object_handle(ObjectHandle::integer(1))
.expect("create first member")
.object_ref()
.unwrap();
let second = pdf
.make_indirect_object_handle(ObjectHandle::integer(2))
.expect("create second member")
.object_ref()
.unwrap();
let groups = [
ObjectStreamGroup::Generated {
source,
members: vec![first],
},
ObjectStreamGroup::Generated {
source,
members: vec![second],
},
];
let error = ObjectStreamRenumber::build(&mut pdf, &groups, false, &BTreeSet::new(), false)
.err()
.expect("duplicate source containers must fail before traversal");
assert!(
matches!(error, Error::Unsupported(message) if message.contains("source container") && message.contains("groups 0 and 1"))
);
}
#[test]
fn generated_object_stream_renumber_uses_recorded_writer_order() {
let mut pdf = Pdf::empty().expect("create generated object-stream owner");
let source = pdf
.make_indirect_object_handle(ObjectHandle::null())
.expect("create generated source container")
.object_ref()
.unwrap();
let first = pdf
.make_indirect_object_handle(ObjectHandle::integer(1))
.expect("create first generated member")
.object_ref()
.unwrap();
let second = pdf
.make_indirect_object_handle(ObjectHandle::integer(2))
.expect("create second generated member")
.object_ref()
.unwrap();
let mut order = BTreeMap::new();
order.insert(
first,
crate::pdf::WriterObjectOrderKey::foreign(ObjectRef::new(2, 0)),
);
order.insert(
second,
crate::pdf::WriterObjectOrderKey::foreign(ObjectRef::new(1, 0)),
);
pdf.set_writer_object_order(order);
let groups = [ObjectStreamGroup::Generated {
source,
members: vec![first, second],
}];
let renumber =
ObjectStreamRenumber::build(&mut pdf, &groups, false, &BTreeSet::new(), true)
.expect("generated object-stream order must be accepted");
assert!(renumber.new_for_original(first).is_some());
assert!(renumber.new_for_original(second).is_some());
}
#[test]
fn resurrectable_walk_rejects_programmatic_depth_beyond_parser_limit() {
let mut follow = Vec::new();
let mut result = BTreeSet::new();
let removed_refs = BTreeSet::new();
let mut state = ResurrectableWalkState {
follow: &mut follow,
result: &mut result,
removed_refs: &removed_refs,
};
let error = walk_resurrectable_handle(
&ObjectHandle::null(),
MAX_PARSE_DEPTH + 1,
false,
false,
&mut state,
)
.expect_err("the resurrectable walk has a parser-depth guard");
assert!(error.to_string().contains("MAX_PARSE_DEPTH"));
}
#[test]
fn canonical_children_propagate_resolution_errors() {
let mut pdf = Pdf::empty().expect("create a document for the walk");
let unresolved = ObjectHandle::new_indirect_unresolved(ObjectRef::new(91, 0), -1);
let mut found = Vec::new();
let error = collect_canonical_children(&mut pdf, &unresolved, 0, false, &mut found)
.expect_err("an unresolved child must remain a fallible traversal");
assert!(matches!(
error,
Error::Internal(message) if message == "object 91 0 belongs to a dropped PDF"
));
}
#[test]
fn resurrectable_walk_propagates_resolution_errors() {
let unresolved = ObjectHandle::new_indirect_unresolved(ObjectRef::new(92, 0), -1);
let mut follow = Vec::new();
let mut result = BTreeSet::new();
let removed_refs = BTreeSet::new();
let mut state = ResurrectableWalkState {
follow: &mut follow,
result: &mut result,
removed_refs: &removed_refs,
};
let error = walk_resurrectable_handle(&unresolved, 0, false, false, &mut state)
.expect_err("the resurrectable walk must propagate resolution errors");
assert!(matches!(
error,
Error::Internal(message) if message == "object 92 0 belongs to a dropped PDF"
));
}
}