use crate::content_stream::parse_content_stream_handles;
use crate::filters::{decode_stream_data_from_handle, DecodeLimits};
use crate::page_object_helper::PageObjectHelper;
use crate::resource_finder::{ResourceFinder, ResourceNamesByType};
use crate::{Error, ObjectHandle, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet, VecDeque};
use std::io::{Read, Seek};
type UsedNames = BTreeMap<Vec<u8>, BTreeSet<Vec<u8>>>;
fn diagnostic_count<R: Read + Seek>(pdf: &Pdf<R>) -> usize {
pdf.num_warnings()
}
pub(crate) fn remove_unreferenced_resources_on_page<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<()> {
let (unresolved, any_failures) = remove_unreferenced_resources_in_form_xobjects(pdf, page_ref)?;
if any_failures {
return Ok(());
}
let diagnostics_before = diagnostic_count(pdf);
let (finder, parse_ok) = {
let mut helper = PageObjectHelper::new(page_ref, pdf);
let mut finder = ResourceFinder::default();
let parse_ok = helper.parse_contents(&mut finder).is_ok() && !finder.has_pending_operands();
(finder, parse_ok)
};
if !parse_ok || diagnostic_count(pdf) > diagnostics_before {
return Ok(());
}
let resources = PageObjectHelper::new(page_ref, pdf).get_resources(true)?;
if resources.is_null() {
return Ok(());
}
for category in [b"/Font".as_slice(), b"/XObject".as_slice()] {
let value = resources.get_key(category);
if value.is_null() {
continue;
}
pdf.resolve(&value)?;
if value.as_dictionary().is_none() {
continue;
}
let dictionary = if value.is_indirect() {
let copy = value.shallow_copy()?;
resources.replace_key(category, copy.clone())?;
copy
} else {
value
};
let names = finder.names();
let remove = dictionary
.as_dictionary()
.into_iter()
.flat_map(|entries| entries.into_keys())
.filter(|name| {
let resource_name = name.strip_prefix(b"/").unwrap_or(name.as_slice());
!names.contains(resource_name)
&& !unresolved
.iter()
.any(|unresolved_name| unresolved_name.as_slice() == resource_name)
})
.collect::<Vec<_>>();
for name in remove {
dictionary.remove_key(&name);
}
pdf.mark_object_handle_dirty(&dictionary)?;
}
pdf.mark_object_handle_dirty(&resources)
}
pub(crate) fn remove_unreferenced_resources_on_form<R: Read + Seek>(
pdf: &mut Pdf<R>,
form: ObjectHandle,
) -> Result<()> {
let mut nested_forms = Vec::new();
{
let mut helper = PageObjectHelper::from_object_handle(form.clone(), pdf);
helper.for_each_form_xobject(true, |nested, _, _| {
nested_forms.push(nested);
Ok(())
})?;
}
for nested in nested_forms {
prune_canonical_resource_target(pdf, nested)?;
}
prune_canonical_resource_target(pdf, form)
}
fn prune_canonical_resource_target<R: Read + Seek>(
pdf: &mut Pdf<R>,
target: ObjectHandle,
) -> Result<()> {
let diagnostics_before = diagnostic_count(pdf);
let (finder, parse_ok) = {
let mut helper = PageObjectHelper::from_object_handle(target.clone(), pdf);
let mut finder = ResourceFinder::default();
let parse_ok = helper.parse_contents(&mut finder).is_ok() && !finder.has_pending_operands();
(finder, parse_ok)
};
if !parse_ok || diagnostic_count(pdf) > diagnostics_before {
return Ok(());
}
let resources = PageObjectHelper::from_object_handle(target, pdf).get_resources(true)?;
if resources.is_null() {
return Ok(());
}
let categories = [b"/Font".as_slice(), b"/XObject".as_slice()];
let mut dictionaries = Vec::new();
let mut known_names = BTreeSet::new();
for category in categories {
let value = resources.get_key(category);
if value.is_null() {
continue;
}
pdf.resolve(&value)?;
if value.as_dictionary().is_none() {
continue;
}
let dictionary = if value.is_indirect() {
let copy = value.shallow_copy()?;
resources.replace_key(category, copy.clone())?;
copy
} else {
value
};
let live_keys = dictionary.try_get_keys()?;
known_names.extend(
live_keys
.iter()
.map(|key| key.strip_prefix(b"/").unwrap_or(key.as_slice()).to_vec()),
);
dictionaries.push((category, dictionary, live_keys));
}
let local_unresolved = categories
.iter()
.filter_map(|category| finder.names_by_resource_type().get(&category[1..]))
.flat_map(|entries| entries.keys())
.filter(|name| !known_names.contains(*name))
.cloned()
.collect::<BTreeSet<_>>();
if !local_unresolved.is_empty() && resources.as_dictionary().is_some() {
pdf.mark_object_handle_dirty(&resources)?;
return Ok(());
}
for (_category, dictionary, live_keys) in dictionaries {
let Some(entries) = dictionary.as_dictionary() else {
continue;
};
let names = finder.names();
let remove = entries
.keys()
.filter(|key| live_keys.contains(*key))
.filter(|key| {
let name = key.strip_prefix(b"/").unwrap_or(key.as_slice());
!names.contains(name)
})
.cloned()
.collect::<Vec<_>>();
for key in remove {
dictionary.remove_key(&key);
}
pdf.mark_object_handle_dirty(&dictionary)?;
}
pdf.mark_object_handle_dirty(&resources)
}
fn remove_unreferenced_resources_in_form_xobjects<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<(BTreeSet<Vec<u8>>, bool)> {
let page_resources = {
let mut helper = PageObjectHelper::new(page_ref, pdf);
helper.get_resources(false)?
};
if page_resources.is_null() {
return Ok((BTreeSet::new(), false));
}
let mut pending = VecDeque::from(form_xobjects_in_resources(pdf, &page_resources)?);
let mut visited = BTreeSet::new();
let mut unresolved = BTreeSet::new();
let mut any_failures = false;
while let Some(form_ref) = pending.pop_front() {
if !visited.insert(form_ref) {
continue;
}
let holder_handle = pdf.get_object_handle(form_ref);
let form_handle = pdf.resolve_handle(&holder_handle)?;
if !form_handle.is_form_xobject()? {
continue; }
let stream_dict = form_stream_dict(&form_handle)?;
let resources = pdf.resolve_handle(&stream_dict.try_get_key(b"/Resources")?)?;
let resources = resources
.try_as_dictionary()?
.map(|_| resources)
.filter(|handle| !handle.is_null());
let decoded = (|| -> Result<Vec<u8>> {
let stream_data = form_handle.get_raw_stream_data()?;
decode_stream_data_from_handle(
&stream_dict,
stream_data.as_ref(),
DecodeLimits::default(),
)
})();
let Ok(bytes) = decoded else {
any_failures = true;
if let Some(resources) = resources.as_ref() {
pending.extend(form_xobjects_in_resources(pdf, resources)?);
} continue;
};
let Some(used) = collect_used_names_for_form(&bytes) else {
any_failures = true;
if let Some(resources) = resources.as_ref() {
pending.extend(form_xobjects_in_resources(pdf, resources)?);
} continue;
};
let local_unresolved = unresolved_resource_names(resources.as_ref(), &used)?;
unresolved.extend(local_unresolved.iter().cloned());
let child_forms = match resources.as_ref() {
Some(resources) => form_xobjects_in_resources(pdf, resources)?,
None => Vec::new(),
};
if !local_unresolved.is_empty() && resources.is_some() {
any_failures = true;
} else if let Some(resources) = &resources {
let resources = if resources.is_indirect() {
let copy = resources.shallow_copy()?;
stream_dict.replace_key(b"/Resources", copy.clone())?;
pdf.mark_object_handle_dirty(&stream_dict)?;
copy
} else {
resources.clone()
};
prune_font_and_xobject_dictionaries(pdf, &resources, &used)?;
}
pending.extend(child_forms);
}
Ok((unresolved, any_failures))
}
fn unresolved_resource_names(
resources: Option<&ObjectHandle>,
used: &UsedNames,
) -> Result<BTreeSet<Vec<u8>>> {
let mut known_names: BTreeSet<Vec<u8>> = BTreeSet::new();
if let Some(resources) = resources {
for category in [b"Font".as_slice(), b"XObject".as_slice()] {
let mut key = Vec::with_capacity(category.len() + 1);
key.push(b'/');
key.extend_from_slice(category);
let value = resources.try_get_key(&key)?;
value.try_dereference()?;
let Some(dictionary) = value.try_as_dictionary()? else {
continue;
};
known_names.extend(
dictionary
.keys()
.map(|name| name.strip_prefix(b"/").unwrap_or(name.as_slice()).to_vec()),
);
}
}
let mut unresolved = BTreeSet::new();
for category in [b"Font".as_slice(), b"XObject".as_slice()] {
for name in used
.get(category)
.into_iter()
.flat_map(|names| names.iter())
{
if !known_names.contains(&name.to_vec()) {
unresolved.insert(name.clone());
}
}
}
Ok(unresolved)
}
fn form_xobjects_in_resources<R: Read + Seek>(
pdf: &mut Pdf<R>,
resources: &ObjectHandle,
) -> Result<Vec<ObjectRef>> {
let xobjects = resources.try_get_key(b"/XObject")?;
xobjects.try_dereference()?;
let Some(xobjects) = xobjects.try_as_dictionary()? else {
return Ok(Vec::new());
};
let mut forms = Vec::new();
for value in xobjects.values() {
if !value.is_indirect() {
continue;
}
if !pdf.resolve_handle(value)?.is_form_xobject()? {
continue;
}
if let Some(reference) = value.object_ref() {
forms.push(reference);
}
}
Ok(forms)
}
fn collect_used_names_for_form(stream_bytes: &[u8]) -> Option<UsedNames> {
let mut used = BTreeMap::new();
let mut finder = ResourceFinder::default();
let complete = parse_content_stream_handles(stream_bytes, None, "", &mut finder).is_ok()
&& !finder.has_pending_operands();
if complete {
record_direct_names(&mut used, finder.names_by_resource_type(), true);
Some(used)
} else {
None
}
}
fn prune_font_and_xobject_dictionaries<R: Read + Seek>(
pdf: &mut Pdf<R>,
resources: &ObjectHandle,
used: &UsedNames,
) -> Result<()> {
for category in [b"Font".as_slice(), b"XObject".as_slice()] {
let mut key = Vec::with_capacity(category.len() + 1);
key.push(b'/');
key.extend_from_slice(category);
let value = resources.try_get_key(&key)?;
value.try_dereference()?;
if value.try_as_dictionary()?.is_none() {
continue;
}
let dictionary = if value.is_indirect() {
let copy = value.shallow_copy()?;
resources.replace_key(&key, copy.clone())?;
copy
} else {
value
};
let names = used.get(category).cloned().unwrap_or_default();
let remove = dictionary
.try_get_keys()?
.into_iter()
.filter(|name| !names.contains(name.strip_prefix(b"/").unwrap_or(name.as_slice())))
.collect::<Vec<_>>();
for name in remove {
dictionary.remove_key(&name);
}
pdf.mark_object_handle_dirty(&dictionary)?;
}
Ok(())
}
const RESOURCE_CATEGORIES: &[&str] = &[
"Font",
"XObject",
"ColorSpace",
"Pattern",
"Shading",
"ExtGState",
"Properties",
];
fn is_builtin_color_space_cs_op(name: &[u8]) -> bool {
matches!(
name,
b"DeviceGray" | b"DeviceRGB" | b"DeviceCMYK" | b"Pattern"
)
}
fn record_direct_names(used: &mut UsedNames, names: &ResourceNamesByType, record_direct: bool) {
if !record_direct {
return;
}
for &category in RESOURCE_CATEGORIES {
let category = category.as_bytes();
for name in names
.get(category)
.into_iter()
.flat_map(|by_name| by_name.keys())
{
if category == b"ColorSpace" && is_builtin_color_space_cs_op(name) {
continue;
}
used.entry(category.to_vec())
.or_default()
.insert(name.clone());
}
}
}
fn form_stream_dict(handle: &ObjectHandle) -> Result<ObjectHandle> {
handle.as_stream_dict().ok_or_else(|| {
Error::Internal("Form XObject handle did not resolve to a stream".to_owned())
})
}
#[cfg(test)]
mod final_handle_tests {
use super::{
remove_unreferenced_resources_in_form_xobjects, remove_unreferenced_resources_on_form,
};
use crate::{ObjectHandle, Pdf};
use std::io::Cursor;
use std::rc::Rc;
fn fixture() -> Pdf<Cursor<Vec<u8>>> {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/direct-root-one-page.pdf");
Pdf::open_mem_owned(std::fs::read(path).expect("fixture exists")).expect("fixture opens")
}
fn form_with_resources(pdf: &Pdf<Cursor<Vec<u8>>>, contents: &[u8]) -> ObjectHandle {
let form = pdf
.new_stream_with_data(Rc::new(contents.to_vec()))
.expect("form stream");
let form_dict = form.as_stream_dict().expect("form dictionary");
form_dict
.replace_key(b"/Type", ObjectHandle::name(b"XObject".to_vec()))
.expect("form type");
form_dict
.replace_key(b"/Subtype", ObjectHandle::name(b"Form".to_vec()))
.expect("form subtype");
form_dict
.replace_key(
b"/Resources",
ObjectHandle::dictionary(vec![(
b"/Font".to_vec(),
ObjectHandle::dictionary(vec![
(b"/F1".to_vec(), ObjectHandle::dictionary(Vec::new())),
(b"/Unused".to_vec(), ObjectHandle::dictionary(Vec::new())),
]),
)]),
)
.expect("form resources");
form
}
#[test]
fn form_resource_prepass_resolves_form_and_resource_handles() {
let mut pdf = fixture();
let page_ref = crate::pages::page_refs(&mut pdf).expect("page refs")[0];
let page_handle = pdf.get_object_handle(page_ref);
pdf.resolve(&page_handle).expect("page resolves");
let replacement = page_handle.shallow_copy().expect("page is copyable");
let form = pdf
.new_stream_with_data(Rc::new(b"q Q".to_vec()))
.expect("form stream");
let form_dict = form.as_stream_dict().expect("form dictionary");
form_dict
.replace_key(b"/Type", ObjectHandle::name(b"XObject".to_vec()))
.expect("form type");
form_dict
.replace_key(b"/Subtype", ObjectHandle::name(b"Form".to_vec()))
.expect("form subtype");
form_dict
.replace_key(
b"/Resources",
ObjectHandle::dictionary(vec![(
b"/Font".to_vec(),
ObjectHandle::dictionary(vec![(b"/Unused".to_vec(), ObjectHandle::integer(1))]),
)]),
)
.expect("form resources");
let resources = ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(vec![(b"/Fm0".to_vec(), form)]),
)]);
replacement
.replace_key(b"/Resources", resources)
.expect("page resources");
pdf.replace_object(page_ref, replacement)
.expect("replace page");
let (unresolved, failures) =
remove_unreferenced_resources_in_form_xobjects(&mut pdf, page_ref)
.expect("form resource prepass");
assert!(unresolved.is_empty());
assert!(!failures);
}
#[test]
fn canonical_form_pruning_uses_the_clean_parse_boundary() {
let mut pdf = fixture();
let form = form_with_resources(&pdf, b"/F1 12 Tf");
remove_unreferenced_resources_on_form(&mut pdf, form.clone())
.expect("clean Form content should be pruned");
let resources = form
.as_stream_dict()
.expect("form dictionary")
.try_get_key(b"/Resources")
.expect("resources");
let fonts = resources.try_get_key(b"/Font").expect("fonts");
assert!(!fonts.try_get_key(b"/F1").expect("used font").is_null());
assert!(fonts
.try_get_key(b"/Unused")
.expect("unused font")
.is_null());
}
#[test]
fn canonical_form_pruning_skips_a_scope_with_parser_warnings() {
let mut pdf = fixture();
let form = form_with_resources(&pdf, b"<0g>");
remove_unreferenced_resources_on_form(&mut pdf, form.clone())
.expect("recoverable Form warnings should skip pruning");
assert!(pdf
.repair_diagnostics()
.entries()
.iter()
.any(|diagnostic| diagnostic
.message
.contains("invalid character (g) in hexstring")));
let resources = form
.as_stream_dict()
.expect("form dictionary")
.try_get_key(b"/Resources")
.expect("resources");
let fonts = resources.try_get_key(b"/Font").expect("fonts");
assert!(!fonts
.try_get_key(b"/Unused")
.expect("unused font")
.is_null());
}
#[test]
fn collect_used_names_for_form_returns_none_for_malformed_content() {
assert!(super::collect_used_names_for_form(b"<0g>").is_none());
}
fn page_with_malformed_form_and_child(
outer_stream: &[u8],
outer_filter: Option<&[u8]>,
) -> (Pdf<std::io::Cursor<Vec<u8>>>, crate::ObjectRef) {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/direct-root-one-page.pdf");
let mut pdf = Pdf::open_mem_owned(std::fs::read(path).expect("fixture exists"))
.expect("fixture opens");
let page_ref = crate::pages::page_refs(&mut pdf).expect("page refs")[0];
let page_handle = pdf.get_object_handle(page_ref);
pdf.resolve(&page_handle).expect("page resolves");
let replacement = page_handle.shallow_copy().expect("page is copyable");
let child_form = pdf
.new_stream_with_data(Rc::new(b"/Ghost Do".to_vec()))
.expect("child form stream");
let child_dict = child_form.as_stream_dict().expect("child form dictionary");
child_dict
.replace_key(b"/Type", ObjectHandle::name(b"XObject".to_vec()))
.expect("child form type");
child_dict
.replace_key(b"/Subtype", ObjectHandle::name(b"Form".to_vec()))
.expect("child form subtype");
child_dict
.replace_key(b"/Resources", ObjectHandle::dictionary(vec![]))
.expect("child form resources");
let outer_form = pdf
.new_stream_with_data(Rc::new(outer_stream.to_vec()))
.expect("outer form stream");
let outer_dict = outer_form.as_stream_dict().expect("outer form dictionary");
outer_dict
.replace_key(b"/Type", ObjectHandle::name(b"XObject".to_vec()))
.expect("outer form type");
outer_dict
.replace_key(b"/Subtype", ObjectHandle::name(b"Form".to_vec()))
.expect("outer form subtype");
if let Some(filter) = outer_filter {
outer_dict
.replace_key(b"/Filter", ObjectHandle::name(filter.to_vec()))
.expect("outer form filter");
}
outer_dict
.replace_key(
b"/Resources",
ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(vec![(b"/FmChild".to_vec(), child_form)]),
)]),
)
.expect("outer form resources");
let resources = ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(vec![(b"/Fm0".to_vec(), outer_form)]),
)]);
replacement
.replace_key(b"/Resources", resources)
.expect("page resources");
pdf.replace_object(page_ref, replacement)
.expect("replace page");
(pdf, page_ref)
}
#[test]
fn form_walk_continues_into_declared_children_after_a_decode_failure() {
let (mut pdf, page_ref) =
page_with_malformed_form_and_child(b"not-flate", Some(b"FlateDecode"));
let (unresolved, failures) =
remove_unreferenced_resources_in_form_xobjects(&mut pdf, page_ref)
.expect("form resource prepass tolerates an undecodable Form");
assert!(failures, "the undecodable outer Form must set any_failures");
assert!(
unresolved.contains(b"Ghost".as_slice()),
"the child Form's own unresolved /Ghost use must surface, proving \
the walk descended past the undecodable parent: {unresolved:?}"
);
}
#[test]
fn form_walk_continues_into_declared_children_after_a_parse_failure() {
let (mut pdf, page_ref) = page_with_malformed_form_and_child(b"<0g>", None);
let (unresolved, failures) =
remove_unreferenced_resources_in_form_xobjects(&mut pdf, page_ref)
.expect("form resource prepass tolerates an unparseable Form");
assert!(failures, "the unparseable outer Form must set any_failures");
assert!(
unresolved.contains(b"Ghost".as_slice()),
"the child Form's own unresolved /Ghost use must surface, proving \
the walk descended past the unparseable parent: {unresolved:?}"
);
}
}