use crate::{Dictionary, Object, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
pub fn remove_attachment<R: Read + Seek>(pdf: &mut Pdf<R>, key: &[u8]) -> Result<bool> {
let entries = collect_embedded_file_pairs_raw(pdf, DEFAULT_MAX_EMBEDDED_FILES_DEPTH)?;
let target_value = match entries.iter().find(|(k, _)| k.as_slice() == key) {
Some((_, v)) => v.clone(),
None => return Ok(false),
};
let filespec_ref_opt: Option<ObjectRef> = match &target_value {
Object::Reference(r) => Some(*r),
_ => None,
};
delete_embedded_file(pdf, key)?;
if let Some(fs_ref) = filespec_ref_opt {
clear_af_reference(pdf, fs_ref)?;
}
crate::subset_prune::sweep_unreachable_objects(pdf)?;
Ok(true)
}
#[cfg(test)]
fn resolve_embedded_file_stream_ref<R: Read + Seek>(
pdf: &mut Pdf<R>,
filespec_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let fs_obj = pdf.resolve(filespec_ref)?;
let Some(fs_dict) = fs_obj.into_dict() else {
return Ok(None);
};
let ef_dict: Dictionary = match fs_dict.get("EF") {
Some(Object::Dictionary(d)) => d.clone(),
Some(Object::Reference(r)) => {
let r = *r;
match pdf.resolve(r)? {
Object::Dictionary(d) => d,
_ => return Ok(None),
}
}
_ => return Ok(None),
};
for key in &["UF", "F", "Unix", "Mac", "DOS"] {
if let Some(r) = ef_dict.get(key).and_then(Object::as_ref_id) {
return Ok(Some(r));
}
}
Ok(None)
}
fn clear_af_reference<R: Read + Seek>(pdf: &mut Pdf<R>, target_ref: ObjectRef) -> Result<()> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()),
};
remove_ref_from_af_in_dict(pdf, catalog_ref, target_ref)?;
let page_refs = match crate::pages::page_refs(pdf) {
Ok(v) => v,
Err(_) => return Ok(()), };
for page_ref in page_refs {
remove_ref_from_af_in_dict(pdf, page_ref, target_ref)?;
}
Ok(())
}
fn remove_ref_from_af_in_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
dict_ref: ObjectRef,
target_ref: ObjectRef,
) -> Result<()> {
let obj = pdf.resolve(dict_ref)?;
let Some(mut dict) = obj.into_dict() else {
return Ok(());
};
let af_value = match dict.get("AF").cloned() {
Some(v) => v,
None => return Ok(()), };
let (array_ref, af_array): (Option<ObjectRef>, Vec<Object>) = match af_value {
Object::Array(arr) => (None, arr),
Object::Reference(r) => match pdf.resolve(r)? {
Object::Array(arr) => (Some(r), arr),
_ => return Ok(()),
},
_ => return Ok(()),
};
if !af_array
.iter()
.any(|o| matches!(o, Object::Reference(r) if *r == target_ref))
{
return Ok(());
}
let filtered: Vec<Object> = af_array
.into_iter()
.filter(|o| !matches!(o, Object::Reference(r) if *r == target_ref))
.collect();
match array_ref {
Some(r) => {
let is_empty = filtered.is_empty();
pdf.set_object(r, Object::Array(filtered));
if is_empty {
dict.remove("AF");
pdf.set_object(dict_ref, Object::Dictionary(dict));
}
}
None => {
if filtered.is_empty() {
dict.remove("AF");
} else {
dict.insert("AF", Object::Array(filtered));
}
pdf.set_object(dict_ref, Object::Dictionary(dict));
}
}
Ok(())
}
pub const LEAF_MAX: usize = 32;
pub const DEFAULT_MAX_EMBEDDED_FILES_DEPTH: usize = 100;
pub fn list_embedded_files<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Vec<(Vec<u8>, ObjectRef)>> {
list_embedded_files_with_max_depth(pdf, DEFAULT_MAX_EMBEDDED_FILES_DEPTH)
}
pub fn list_embedded_files_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Vec<(Vec<u8>, ObjectRef)>> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(vec![]),
};
let catalog_obj = pdf.resolve(catalog_ref)?;
let Some(catalog) = catalog_obj.into_dict() else {
return Ok(vec![]);
};
let names_dict = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve(r)? {
Object::Dictionary(d) => d,
_ => return Ok(vec![]),
},
Some(Object::Dictionary(d)) => d,
_ => return Ok(vec![]),
};
let ef_root = match names_dict.get("EmbeddedFiles").cloned() {
Some(Object::Reference(r)) => {
let mut visited = BTreeSet::new();
let mut out = Vec::new();
collect_name_tree(pdf, r, &mut out, &mut visited, 0, max_depth)?;
return Ok(out);
}
Some(Object::Dictionary(d)) => d,
_ => return Ok(vec![]),
};
let mut out = Vec::new();
let mut visited = BTreeSet::new();
collect_name_tree_dict(pdf, ef_root, &mut out, &mut visited, 0, max_depth)?;
Ok(out)
}
fn collect_name_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
out: &mut Vec<(Vec<u8>, ObjectRef)>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if depth >= max_depth {
return Err(crate::Error::Unsupported(format!(
"embedded_files: name-tree depth limit {max_depth} exceeded at {node_ref}"
)));
}
if !visited.insert(node_ref) {
return Ok(());
}
let node_obj = pdf.resolve(node_ref)?;
let Some(node) = node_obj.into_dict() else {
return Ok(());
};
collect_name_tree_dict(pdf, node, out, visited, depth, max_depth)
}
fn collect_name_tree_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: crate::Dictionary,
out: &mut Vec<(Vec<u8>, ObjectRef)>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if let Some(pairs) = node.get("Names").and_then(Object::as_array) {
collect_leaf_pairs(pairs.to_vec(), out);
return Ok(());
}
if let Some(kids) = node.get("Kids").and_then(Object::as_array) {
for child_ref in kids.iter().filter_map(Object::as_ref_id) {
collect_name_tree(pdf, child_ref, out, visited, depth + 1, max_depth)?;
}
}
Ok(())
}
fn collect_leaf_pairs(pairs: Vec<Object>, out: &mut Vec<(Vec<u8>, ObjectRef)>) {
let mut iter = pairs.into_iter();
while let Some(key_obj) = iter.next() {
let val_obj = match iter.next() {
Some(o) => o,
None => break, };
let key = match key_obj {
Object::String(bytes) => bytes,
_ => continue, };
let filespec_ref = match val_obj {
Object::Reference(r) => r,
_ => continue, };
out.push((key, filespec_ref));
}
}
pub(crate) fn collect_embedded_file_pairs_raw<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Vec<(Vec<u8>, Object)>> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(vec![]),
};
let Object::Dictionary(catalog) = pdf.resolve(catalog_ref)? else {
return Ok(vec![]);
};
let names_dict = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve(r)? {
Object::Dictionary(d) => d,
_ => return Ok(vec![]),
},
Some(Object::Dictionary(d)) => d,
_ => return Ok(vec![]),
};
let mut out = Vec::new();
let mut visited = BTreeSet::new();
match names_dict.get("EmbeddedFiles").cloned() {
Some(Object::Reference(r)) => {
collect_name_tree_raw(pdf, r, &mut out, &mut visited, 0, max_depth)?;
}
Some(Object::Dictionary(d)) => {
collect_name_tree_dict_raw(pdf, d, &mut out, &mut visited, 0, max_depth)?;
}
_ => return Ok(vec![]),
}
Ok(out)
}
fn collect_name_tree_raw<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
out: &mut Vec<(Vec<u8>, Object)>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if depth >= max_depth {
return Err(crate::Error::Unsupported(format!(
"embedded_files: name-tree depth limit {max_depth} exceeded at {node_ref}"
)));
}
if !visited.insert(node_ref) {
return Ok(()); }
let Object::Dictionary(node) = pdf.resolve(node_ref)? else {
return Ok(()); };
collect_name_tree_dict_raw(pdf, node, out, visited, depth, max_depth)
}
fn collect_name_tree_dict_raw<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: crate::Dictionary,
out: &mut Vec<(Vec<u8>, Object)>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if let Some(pairs) = node.get("Names").and_then(Object::as_array) {
collect_leaf_pairs_raw(pairs.to_vec(), out);
return Ok(());
}
if let Some(kids) = node.get("Kids").and_then(Object::as_array) {
for child_ref in kids.iter().filter_map(Object::as_ref_id) {
collect_name_tree_raw(pdf, child_ref, out, visited, depth + 1, max_depth)?;
}
}
Ok(())
}
fn collect_leaf_pairs_raw(pairs: Vec<Object>, out: &mut Vec<(Vec<u8>, Object)>) {
let mut iter = pairs.into_iter();
while let Some(key_obj) = iter.next() {
let val_obj = match iter.next() {
Some(o) => o,
None => break, };
let key = match key_obj {
Object::String(bytes) => bytes,
_ => continue, };
out.push((key, val_obj));
}
}
pub fn insert_embedded_file<R: Read + Seek>(
pdf: &mut Pdf<R>,
key: &[u8],
filespec_ref: ObjectRef,
) -> Result<()> {
let mut entries = collect_embedded_file_pairs_raw(pdf, DEFAULT_MAX_EMBEDDED_FILES_DEPTH)?;
if let Some(existing) = entries.iter_mut().find(|(k, _)| k == key) {
existing.1 = Object::Reference(filespec_ref);
} else {
entries.push((key.to_vec(), Object::Reference(filespec_ref)));
entries.sort_by(|(a, _), (b, _)| a.cmp(b));
}
rebuild_embedded_files_tree(pdf, entries)
}
pub fn delete_embedded_file<R: Read + Seek>(pdf: &mut Pdf<R>, key: &[u8]) -> Result<bool> {
let mut entries = collect_embedded_file_pairs_raw(pdf, DEFAULT_MAX_EMBEDDED_FILES_DEPTH)?;
let before = entries.len();
entries.retain(|(k, _)| k != key);
if entries.len() == before {
return Ok(false); }
rebuild_embedded_files_tree(pdf, entries)?;
Ok(true)
}
fn rebuild_embedded_files_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
entries: Vec<(Vec<u8>, Object)>,
) -> Result<()> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()),
};
let catalog_obj = pdf.resolve(catalog_ref)?;
let Some(mut catalog) = catalog_obj.into_dict() else {
return Ok(());
};
let mut next_num: u32 = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let mut alloc = move || -> ObjectRef {
next_num += 1;
ObjectRef::new(next_num, 0)
};
if entries.is_empty() {
let names_dict_opt = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve(r)? {
Object::Dictionary(d) => Some((Some(r), d)),
_ => None,
},
Some(Object::Dictionary(d)) => Some((None, d)),
_ => None,
};
if let Some((names_ref_opt, mut names_dict)) = names_dict_opt {
names_dict.remove("EmbeddedFiles");
if names_dict.iter().next().is_none() {
catalog.remove("Names");
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
if let Some(r) = names_ref_opt {
pdf.delete_object(r);
}
} else {
match names_ref_opt {
Some(r) => {
pdf.set_object(r, Object::Dictionary(names_dict));
}
None => {
catalog.insert("Names", Object::Dictionary(names_dict));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
}
}
}
}
return Ok(());
}
let tree_root_ref = if entries.len() <= LEAF_MAX {
let leaf = build_leaf_dict(&entries);
let leaf_ref = alloc();
pdf.set_object(leaf_ref, Object::Dictionary(leaf));
leaf_ref
} else {
let n_leaves = entries.len().div_ceil(LEAF_MAX);
let chunk_size = entries.len().div_ceil(n_leaves);
let mut kids: Vec<Object> = Vec::with_capacity(n_leaves);
for chunk in entries.chunks(chunk_size) {
let leaf = build_leaf_dict(chunk);
let leaf_ref = alloc();
pdf.set_object(leaf_ref, Object::Dictionary(leaf));
kids.push(Object::Reference(leaf_ref));
}
let first = entries.first().map(|(k, _)| k.clone()).unwrap_or_default();
let last = entries.last().map(|(k, _)| k.clone()).unwrap_or_default();
let mut root = Dictionary::new();
root.insert(
"Limits",
Object::Array(vec![Object::String(first), Object::String(last)]),
);
root.insert("Kids", Object::Array(kids));
let root_ref = alloc();
pdf.set_object(root_ref, Object::Dictionary(root));
root_ref
};
let (names_ref, mut names_dict) = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match pdf.resolve(r)? {
Object::Dictionary(d) => (r, d),
_ => {
let r2 = alloc();
(r2, Dictionary::new())
}
},
Some(Object::Dictionary(d)) => {
let r = alloc();
(r, d)
}
_ => {
let r = alloc();
(r, Dictionary::new())
}
};
names_dict.insert("EmbeddedFiles", Object::Reference(tree_root_ref));
pdf.set_object(names_ref, Object::Dictionary(names_dict));
catalog.insert("Names", Object::Reference(names_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
Ok(())
}
fn build_leaf_dict(entries: &[(Vec<u8>, Object)]) -> Dictionary {
debug_assert!(
!entries.is_empty(),
"build_leaf_dict called with empty slice"
);
let first = entries.first().map(|(k, _)| k.clone()).unwrap_or_default();
let last = entries.last().map(|(k, _)| k.clone()).unwrap_or_default();
let mut pairs: Vec<Object> = Vec::with_capacity(entries.len() * 2);
for (key, val) in entries {
pairs.push(Object::String(key.clone()));
pairs.push(val.clone());
}
let mut dict = Dictionary::new();
dict.insert(
"Limits",
Object::Array(vec![Object::String(first), Object::String(last)]),
);
dict.insert("Names", Object::Array(pairs));
dict
}
#[cfg(test)]
mod tests {
use super::*;
use crate::filespec_helper::{add_attachment_from_path, FileSpecBuilder};
fn minimal_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{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_minimal() -> Pdf<std::io::Cursor<Vec<u8>>> {
Pdf::open(std::io::Cursor::new(minimal_pdf_bytes())).expect("open minimal PDF")
}
#[test]
fn remove_one_of_two_leaves_other_intact() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file_a = dir.path().join("a.txt");
let file_b = dir.path().join("b.txt");
std::fs::write(&file_a, b"content A").unwrap();
std::fs::write(&file_b, b"content B").unwrap();
add_attachment_from_path(&mut pdf, b"a.txt", &file_a).expect("add a");
let fs_b = add_attachment_from_path(&mut pdf, b"b.txt", &file_b).expect("add b");
let removed = remove_attachment(&mut pdf, b"a.txt").expect("remove a");
assert!(
removed,
"remove_attachment must return true for existing key"
);
let entries = list_embedded_files(&mut pdf).expect("list");
assert_eq!(entries.len(), 1, "exactly one attachment must remain");
assert_eq!(entries[0].0, b"b.txt", "b.txt must survive");
assert_eq!(entries[0].1, fs_b, "surviving filespec ref must match");
let keys: Vec<&[u8]> = entries.iter().map(|(k, _)| k.as_slice()).collect();
assert!(!keys.contains(&b"a.txt".as_ref()), "a.txt must be gone");
}
#[test]
fn remove_attachment_sweeps_transitively_unreachable_subgraph() {
let mut pdf = open_minimal();
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let sidecar_ref = ObjectRef::new(next + 1, 0);
pdf.set_object(
sidecar_ref,
Object::Stream(crate::object::Stream {
dict: Dictionary::new(),
data: b"sidecar".to_vec(),
}),
);
let fs_ref = FileSpecBuilder::new("trans.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
let Object::Dictionary(mut fs_dict) = pdf.resolve(fs_ref).expect("resolve filespec") else {
panic!("expected filespec dict");
};
fs_dict.insert("CI", Object::Reference(sidecar_ref));
pdf.set_object(fs_ref, Object::Dictionary(fs_dict));
insert_embedded_file(&mut pdf, b"trans.txt", fs_ref).expect("insert");
remove_attachment(&mut pdf, b"trans.txt").expect("remove");
let live = pdf.live_object_refs();
assert!(!live.contains(&fs_ref), "filespec must be swept");
assert!(
!live.contains(&sidecar_ref),
"object reachable only via the filespec must be transitively swept (mark-and-sweep)"
);
}
#[test]
fn remove_attachment_gc_deletes_filespec_and_stream() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file = dir.path().join("gc.txt");
std::fs::write(&file, b"gc test").unwrap();
let fs_ref = add_attachment_from_path(&mut pdf, b"gc.txt", &file).expect("add");
let stream_ref = resolve_embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve_stream_ref")
.expect("stream ref must exist");
remove_attachment(&mut pdf, b"gc.txt").expect("remove");
let live = pdf.live_object_refs();
assert!(
!live.contains(&fs_ref),
"filespec ref must not be in live_object_refs after GC"
);
assert!(
!live.contains(&stream_ref),
"stream ref must not be in live_object_refs after GC"
);
}
#[test]
fn remove_attachment_with_indirect_af_array_gcs_filespec_and_stream() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("idx.txt", b"indirect-af payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"idx.txt", fs_ref).expect("insert");
let stream_ref = resolve_embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let af_array_ref = ObjectRef::new(next + 1, 0);
pdf.set_object(af_array_ref, Object::Array(vec![Object::Reference(fs_ref)]));
let catalog_ref = pdf.root_ref().expect("root");
let Object::Dictionary(mut catalog) = pdf.resolve(catalog_ref).expect("resolve catalog")
else {
panic!("expected catalog dict");
};
catalog.insert("AF", Object::Reference(af_array_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let removed = remove_attachment(&mut pdf, b"idx.txt").expect("remove");
assert!(removed);
let live = pdf.live_object_refs();
assert!(
!live.contains(&fs_ref),
"filespec must be GC-deleted even when only an indirect /AF array referenced it"
);
assert!(
!live.contains(&stream_ref),
"embedded stream must be GC-deleted alongside the filespec"
);
assert!(
!live.contains(&af_array_ref),
"indirect /AF array reachable only via the cleared catalog /AF must be swept"
);
let Object::Dictionary(catalog2) = pdf.resolve(catalog_ref).expect("resolve catalog after")
else {
panic!("expected catalog dict");
};
assert!(
catalog2.get("AF").is_none(),
"catalog /AF must be removed once empty"
);
}
#[test]
fn remove_attachment_shared_indirect_af_across_catalog_and_page_not_dangled() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("sh.txt", b"shared-af payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"sh.txt", fs_ref).expect("insert");
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let af_array_ref = ObjectRef::new(next + 1, 0);
pdf.set_object(af_array_ref, Object::Array(vec![Object::Reference(fs_ref)]));
let catalog_ref = pdf.root_ref().expect("root");
let Object::Dictionary(mut catalog) = pdf.resolve(catalog_ref).expect("resolve catalog")
else {
panic!("expected catalog dict");
};
catalog.insert("AF", Object::Reference(af_array_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let page_refs = crate::pages::page_refs(&mut pdf).expect("page_refs");
assert_eq!(page_refs.len(), 1, "fixture has one page");
let page_ref = page_refs[0];
let Object::Dictionary(mut page_dict) = pdf.resolve(page_ref).expect("resolve page") else {
panic!("expected page dict");
};
page_dict.insert("AF", Object::Reference(af_array_ref));
pdf.set_object(page_ref, Object::Dictionary(page_dict));
let removed = remove_attachment(&mut pdf, b"sh.txt").expect("remove");
assert!(removed);
let Object::Array(af_after) = pdf
.resolve(af_array_ref)
.expect("shared indirect /AF array must still resolve (not deleted)")
else {
panic!("expected /AF array object");
};
assert!(
af_after.is_empty(),
"shared /AF array must be emptied of the removed filespec"
);
let live = pdf.live_object_refs();
assert!(
!live.contains(&fs_ref),
"filespec must be GC-deleted once the shared /AF array no longer references it"
);
let Object::Dictionary(page_after) = pdf.resolve(page_ref).expect("resolve page after")
else {
panic!("expected page dict");
};
if let Some(r) = page_after.get("AF").and_then(Object::as_ref_id) {
assert_eq!(
r, af_array_ref,
"page /AF must still point at the surviving shared array"
);
assert!(
pdf.resolve(r).is_ok(),
"page /AF reference must resolve (not dangling)"
);
}
}
#[test]
fn remove_attachment_preserves_filespec_referenced_by_other_name_tree() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("shared.txt", b"shared payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"shared.txt", fs_ref).expect("insert");
let stream_ref = resolve_embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let dests_leaf_ref = ObjectRef::new(next + 1, 0);
let mut dests_leaf = Dictionary::new();
dests_leaf.insert(
"Names",
Object::Array(vec![
Object::String(b"shared-dest".to_vec()),
Object::Reference(fs_ref),
]),
);
pdf.set_object(dests_leaf_ref, Object::Dictionary(dests_leaf));
let catalog_ref = pdf.root_ref().expect("root");
let Object::Dictionary(mut catalog) = pdf.resolve(catalog_ref).expect("resolve catalog")
else {
panic!("expected catalog dict");
};
catalog.insert("Dests", Object::Reference(dests_leaf_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let removed = remove_attachment(&mut pdf, b"shared.txt").expect("remove");
assert!(removed, "existing key must report removed");
let live = pdf.live_object_refs();
assert!(
live.contains(&fs_ref),
"filespec referenced by another live name tree (/Dests) must NOT be GC-deleted"
);
let Object::Dictionary(leaf) = pdf.resolve(dests_leaf_ref).expect("resolve dests leaf")
else {
panic!("expected dests leaf dict");
};
assert!(
matches!(leaf.get("Names"), Some(Object::Array(a)) if a.iter().any(|o| matches!(o, Object::Reference(r) if *r == fs_ref))),
"/Dests leaf must still reference the filespec"
);
assert!(
live.contains(&stream_ref),
"embedded stream of a preserved filespec must NOT be GC-deleted"
);
}
#[test]
fn remove_attachment_keeps_pair_when_stream_externally_referenced_and_back_refs() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("paired.txt", b"paired payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"paired.txt", fs_ref).expect("insert");
let stream_ref = resolve_embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let Object::Stream(mut stream) = pdf.resolve(stream_ref).expect("resolve stream") else {
panic!("expected stream object");
};
stream.dict.insert("RelatedFS", Object::Reference(fs_ref));
pdf.set_object(stream_ref, Object::Stream(stream));
let catalog_ref = pdf.root_ref().expect("root");
let Object::Dictionary(mut catalog) = pdf.resolve(catalog_ref).expect("resolve catalog")
else {
panic!("expected catalog dict");
};
catalog.insert("ExtraStreamRef", Object::Reference(stream_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let removed = remove_attachment(&mut pdf, b"paired.txt").expect("remove");
assert!(removed);
let live = pdf.live_object_refs();
assert!(
live.contains(&stream_ref),
"externally-referenced stream must be preserved"
);
assert!(
live.contains(&fs_ref),
"filespec must be preserved because the live stream back-references it"
);
}
#[test]
fn remove_attachment_with_shared_stream_keeps_stream_and_other_filespec() {
let mut pdf = open_minimal();
let fs_a = FileSpecBuilder::new("a.txt", b"shared body")
.build(&mut pdf)
.expect("build a");
insert_embedded_file(&mut pdf, b"a.txt", fs_a).expect("insert a");
let shared_stream = resolve_embedded_file_stream_ref(&mut pdf, fs_a)
.expect("resolve stream a")
.expect("stream a exists");
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let fs_b = ObjectRef::new(next + 1, 0);
let mut ef = Dictionary::new();
ef.insert("F", Object::Reference(shared_stream));
ef.insert("UF", Object::Reference(shared_stream));
let mut fs_b_dict = Dictionary::new();
fs_b_dict.insert("Type", Object::Name(b"Filespec".to_vec()));
fs_b_dict.insert("F", Object::String(b"b.txt".to_vec()));
fs_b_dict.insert("UF", Object::String(b"b.txt".to_vec()));
fs_b_dict.insert("EF", Object::Dictionary(ef));
pdf.set_object(fs_b, Object::Dictionary(fs_b_dict));
insert_embedded_file(&mut pdf, b"b.txt", fs_b).expect("insert b");
let removed = remove_attachment(&mut pdf, b"a.txt").expect("remove a");
assert!(removed);
let live = pdf.live_object_refs();
assert!(
!live.contains(&fs_a),
"removed attachment's filespec must be GC-deleted"
);
assert!(
live.contains(&shared_stream),
"stream shared with another filespec must be preserved"
);
assert!(
live.contains(&fs_b),
"the other filespec sharing the stream must remain intact"
);
}
#[test]
fn remove_attachment_gcs_all_distinct_ef_streams() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("multi.txt", b"primary stream")
.build(&mut pdf)
.expect("build filespec");
let Object::Dictionary(fs_dict) = pdf.resolve(fs_ref).expect("resolve fs") else {
panic!("expected filespec dict");
};
let Some(Object::Dictionary(mut ef)) = fs_dict.get("EF").cloned() else {
panic!("expected inline /EF dict");
};
let stream_f = match ef.get("F") {
Some(Object::Reference(r)) => *r,
_ => panic!("expected /EF /F indirect stream"),
};
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let stream_uf = ObjectRef::new(next + 1, 0);
let mut s2 = Dictionary::new();
s2.insert("Type", Object::Name(b"EmbeddedFile".to_vec()));
pdf.set_object(
stream_uf,
Object::Stream(crate::object::Stream {
dict: s2,
data: b"sibling stream".to_vec(),
}),
);
ef.insert("UF", Object::Reference(stream_uf));
let Object::Dictionary(mut fs_dict_mut) = pdf.resolve(fs_ref).expect("resolve fs") else {
panic!("expected filespec dict");
};
fs_dict_mut.insert("EF", Object::Dictionary(ef));
pdf.set_object(fs_ref, Object::Dictionary(fs_dict_mut));
insert_embedded_file(&mut pdf, b"multi.txt", fs_ref).expect("insert");
let removed = remove_attachment(&mut pdf, b"multi.txt").expect("remove");
assert!(removed);
let live = pdf.live_object_refs();
assert!(!live.contains(&fs_ref), "filespec must be GC-deleted");
assert!(
!live.contains(&stream_f),
"primary /EF /F stream must be GC-deleted"
);
assert!(
!live.contains(&stream_uf),
"distinct /EF /UF sibling stream must also be GC-deleted (not orphaned)"
);
}
#[test]
fn remove_attachment_leaves_empty_indirect_af_array_intact() {
let mut pdf = open_minimal();
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let af_array_ref = ObjectRef::new(next + 1, 0);
pdf.set_object(af_array_ref, Object::Array(vec![]));
let sharer_ref = ObjectRef::new(next + 2, 0);
let mut sharer = Dictionary::new();
sharer.insert("AF", Object::Reference(af_array_ref));
pdf.set_object(sharer_ref, Object::Dictionary(sharer));
let catalog_ref = pdf.root_ref().expect("root");
let Object::Dictionary(mut catalog) = pdf.resolve(catalog_ref).expect("resolve catalog")
else {
panic!("expected catalog dict");
};
catalog.insert("AF", Object::Reference(af_array_ref));
catalog.insert("Sharer", Object::Reference(sharer_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let fs_ref = FileSpecBuilder::new("x.txt", b"x")
.build(&mut pdf)
.expect("build");
insert_embedded_file(&mut pdf, b"x.txt", fs_ref).expect("insert");
let removed = remove_attachment(&mut pdf, b"x.txt").expect("remove");
assert!(removed);
let live = pdf.live_object_refs();
assert!(
live.contains(&af_array_ref),
"empty indirect /AF array (target absent) must NOT be deleted"
);
let Object::Dictionary(catalog2) = pdf.resolve(catalog_ref).expect("resolve catalog after")
else {
panic!("expected catalog dict");
};
assert!(
matches!(catalog2.get("AF"), Some(Object::Reference(r)) if *r == af_array_ref),
"catalog /AF must still point at the untouched indirect array"
);
}
#[test]
fn remove_nonexistent_key_returns_false() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file = dir.path().join("keep.txt");
std::fs::write(&file, b"keep me").unwrap();
add_attachment_from_path(&mut pdf, b"keep.txt", &file).expect("add");
let result = remove_attachment(&mut pdf, b"no-such-key.txt").expect("no error");
assert!(!result, "must return false for absent key");
let entries = list_embedded_files(&mut pdf).expect("list");
assert_eq!(entries.len(), 1, "document must be unchanged");
assert_eq!(entries[0].0, b"keep.txt");
}
#[test]
fn remove_attachment_clears_af_on_catalog_and_page() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("af-test.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"af-test.txt", fs_ref).expect("insert");
let catalog_ref = pdf.root_ref().expect("root");
let catalog_obj = pdf.resolve(catalog_ref).expect("resolve catalog");
let Some(mut catalog) = catalog_obj.into_dict() else {
panic!("expected catalog dict");
};
catalog.insert("AF", Object::Array(vec![Object::Reference(fs_ref)]));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
let page_refs = crate::pages::page_refs(&mut pdf).expect("page_refs");
assert_eq!(page_refs.len(), 1, "fixture has one page");
let page_ref = page_refs[0];
let page_obj = pdf.resolve(page_ref).expect("resolve page");
let Some(mut page_dict) = page_obj.into_dict() else {
panic!("expected page dict");
};
page_dict.insert("AF", Object::Array(vec![Object::Reference(fs_ref)]));
pdf.set_object(page_ref, Object::Dictionary(page_dict));
let removed = remove_attachment(&mut pdf, b"af-test.txt").expect("remove");
assert!(removed);
let catalog_obj2 = pdf.resolve(catalog_ref).expect("resolve catalog after");
let Some(catalog2) = catalog_obj2.into_dict() else {
panic!("expected catalog dict");
};
assert!(
catalog2.get("AF").is_none(),
"catalog /AF must be removed after attachment removal"
);
let page_obj2 = pdf.resolve(page_ref).expect("resolve page after");
let Some(page_dict2) = page_obj2.into_dict() else {
panic!("expected page dict");
};
assert!(
page_dict2.get("AF").is_none(),
"page /AF must be removed after attachment removal"
);
}
#[test]
fn conservative_gc_preserves_shared_stream() {
let mut pdf = open_minimal();
let next = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let stream_ref = ObjectRef::new(next + 1, 0);
let fs_ref1 = ObjectRef::new(next + 2, 0);
let fs_ref2 = ObjectRef::new(next + 3, 0);
let mut ef_dict = Dictionary::new();
ef_dict.insert("Type", Object::Name(b"EmbeddedFile".to_vec()));
ef_dict.insert("Length", Object::Integer(7));
let ef_stream = crate::object::Stream::new(ef_dict, b"payload".to_vec());
pdf.set_object(stream_ref, Object::Stream(ef_stream));
let mut ef_sub = Dictionary::new();
ef_sub.insert("F", Object::Reference(stream_ref));
ef_sub.insert("UF", Object::Reference(stream_ref));
let mut fs1 = Dictionary::new();
fs1.insert("Type", Object::Name(b"Filespec".to_vec()));
fs1.insert("F", Object::String(b"shared1.txt".to_vec()));
fs1.insert("EF", Object::Dictionary(ef_sub.clone()));
pdf.set_object(fs_ref1, Object::Dictionary(fs1));
let mut fs2 = Dictionary::new();
fs2.insert("Type", Object::Name(b"Filespec".to_vec()));
fs2.insert("F", Object::String(b"shared2.txt".to_vec()));
fs2.insert("EF", Object::Dictionary(ef_sub));
pdf.set_object(fs_ref2, Object::Dictionary(fs2));
insert_embedded_file(&mut pdf, b"shared1.txt", fs_ref1).expect("insert 1");
insert_embedded_file(&mut pdf, b"shared2.txt", fs_ref2).expect("insert 2");
let removed = remove_attachment(&mut pdf, b"shared1.txt").expect("remove");
assert!(removed);
let live = pdf.live_object_refs();
assert!(
live.contains(&stream_ref),
"shared stream must NOT be GC'd while fs_ref2 still references it"
);
assert!(
!live.contains(&fs_ref1),
"removed filespec ref must be GC'd"
);
assert!(
live.contains(&fs_ref2),
"surviving filespec ref must remain alive"
);
}
}