use std::cell::{Cell, RefCell};
use std::collections::{BTreeMap, BTreeSet, VecDeque};
use std::io::{Read, Seek};
use std::rc::Rc;
use crate::object_handle::LiveDictionaryKeyBuffer;
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::writer::object_streams;
use crate::writer::output::{write_decimal_u64, write_object_ref, OutputSink};
#[cfg(test)]
use crate::writer::plain::plan::{
PlainWritePlan, PlannedIndirectObject, PlannedObjectStreamOrigin,
};
use crate::writer::plain::xref::{BodyLayout, CompressedLocation};
use crate::writer::write_object::{IndirectStreamLength, QdfObjectInfo, WriteObject};
use crate::writer::WriterOptions;
use crate::writer::{
serialize, CompressStreams, ObjectWriterEmission, StreamDictionaryOptions, PCLM_HEADER_MARKER,
QPDF_BINARY_MARKER,
};
#[cfg(test)]
use crate::PageDocumentHelper;
use crate::{ObjectHandle, ObjectRef, Pdf};
struct LiveQueue {
next_objid: u32,
old_to_new: BTreeMap<ObjectRef, ObjectRef>,
raw_old_to_new: BTreeMap<QpdfObjGen, ObjectRef>,
pending: VecDeque<ObjectHandle>,
removed_refs: BTreeSet<ObjectRef>,
member_to_container: BTreeMap<ObjectRef, ObjectRef>,
container_to_members: BTreeMap<ObjectRef, Vec<ObjectRef>>,
resolving_members: BTreeSet<ObjectRef>,
stream_length_holders: BTreeMap<ObjectRef, ObjectRef>,
generated_container_sources: BTreeSet<ObjectRef>,
qdf_ignored_refs: BTreeSet<QpdfObjGen>,
qdf: bool,
}
impl LiveQueue {
fn reserve_output_number(&mut self) -> crate::Result<ObjectRef> {
let number = self.next_objid;
self.next_objid = self.next_objid.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported("plain live writer object number overflows u32".into())
})?;
Ok(ObjectRef::new(number, 0))
}
fn new(removed_refs: BTreeSet<ObjectRef>, qdf: bool) -> Self {
Self {
next_objid: 1,
old_to_new: BTreeMap::new(),
raw_old_to_new: BTreeMap::new(),
pending: VecDeque::new(),
removed_refs,
member_to_container: BTreeMap::new(),
container_to_members: BTreeMap::new(),
resolving_members: BTreeSet::new(),
stream_length_holders: BTreeMap::new(),
generated_container_sources: BTreeSet::new(),
qdf_ignored_refs: BTreeSet::new(),
qdf,
}
}
fn register_object_streams<R: Read + Seek>(
&mut self,
pdf: &Pdf<R>,
groups: &[crate::writer::object_streams::ObjectStreamGroup],
) -> crate::Result<()> {
for group in groups {
let (source, members, generated) = match group {
crate::writer::object_streams::ObjectStreamGroup::SourceBacked {
source,
members,
} => (*source, members, false),
crate::writer::object_streams::ObjectStreamGroup::Generated { source, members } => {
(*source, members, true)
}
};
if generated {
self.generated_container_sources.insert(source);
}
let mut retained: Vec<ObjectRef> = members
.iter()
.copied()
.filter(|member| !self.removed_refs.contains(member))
.collect();
if pdf.writer_object_order.is_some() {
retained.sort_unstable_by_key(|member| pdf.writer_object_order_key(*member));
} else {
retained.sort_unstable_by_key(|member| (member.number, member.generation));
}
if retained.is_empty() {
continue;
}
for member in &retained {
self.member_to_container.insert(*member, source);
}
self.container_to_members.insert(source, retained);
}
Ok(())
}
fn enqueue_handle<R: Read + Seek>(
&mut self,
pdf: &mut Pdf<R>,
handle: ObjectHandle,
) -> crate::Result<Option<ObjectRef>> {
if handle.owning_pdf_unique_id() != Some(pdf.unique_id()) {
return Err(crate::Error::Internal(
"QPDFObjectHandle from different QPDF found while writing. Use QPDF::copyForeignObject to add objects from another file."
.to_string(),
));
}
if self.qdf && handle.try_is_stream_of_type(b"XRef", b"")? {
if let Some(source) = handle
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
self.qdf_ignored_refs.insert(source);
}
return Ok(None);
}
let Some(source) = handle.object_ref() else {
let Some(raw_source) = handle
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
else {
return Ok(None);
};
if let Some(output) = self.raw_old_to_new.get(&raw_source).copied() {
return Ok(Some(output));
}
let output = self.reserve_output_number()?;
self.raw_old_to_new.insert(raw_source, output);
self.pending.push_back(handle);
if self.qdf
&& self
.pending
.back()
.is_some_and(|handle| handle.as_stream_dict().is_some())
{
let holder = self.reserve_output_number()?;
self.stream_length_holders
.insert(ObjectRef::new(output.number, 0), holder);
}
return Ok(Some(output));
};
if source.number == 0 {
return Ok(None);
}
if self.removed_refs.contains(&source) && !self.container_to_members.contains_key(&source) {
return Ok(None);
}
if let Some(output) = self.old_to_new.get(&source).copied() {
return Ok(Some(output));
}
if let Some(&container) = self.member_to_container.get(&source) {
if !self.resolving_members.insert(source) {
return Ok(Some(ObjectRef::new(0, 0)));
}
let container_handle = pdf.get_object_handle(container);
self.enqueue_handle(pdf, container_handle)?;
return Ok(self.old_to_new.get(&source).copied());
}
let output = self.reserve_output_number()?;
self.old_to_new.insert(source, output);
self.pending.push_back(handle);
if let Some(members) = self.container_to_members.get(&source).cloned() {
for member in members {
if !self.old_to_new.contains_key(&member) {
let member_output = self.reserve_output_number()?;
self.old_to_new.insert(member, member_output);
} }
} else if self.qdf
&& self
.pending
.back()
.is_some_and(|handle| handle.as_stream_dict().is_some())
{
let holder = self.reserve_output_number()?;
self.stream_length_holders.insert(source, holder);
}
Ok(Some(output))
}
fn pop(&mut self) -> Option<ObjectHandle> {
self.pending.pop_front()
}
}
pub(crate) struct LiveBodyOutput {
pub(crate) layout: BodyLayout,
pub(crate) old_to_new: BTreeMap<ObjectRef, ObjectRef>,
pub(crate) ignored_refs: BTreeSet<QpdfObjGen>,
pub(crate) object_count: usize,
}
fn collect_live_dictionary_children(
handle: &ObjectHandle,
found: &mut Vec<ObjectHandle>,
depth: usize,
) -> crate::Result<()> {
let mut current_key = LiveDictionaryKeyBuffer::default();
let mut next_key = LiveDictionaryKeyBuffer::default();
let mut first_entry = true;
while let Some(value) = handle.next_dictionary_entry_for_live_walk(
(!first_entry).then_some(current_key.as_slice()),
&mut next_key,
) {
std::mem::swap(&mut current_key, &mut next_key);
if !value.try_is_null()? {
collect_live_seed_handles(&value, found, depth + 1)?;
}
first_entry = false;
}
Ok(())
}
fn collect_live_seed_handles(
handle: &ObjectHandle,
found: &mut Vec<ObjectHandle>,
depth: usize,
) -> crate::Result<()> {
if handle
.qpdf_obj_gen()
.is_some_and(|object_gen| object_gen.is_indirect())
{
found.push(handle.clone());
return Ok(());
}
if depth > crate::parser::MAX_PARSE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"plain live writer: direct seed nesting exceeds maximum of {}",
crate::parser::MAX_PARSE_DEPTH
)));
}
if handle.try_is_array()? {
let items = handle.try_array_items()?;
let mut cursor = items.begin();
while !cursor.is_end() {
let item = cursor.current();
collect_live_seed_handles(&item, found, depth + 1)?;
cursor.next();
}
} else if let Some(stream_dict) = handle.as_stream_dict() {
collect_live_dictionary_children(&stream_dict, found, depth)?;
} else if handle.try_is_dictionary()? {
collect_live_dictionary_children(handle, found, depth)?;
}
Ok(())
}
fn collect_live_child_handles(
handle: &ObjectHandle,
found: &mut Vec<ObjectHandle>,
depth: usize,
) -> crate::Result<()> {
if depth > crate::parser::MAX_PARSE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"plain live writer: emitted value nesting exceeds maximum of {}",
crate::parser::MAX_PARSE_DEPTH
)));
}
if handle.try_is_array()? {
let items = handle.try_array_items()?;
let mut cursor = items.begin();
while !cursor.is_end() {
let item = cursor.current();
collect_live_seed_handles(&item, found, depth + 1)?;
cursor.next();
}
} else if let Some(stream_dict) = handle.as_stream_dict() {
collect_live_dictionary_children(&stream_dict, found, depth)?; } else if handle.try_is_dictionary()? {
collect_live_dictionary_children(handle, found, depth)?;
}
Ok(())
}
fn enqueue_object<R: Read + Seek>(
queue: &mut LiveQueue,
pdf: &mut Pdf<R>,
value: &ObjectHandle,
) -> crate::Result<()> {
let mut handles = Vec::new();
collect_live_seed_handles(value, &mut handles, 0)?;
for handle in handles {
queue.enqueue_handle(pdf, handle)?;
}
Ok(())
}
fn enqueue_objects_standard<R: Read + Seek>(
queue: &mut LiveQueue,
pdf: &mut Pdf<R>,
options: &WriterOptions,
) -> crate::Result<()> {
if options.preserve_unreferenced_objects {
let mut all_objects = pdf.get_all_objects()?;
if pdf.writer_object_order.is_some() {
all_objects.sort_by_key(|handle| {
handle.object_ref().map_or_else(
|| pdf.writer_object_order_key(ObjectRef::new(u32::MAX, 0)),
|object_ref| pdf.writer_object_order_key(object_ref),
)
});
}
for handle in all_objects {
if handle
.object_ref()
.is_some_and(|source| queue.generated_container_sources.contains(&source))
{
continue;
}
queue.enqueue_handle(pdf, handle)?;
}
}
let root = pdf.root_handle()?;
enqueue_object(queue, pdf, &root)?;
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"/Size"
| b"/Encrypt"
| b"/Prev"
| b"/Root"
| b"/Type"
| b"/W"
| b"/Index"
| b"/Length"
| b"/Filter"
| b"/DecodeParms"
| b"/XRefStm"
) || value.try_is_null()?
{
continue;
}
enqueue_object(queue, pdf, &value)?;
}
Ok(())
}
fn enqueue_objects_pclm<R: Read + Seek>(
queue: &mut LiveQueue,
pdf: &mut Pdf<R>,
) -> crate::Result<()> {
let image_transform_content = Rc::new(b"q /image Do Q\n".to_vec());
for page in crate::pages::page_refs(pdf)? {
let page = pdf.get_object_handle(page);
page.try_dereference()?;
enqueue_object(queue, pdf, &page)?;
let contents = page.try_get_key(b"/Contents")?;
enqueue_object(queue, pdf, &contents)?;
let strips = page.try_get_key(b"/Resources")?.try_get_key(b"/XObject")?;
for key in strips.try_get_keys()? {
let strip = strips.try_get_key(&key)?;
enqueue_object(queue, pdf, &strip)?;
let transform = pdf.new_stream_with_data(Rc::clone(&image_transform_content))?;
enqueue_object(queue, pdf, &transform)?;
}
}
let root = pdf.root_handle()?;
enqueue_object(queue, pdf, &root)?;
Ok(())
}
fn initialize_live_queue<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
removed_refs: BTreeSet<ObjectRef>,
object_streams: &[crate::writer::object_streams::ObjectStreamGroup],
) -> crate::Result<LiveQueue> {
let mut queue = LiveQueue::new(removed_refs, options.qdf);
queue.register_object_streams(pdf, object_streams)?;
if options.pclm {
enqueue_objects_pclm(&mut queue, pdf)?;
} else {
enqueue_objects_standard(&mut queue, pdf, options)?;
}
Ok(queue)
}
#[allow(clippy::too_many_arguments)] fn emit_live_body<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
out: &mut OutputSink<'_>,
options: &WriterOptions,
version: &str,
final_extension_level: i64,
root_source: Option<ObjectRef>,
removed_refs: BTreeSet<ObjectRef>,
object_streams: &[crate::writer::object_streams::ObjectStreamGroup],
encryption_context: Option<&crate::writer::EncryptionContext>,
content_container_refs: &BTreeSet<QpdfObjGen>,
content_stream_state: crate::writer::LiveContentStreamState,
) -> crate::Result<LiveBodyOutput> {
out.write_bytes(format!("%PDF-{version}\n").as_bytes())?;
if options.pclm {
out.write_bytes(PCLM_HEADER_MARKER)?;
} else {
out.write_bytes(QPDF_BINARY_MARKER)?;
}
let queue = initialize_live_queue(pdf, options, removed_refs.clone(), object_streams)?;
let raw_removed_refs = removed_refs
.iter()
.copied()
.map(QpdfObjGen::try_from_object_ref)
.collect::<crate::Result<BTreeSet<_>>>()?;
if options.qdf {
out.write_bytes(b"%QDF-1.0\n\n")?;
}
out.write_bytes(options.extra_header_text.as_bytes())?;
let mut layout = BodyLayout::default();
let mut emitter = LiveObjectEmitter {
pdf,
options,
out,
layout: &mut layout,
queue: RefCell::new(queue),
root_source,
version,
final_extension_level,
removed_refs,
raw_removed_refs,
lengths: BTreeMap::new(),
encryption: crate::writer::encryption_state::WriterEncryptionState::new(
encryption_context.is_some(),
encryption_context
.map(|context| context.file_key.clone())
.unwrap_or_default(),
encryption_context
.is_some_and(|context| crate::writer::cipher_needs_aes_iv(context.cipher)),
encryption_context.map_or(0, |context| context.encryption_v),
encryption_context.map_or(0, |context| context.encryption_r),
),
encrypted_strings: encryption_context
.map(crate::writer::encrypted_strings::EncryptedStringEmitter::from_context),
encryption_context,
content_container_refs: content_container_refs.clone(),
current_raw_output: None,
content_stream_state,
current_stream_length: None,
two_pass_object_streams: !object_streams.is_empty(),
};
loop {
let source = emitter.queue.borrow_mut().pop();
let Some(handle) = source else { break };
emitter.current_raw_output = handle.qpdf_obj_gen().and_then(|object_gen| {
emitter
.queue
.borrow()
.raw_old_to_new
.get(&object_gen)
.copied()
});
emitter.write_object(&handle, None)?;
emitter.current_raw_output = None;
}
let queue = emitter.queue.into_inner();
let old_to_new = queue.old_to_new;
let ignored_refs = queue.qdf_ignored_refs;
let object_count = usize::try_from(queue.next_objid.saturating_sub(1)).map_err(|_| {
crate::Error::Unsupported("plain live writer object count exceeds usize".into())
})?;
Ok(LiveBodyOutput {
layout,
old_to_new,
ignored_refs,
object_count,
})
}
#[allow(clippy::too_many_arguments)] pub(crate) fn emit_live<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
out: &mut OutputSink<'_>,
options: &WriterOptions,
version: &str,
final_extension_level: i64,
root_source: Option<ObjectRef>,
removed_refs: BTreeSet<ObjectRef>,
object_streams: &[crate::writer::object_streams::ObjectStreamGroup],
encryption_context: Option<&crate::writer::EncryptionContext>,
content_container_refs: &BTreeSet<QpdfObjGen>,
content_stream_state: crate::writer::LiveContentStreamState,
) -> crate::Result<LiveBodyOutput> {
emit_live_body(
pdf,
out,
options,
version,
final_extension_level,
root_source,
removed_refs,
object_streams,
encryption_context,
content_container_refs,
content_stream_state,
)
}
#[cfg(test)]
fn qdf_page_context<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> crate::Result<crate::writer::LiveContentStreamState> {
let pages = PageDocumentHelper::new(pdf).get_all_page_handles()?;
let mut page_sequences = BTreeMap::new();
let mut contents_sequences = BTreeMap::new();
let mut normalized_streams = BTreeSet::new();
for (index, page) in pages.into_iter().enumerate() {
let sequence = index
.checked_add(1)
.ok_or_else(|| crate::Error::Unsupported("QDF page sequence overflows usize".into()))?;
let page_object_gen = page
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| {
crate::Error::Internal("qpdf page list contains a direct page".into())
})?;
page_sequences.insert(page_object_gen, sequence);
for object_gen in crate::writer::collect_content_stream_qpdf_obj_gens(&page)? {
contents_sequences.insert(object_gen, sequence);
normalized_streams.insert(object_gen);
}
}
Ok(crate::writer::LiveContentStreamState {
page_sequences,
contents_sequences,
normalized_streams,
})
}
#[cfg(test)]
fn map_queued_output(
queued_map: &BTreeMap<ObjectRef, ObjectRef>,
ignored_refs: &BTreeSet<ObjectRef>,
object: ObjectRef,
) -> crate::Result<ObjectRef> {
queued_map
.get(&object)
.copied()
.or_else(|| {
ignored_refs
.contains(&object)
.then_some(ObjectRef::new(0, 0))
})
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: reference {} {} R absent from queue",
object.number, object.generation
))
})
}
fn map_queued_raw_output(
raw_queued_map: &BTreeMap<QpdfObjGen, ObjectRef>,
queued_map: &BTreeMap<ObjectRef, ObjectRef>,
ignored_refs: &BTreeSet<QpdfObjGen>,
object_gen: QpdfObjGen,
) -> crate::Result<ObjectRef> {
raw_queued_map
.get(&object_gen)
.copied()
.or_else(|| {
object_gen
.to_object_ref()
.and_then(|object_ref| queued_map.get(&object_ref).copied())
})
.or_else(|| {
ignored_refs
.contains(&object_gen)
.then_some(ObjectRef::new(0, 0))
})
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: raw reference {} {} R absent from queue",
object_gen.get_obj(),
object_gen.get_gen()
))
})
}
fn live_queue_raw_output_map(
queue: &RefCell<LiveQueue>,
) -> impl Fn(QpdfObjGen) -> crate::Result<ObjectRef> + '_ {
move |object_gen| {
let queue = queue.borrow();
map_queued_raw_output(
&queue.raw_old_to_new,
&queue.old_to_new,
&queue.qdf_ignored_refs,
object_gen,
)
}
}
#[cfg(test)]
fn planned_object_stream_groups(
plan: &PlainWritePlan,
) -> crate::Result<Vec<crate::writer::object_streams::ObjectStreamGroup>> {
let mut groups = Vec::new();
for object in &plan.objects {
let PlannedIndirectObject::ObjectStream {
origin, members, ..
} = object
else {
continue;
};
let members = members.iter().map(|member| member.source).collect();
let group = match origin {
PlannedObjectStreamOrigin::SourceBacked(source) => {
crate::writer::object_streams::ObjectStreamGroup::SourceBacked {
source: *source,
members,
}
}
PlannedObjectStreamOrigin::Generated(source) => {
crate::writer::object_streams::ObjectStreamGroup::Generated {
source: *source,
members,
}
}
PlannedObjectStreamOrigin::Synthetic => {
return Err(crate::Error::Unsupported(
"plain live writer cannot dynamically emit a synthetic ObjStm".into(),
));
}
};
groups.push(group);
}
Ok(groups)
}
#[cfg(test)]
pub(crate) fn emit_bodies<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut OutputSink<'_>,
options: &WriterOptions,
plan: &PlainWritePlan,
) -> crate::Result<LiveBodyOutput> {
validate_objstm_member_bodies(pdf, plan)?;
let groups = planned_object_stream_groups(plan)?;
emit_live_body(
pdf,
out,
options,
&plan.version,
plan.final_extension_level,
plan.root_source,
plan.removed_refs.clone(),
&groups,
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState::default(),
)
}
struct LiveObjectEmitter<'pdf, 'output, 'sink, R: Read + Seek + 'static> {
pdf: &'pdf mut Pdf<R>,
options: &'pdf WriterOptions,
out: &'output mut OutputSink<'sink>,
layout: &'output mut BodyLayout,
queue: RefCell<LiveQueue>,
root_source: Option<ObjectRef>,
version: &'pdf str,
final_extension_level: i64,
removed_refs: BTreeSet<ObjectRef>,
raw_removed_refs: BTreeSet<QpdfObjGen>,
lengths: BTreeMap<u32, usize>,
encryption: crate::writer::encryption_state::WriterEncryptionState,
encrypted_strings: Option<crate::writer::encrypted_strings::EncryptedStringEmitter>,
encryption_context: Option<&'pdf crate::writer::EncryptionContext>,
content_container_refs: BTreeSet<QpdfObjGen>,
current_raw_output: Option<ObjectRef>,
content_stream_state: crate::writer::LiveContentStreamState,
current_stream_length: Option<IndirectStreamLength>,
two_pass_object_streams: bool,
}
struct LiveDirectStreamWriter<'a> {
options: &'a WriterOptions,
output: ObjectRef,
encryption_context: Option<&'a crate::writer::EncryptionContext>,
}
impl crate::writer::object::DynamicDirectStreamWriter for LiveDirectStreamWriter<'_> {
fn write_direct_stream(
&mut self,
stream: &ObjectHandle,
out: &mut OutputSink<'_>,
map: &mut crate::writer::object::DynamicObjectRefMap<'_>,
removed_refs: &BTreeSet<ObjectRef>,
write_string: &mut dyn FnMut(&mut OutputSink<'_>, &[u8]) -> crate::Result<()>,
) -> crate::Result<()> {
stream.try_dereference()?;
let (dict, data, dictionary_options) =
canonical_stream_output_for_rewrite(stream, self.options, false)?;
let is_metadata_stream = dict.try_is_dictionary_of_type(b"Metadata", b"")?;
let encrypt_stream = self
.encryption_context
.is_some_and(|context| context.encrypt_metadata || !is_metadata_stream);
let mut stream_length = data.len();
if let Some(context) = self.encryption_context {
crate::writer::adjust_aes_stream_length(&mut stream_length, context, encrypt_stream)?;
}
dict.replace_key(
b"/Length",
ObjectHandle::integer(i64::try_from(stream_length).map_err(|_| {
crate::Error::Unsupported("direct stream /Length does not fit in i64".into())
})?), )?; dict.unparse_stream_body_with_dynamic_ref_map_and_string_writer(
out,
dictionary_options,
map,
removed_refs,
write_string,
self,
)?; if let Some(context) = self.encryption_context {
crate::writer::write_stream_payload_with_pipeline(
out,
&data,
self.options.newline_before_endstream,
self.output,
context,
encrypt_stream,
None,
)?; } else {
serialize::write_stream_payload(out, &data, self.options.newline_before_endstream)?;
}
Ok(())
}
}
impl<'pdf, 'output, 'sink, R: Read + Seek + 'static> crate::writer::write_object::WriteObject
for LiveObjectEmitter<'pdf, 'output, 'sink, R>
{
type ObjectStreamContainer = Vec<ObjectRef>;
fn object_stream_container(&self, object: QpdfObjGen) -> Option<Vec<ObjectRef>> {
object.to_object_ref().and_then(|object_ref| {
self.queue
.borrow()
.container_to_members
.get(&object_ref)
.cloned()
})
}
fn write_object_stream(
&mut self,
object: &ObjectHandle,
container: Vec<ObjectRef>,
) -> crate::Result<()> {
self.emit_live_object_stream(object, &container)
}
fn indicate_progress(&mut self) -> crate::Result<()> {
crate::writer::report_progress_event(self.options)
}
fn qdf_object_info(&self, object: QpdfObjGen) -> Option<QdfObjectInfo> {
let source = object.to_object_ref();
let original_object_id = source
.map(|source| self.pdf.writer_original_object_ref(source))
.and_then(|source| QpdfObjGen::try_from_object_ref(source).ok())
.unwrap_or(object);
self.options.qdf.then(|| QdfObjectInfo {
page_sequence: self
.content_stream_state
.page_sequences
.get(&object)
.copied(),
contents_sequence: self
.content_stream_state
.contents_sequences
.get(&object)
.copied(),
suppress_original_object_ids: self.options.no_original_object_ids,
original_object_id: Some(original_object_id),
})
}
fn indirect_stream_length(&self) -> Option<IndirectStreamLength> {
self.current_stream_length
}
fn output_number(&self, object: QpdfObjGen) -> crate::Result<u32> {
if !object.is_indirect() {
if let Some(output) = self.current_raw_output {
return Ok(output.number);
}
}
let queue = self.queue.borrow();
queue
.raw_old_to_new
.get(&object)
.or_else(|| {
object
.to_object_ref()
.and_then(|object_ref| queue.old_to_new.get(&object_ref))
})
.map(|output| output.number)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: reference {} {} R absent from queue",
object.get_obj(),
object.get_gen()
))
})
}
fn write_bytes(&mut self, bytes: &[u8]) -> crate::Result<()> {
self.out.write_bytes(bytes)
}
fn output_count(&self) -> crate::Result<usize> {
usize::try_from(self.out.position()).map_err(|_| {
crate::Error::Unsupported(
"plain live writer output position exceeds usize range".to_string(),
)
})
}
fn record_object_offset(&mut self, object: u32, offset: usize) {
self.layout.uncompressed.insert(object, (0, offset));
}
fn object_offset(&self, object: u32) -> usize {
self.layout.uncompressed[&object].1
}
fn record_object_length(&mut self, object: u32, length: usize) {
self.lengths.insert(object, length);
}
fn encryption_state(&mut self) -> &mut crate::writer::encryption_state::WriterEncryptionState {
&mut self.encryption
}
fn unparse_object(
&mut self,
object: &ObjectHandle,
_in_object_stream: bool,
) -> crate::Result<()> {
self.current_stream_length = None;
object.try_dereference()?;
if object
.qpdf_obj_gen()
.filter(|source| source.is_indirect())
.is_some_and(|source| self.content_container_refs.contains(&source))
{
self.enqueue_surviving_children(object)?;
let raw_static_map = live_queue_raw_output_map(&self.queue);
let output =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?;
if let Some(emitter) = self.encrypted_strings.as_mut() {
emitter.write_handle_content_container_with_qpdf_obj_gen_map(
self.out,
ObjectRef::new(output, 0),
None,
object,
self.options,
&raw_static_map,
&self.raw_removed_refs,
)?; } else {
emit_content_container_from_handle_with_qpdf_obj_gen_map(
object,
self.options,
self.out,
&raw_static_map,
&self.raw_removed_refs,
)?; }
return Ok(());
}
if self.root_source == object.object_ref() {
if self.encrypted_strings.is_some() || self.options.qdf {
let root = object.output_root_copy_with_adbe(
self.version,
self.final_extension_level,
true,
)?; self.enqueue_surviving_children(&root)?; let raw_static_map = live_queue_raw_output_map(&self.queue);
let output =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?; if let Some(emitter) = self.encrypted_strings.as_mut() {
if self.options.qdf {
emitter.write_handle_object_with_qpdf_obj_gen_map(
self.out,
ObjectRef::new(output, 0),
None,
&root,
&raw_static_map,
&self.raw_removed_refs,
)?; } else {
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: child is direct or removed".to_string(),
)
}) };
let mut direct_stream_writer = LiveDirectStreamWriter {
options: self.options,
output: ObjectRef::new(output, 0),
encryption_context: self.encryption_context,
};
emitter.write_handle_object_with_dynamic_ref_map_and_direct_stream_writer(
self.out,
ObjectRef::new(output, 0),
None,
&root,
&mut map,
&self.removed_refs,
&mut direct_stream_writer,
)?; }
} else {
root.unparse_object_qdf_with_qpdf_obj_gen_map_and_removed(
self.out,
0,
&raw_static_map,
&self.raw_removed_refs,
)?;
}
} else {
let output =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?;
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: child is direct or removed".to_string(),
)
}) };
let mut direct_stream_writer = LiveDirectStreamWriter {
options: self.options,
output: ObjectRef::new(output, 0),
encryption_context: None,
};
let mut write_string = |out: &mut OutputSink<'_>, value: &[u8]| {
crate::pdf_syntax::write_string_value(out, value)
};
crate::writer::object::unparse_root_object_with_dynamic_ref_map_and_string_writer_and_direct_stream_writer(
object,
self.out,
&mut map,
&self.removed_refs,
self.version,
self.final_extension_level,
true,
&mut write_string,
&mut direct_stream_writer,
)?; }
} else if object.as_stream_dict().is_some() {
let source = object.object_ref();
let normalize_content = self.options.content_normalization
&& object.qpdf_obj_gen().is_some_and(|object_gen| {
self.content_stream_state
.normalized_streams
.contains(&object_gen)
});
let (dict, data, dictionary_options) =
canonical_stream_output_for_rewrite(object, self.options, normalize_content)?;
let surviving_children = crate::writer::object::prepared_stream_dictionary_children(
&dict,
dictionary_options,
)?;
self.enqueue_surviving_handles(surviving_children)?;
let output_number =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?;
let emitted_ref = ObjectRef::new(output_number, 0);
let encryption_context = self.encryption_context;
let encrypt_stream = encryption_context
.is_some_and(|context| context.encrypt_metadata || context.metadata_ref != source);
let mut stream_length = data.len();
if let Some(context) = encryption_context {
crate::writer::adjust_aes_stream_length(
&mut stream_length,
context,
encrypt_stream,
)?; dict.replace_key(
b"/Length",
ObjectHandle::integer(i64::try_from(stream_length).map_err(|_| {
crate::Error::Unsupported("stream /Length does not fit in i64".into())
})?), )?; }
let raw_static_map = live_queue_raw_output_map(&self.queue);
if self.options.qdf {
let holder = self
.queue
.borrow()
.stream_length_holders
.get(&source.unwrap_or(ObjectRef::new(output_number, 0)))
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: stream {output_number} has no length holder"
))
})?; if let Some(emitter) = self.encrypted_strings.as_mut() {
emitter.write_handle_stream_dict_with_qpdf_obj_gen_map(
self.out,
emitted_ref,
None,
&dict,
crate::writer::encrypted_strings::StreamDictOptions::new(
true,
dictionary_options,
encrypt_stream,
),
&raw_static_map,
&self.raw_removed_refs,
Some(holder),
)?; } else {
dict.unparse_stream_body_qdf_with_qpdf_obj_gen_map_and_removed_and_length_with_options(
self.out,
0,
&raw_static_map,
&self.raw_removed_refs,
Some(holder),
dictionary_options,
)?; }
if let Some(context) = encryption_context {
crate::writer::write_stream_payload_with_pipeline_qdf(
self.out,
&data,
self.options.newline_before_endstream,
true,
emitted_ref,
context,
encrypt_stream,
None,
)?; } else {
serialize::write_stream_payload_with_qdf(
self.out,
&data,
self.options.newline_before_endstream,
true,
)?; }
self.current_stream_length = Some(IndirectStreamLength {
cur_stream_length: stream_length,
added_newline: serialize::framing_adds_newline_with_qdf(
&data,
self.options.newline_before_endstream,
true,
),
});
} else {
if let Some(emitter) = self.encrypted_strings.as_mut() {
emitter.write_handle_stream_dict_with_qpdf_obj_gen_map(
self.out,
emitted_ref,
None,
&dict,
crate::writer::encrypted_strings::StreamDictOptions::new(
false,
dictionary_options,
encrypt_stream,
),
&raw_static_map,
&self.raw_removed_refs,
None,
)?; crate::writer::write_stream_payload_with_pipeline(
self.out,
&data,
self.options.newline_before_endstream,
emitted_ref,
encryption_context.expect("encrypted emitter has a context"),
encrypt_stream,
None,
)?; } else {
dict.unparse_stream_body_with_qpdf_obj_gen_map_and_removed_with_options(
self.out,
dictionary_options,
&raw_static_map,
&self.raw_removed_refs,
)?; serialize::write_stream_payload(
self.out,
&data,
self.options.newline_before_endstream,
)?;
}
}
} else if self.encrypted_strings.is_some() || self.options.qdf {
self.enqueue_surviving_children(object)?;
let raw_static_map = live_queue_raw_output_map(&self.queue);
let output =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?;
if let Some(emitter) = self.encrypted_strings.as_mut() {
if self.options.qdf {
emitter.write_handle_object_with_qpdf_obj_gen_map(
self.out,
ObjectRef::new(output, 0),
None,
object,
&raw_static_map,
&self.raw_removed_refs,
)?; } else {
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: child is direct or removed".to_string(),
)
}) };
let mut direct_stream_writer = LiveDirectStreamWriter {
options: self.options,
output: ObjectRef::new(output, 0),
encryption_context: self.encryption_context,
};
emitter.write_handle_object_with_dynamic_ref_map_and_direct_stream_writer(
self.out,
ObjectRef::new(output, 0),
None,
object,
&mut map,
&self.removed_refs,
&mut direct_stream_writer,
)?; }
} else {
object.unparse_object_qdf_with_qpdf_obj_gen_map_and_removed(
self.out,
0,
&raw_static_map,
&self.raw_removed_refs,
)?; }
} else {
let output =
self.output_number(object.qpdf_obj_gen().unwrap_or(QpdfObjGen::new(0, 0)))?;
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: child is direct or removed".to_string(),
)
}) };
let mut direct_stream_writer = LiveDirectStreamWriter {
options: self.options,
output: ObjectRef::new(output, 0),
encryption_context: None,
};
let mut write_string = |out: &mut OutputSink<'_>, value: &[u8]| {
crate::pdf_syntax::write_string_value(out, value)
};
crate::writer::object::unparse_object_with_dynamic_ref_map_and_string_writer_and_direct_stream_writer(
object,
self.out,
&mut map,
&self.removed_refs,
&mut write_string,
&mut direct_stream_writer,
)?;
}
Ok(())
}
}
impl<'pdf, 'output, 'sink, R: Read + Seek + 'static> LiveObjectEmitter<'pdf, 'output, 'sink, R> {
fn enqueue_surviving_handles(
&mut self,
children: impl IntoIterator<Item = ObjectHandle>,
) -> crate::Result<()> {
for value in children {
let mut indirect_children = Vec::new();
collect_live_seed_handles(&value, &mut indirect_children, 0)?;
for child in indirect_children {
self.queue.borrow_mut().enqueue_handle(self.pdf, child)?;
}
}
Ok(())
}
fn enqueue_surviving_children(&mut self, value: &ObjectHandle) -> crate::Result<()> {
let mut children = Vec::new();
collect_live_child_handles(value, &mut children, 0)?;
self.enqueue_surviving_handles(children)
}
#[allow(clippy::too_many_arguments)]
fn emit_live_object_stream_member(
&mut self,
out: &mut OutputSink<'_>,
_member_index: u32,
_member_ref: ObjectRef,
source: &ObjectHandle,
report_before: bool,
report_after: bool,
decrement: bool,
) -> crate::Result<()> {
if decrement {
crate::writer::decrement_progress_event(self.options)?;
crate::writer::report_progress_event(self.options)?;
}
if report_before {
crate::writer::report_progress_event(self.options)?;
}
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: child is direct or removed".to_string(),
)
}) };
source.try_dereference()?;
let handle = if source.as_stream_dict().is_some() {
source.warn_if_possible("stream found inside object stream; treating as null")?;
ObjectHandle::null()
} else {
source.clone()
};
let result = if handle.object_ref() == self.root_source {
handle.unparse_root_object_with_dynamic_ref_map(
out,
&mut map,
&self.removed_refs,
self.version,
self.final_extension_level,
true,
)
} else {
handle.unparse_object_with_dynamic_ref_map(out, &mut map, &self.removed_refs)
};
if report_after && result.is_ok() {
crate::writer::report_progress_event(self.options)?; }
result
}
fn emit_live_object_stream(
&mut self,
container: &ObjectHandle,
members: &[ObjectRef],
) -> crate::Result<()> {
if self.options.qdf {
return self.emit_live_qdf_object_stream(container, members);
}
let container_source = container.object_ref().ok_or_else(|| {
crate::Error::Internal(
"plain live writer: object-stream container has no source identity".to_string(),
)
})?; let output = self
.queue
.borrow()
.old_to_new
.get(&container_source)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: reference {} {} R absent from queue",
container_source.number, container_source.generation
))
})?;
let mut handles = Vec::with_capacity(members.len());
for &member_source in members {
let member_output = self
.queue
.borrow()
.old_to_new
.get(&member_source)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: object-stream member {} {} R absent from queue",
member_source.number, member_source.generation
))
})?;
let handle = self.pdf.get_object_handle(member_source);
handles.push((member_output, handle));
}
if self.two_pass_object_streams {
let mut first_pass = |out: &mut OutputSink<'_>,
index: u32,
member: ObjectRef,
handle: &ObjectHandle| {
self.emit_live_object_stream_member(out, index, member, handle, false, false, true)
};
let _ = object_streams::emit_objstm_body_from_handles_with_sink(
&handles,
&mut first_pass,
false,
)?; } let mut final_pass =
|out: &mut OutputSink<'_>, index: u32, member: ObjectRef, handle: &ObjectHandle| {
self.emit_live_object_stream_member(
out,
index,
member,
handle,
self.two_pass_object_streams,
!self.two_pass_object_streams,
false,
)
};
let body = object_streams::emit_objstm_body_from_handles_with_sink(
&handles,
&mut final_pass,
true,
)?; let extends = {
let source_handle = self.pdf.get_object_handle(container_source);
source_handle.try_dereference()?;
match source_handle.as_stream_dict() {
Some(source_dict) => {
let extends_handle = source_dict.try_get_key(b"/Extends")?;
match extends_handle.object_ref() {
Some(_) => Some(
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, extends_handle)?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: object-stream /Extends is direct or removed"
.to_string(),
)
})?,
),
None => None,
}
}
None => None,
}
};
let offset = self.output_count()?;
self.out
.write_bytes(format!("{} {} obj\n", output.number, output.generation).as_bytes())?;
if let Some(context) = self.encryption_context {
serialize::write_encrypted_objstm_stream_with_extends(
self.out,
body,
self.options.compress_streams,
self.options.newline_before_endstream,
extends,
output,
context,
)?; } else {
serialize::write_objstm_stream_with_extends(
self.out,
body,
self.options.compress_streams,
self.options.newline_before_endstream,
extends,
)?; } self.out.write_bytes(b"\nendobj\n")?;
self.layout
.uncompressed
.insert(output.number, (output.generation, offset));
for (index, (member_output, _)) in handles.iter().enumerate() {
self.layout.compressed.insert(
member_output.number,
CompressedLocation {
container: output.number,
index: u32::try_from(index).unwrap_or(u32::MAX),
},
);
}
Ok(())
}
fn emit_live_qdf_object_stream(
&mut self,
container: &ObjectHandle,
members: &[ObjectRef],
) -> crate::Result<()> {
let container_source = container.object_ref().ok_or_else(|| {
crate::Error::Internal(
"plain live writer: QDF object-stream container has no source identity".into(),
)
})?; let output = self
.queue
.borrow()
.old_to_new
.get(&container_source)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: reference {} {} R absent from queue",
container_source.number, container_source.generation
))
})?; let mut handles = Vec::with_capacity(members.len());
for &member_source in members {
let member_output = self
.queue
.borrow()
.old_to_new
.get(&member_source)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain live writer: object-stream member {} {} R absent from queue",
member_source.number, member_source.generation
))
})?; handles.push((member_output, self.pdf.get_object_handle(member_source)));
}
let root_source = self.root_source;
let raw_removed_refs = self.raw_removed_refs.clone();
let first_pass = Cell::new(true);
let mut marker_starts = Vec::with_capacity(handles.len());
let mut marker_lengths = Vec::with_capacity(handles.len());
let body_writer = &mut |out: &mut OutputSink<'_>,
member_index: u32,
member_ref: ObjectRef,
handle: &ObjectHandle|
-> crate::Result<()> {
let marker_start = out.position_usize()?;
let source_member = usize::try_from(member_index)
.ok()
.and_then(|index| members.get(index))
.copied()
.unwrap_or(member_ref);
out.write_bytes(b"%% Object stream: object ")?;
write_decimal_u64(out, u64::from(member_ref.number))?;
out.write_bytes(b", index ")?;
write_decimal_u64(out, u64::from(member_index))?;
if !self.options.no_original_object_ids {
let original = self.pdf.writer_original_object_ref(source_member);
out.write_bytes(b"; original object ID: ")?;
write_decimal_u64(out, u64::from(original.number))?;
if original.generation != 0 {
out.write_bytes(b" ")?;
write_decimal_u64(out, u64::from(original.generation))?;
}
} out.write_bytes(b"\n")?;
if first_pass.get() {
marker_starts.push(marker_start);
marker_lengths.push(out.position_usize()? - marker_start);
}
if let Some(sequence) = handle
.qpdf_obj_gen()
.and_then(|source| self.content_stream_state.page_sequences.get(&source))
{
out.write_bytes(b"%% Page ")?;
write_decimal_u64(out, *sequence as u64)?;
out.write_bytes(b"\n")?;
}
if first_pass.get() {
crate::writer::decrement_progress_event(self.options)?;
crate::writer::report_progress_event(self.options)?;
} else {
crate::writer::report_progress_event(self.options)?;
}
handle.try_dereference()?;
let handle_to_write = if handle.as_stream_dict().is_some() {
for _ in 0..2 {
handle
.warn_if_possible("stream found inside object stream; treating as null")?;
}
ObjectHandle::null()
} else {
handle.clone()
};
let mut map = |child: &ObjectHandle| {
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, child.clone())?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: QDF child is direct or removed".to_string(),
)
}) };
if handle_to_write.object_ref() == root_source {
let root = handle_to_write.output_root_copy_with_adbe(
self.version,
self.final_extension_level,
true,
)?; crate::writer::object::unparse_object_qdf_with_dynamic_ref_map(
&root,
0,
out,
&mut map,
&raw_removed_refs,
) } else {
crate::writer::object::unparse_object_qdf_with_dynamic_ref_map(
&handle_to_write,
0,
out,
&mut map,
&raw_removed_refs,
) }
};
let _ = object_streams::emit_objstm_body_from_handles_with_sink_qdf(
&handles,
body_writer,
false,
)?; first_pass.set(false);
let body = object_streams::emit_objstm_body_from_handles_with_sink_qdf(
&handles,
body_writer,
true,
)?; let first_marker_len = marker_lengths.first().copied().ok_or_else(|| {
crate::Error::Internal("plain live QDF ObjStm marker lengths are empty".into())
})?; let mut body_bytes = body.bytes;
body_bytes.drain(..body.first_offset);
let mut pair_table = Vec::new();
for (index, ((member, _), (&marker_start, &marker_len))) in handles
.iter()
.zip(marker_starts.iter().zip(marker_lengths.iter()))
.enumerate()
{
if index != 0 {
pair_table.push(b'\n');
}
let offset = marker_start
.checked_add(marker_len)
.and_then(|end| end.checked_sub(first_marker_len))
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live QDF ObjStm member offset overflows usize".into(),
)
})?; use std::io::Write as _;
let _ = write!(pair_table, "{} {}", member.number, offset);
}
pair_table.push(b'\n');
let first_offset = pair_table.len();
let objects_len = body_bytes.len();
body_bytes.reserve(first_offset);
body_bytes.resize(
objects_len.checked_add(first_offset).ok_or_else(|| {
crate::Error::Unsupported(
"plain live QDF ObjStm body length overflows usize".into(),
)
})?, 0,
);
body_bytes.copy_within(0..objects_len, first_offset);
body_bytes[..first_offset].copy_from_slice(&pair_table);
let qdf_first_offset = first_offset.checked_add(first_marker_len).ok_or_else(|| {
crate::Error::Unsupported("plain live QDF ObjStm /First overflows usize".into())
})?; let body = object_streams::ObjStmBody {
bytes: body_bytes,
first_offset,
n_members: handles.len(),
};
let extends = {
let source_handle = self.pdf.get_object_handle(container_source);
source_handle.try_dereference()?;
match source_handle.as_stream_dict() {
Some(dict) => match dict.try_get_key(b"/Extends")?.object_ref() {
Some(extends) => {
let extends_handle = self.pdf.get_object_handle(extends);
Some(
self.queue
.borrow_mut()
.enqueue_handle(self.pdf, extends_handle)?
.ok_or_else(|| {
crate::Error::Unsupported(
"plain live writer: QDF object-stream /Extends is direct or removed"
.into(),
)
})?,
)
}
None => None,
},
None => None,
}
};
let offset = self.output_count()?;
self.out
.write_bytes(format!("{} {} obj\n", output.number, output.generation).as_bytes())?;
if let Some(context) = self.encryption_context {
serialize::write_encrypted_objstm_stream_with_extends_qdf(
self.out,
body,
extends,
qdf_first_offset,
self.options.newline_before_endstream,
output,
context,
)?; } else {
serialize::write_objstm_stream_with_extends_qdf(
self.out,
body,
extends,
qdf_first_offset,
self.options.newline_before_endstream,
)?; }
self.out.write_bytes(b"\nendobj\n\n")?;
self.layout
.uncompressed
.insert(output.number, (output.generation, offset));
for (index, (member_output, _)) in handles.iter().enumerate() {
self.layout.compressed.insert(
member_output.number,
CompressedLocation {
container: output.number,
index: u32::try_from(index).unwrap_or(u32::MAX),
},
);
}
Ok(())
}
}
pub(crate) fn canonical_stream_output_with_status(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
canonical_stream_output_with_rewrite_policy(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)
}
pub(crate) fn canonical_stream_output_for_rewrite(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
let (dict, data, dictionary_options) =
canonical_stream_output_for_rewrite_with_status(handle, options, normalize_content)?;
Ok((dict, data, dictionary_options))
}
pub(crate) fn canonical_stream_output_for_rewrite_with_status(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
canonical_stream_output_with_status(handle, options, true, normalize_content)
}
#[cfg_attr(not(test), allow(dead_code))]
pub(crate) fn emit_content_container_from_handle_with_ref_map(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut OutputSink<'_>,
map: &dyn Fn(ObjectRef) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<ObjectRef>,
) -> crate::Result<()> {
let raw_map = crate::writer::object::qpdf_obj_gen_map_from_object_ref_map(map);
let raw_removed_refs =
crate::writer::object::qpdf_obj_gen_set_from_object_ref_set(removed_refs)?;
let mut write_string =
|out: &mut OutputSink<'_>, value: &[u8]| crate::pdf_syntax::write_string_value(out, value);
emit_content_container_from_handle_with_qpdf_obj_gen_map_and_string_writer(
container,
options,
out,
&raw_map,
&raw_removed_refs,
&mut write_string,
)
}
#[cfg_attr(not(test), allow(dead_code))]
pub(crate) fn emit_content_container_from_handle_with_ref_map_and_string_writer<F>(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut OutputSink<'_>,
map: &dyn Fn(ObjectRef) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<ObjectRef>,
write_string: &mut F,
) -> crate::Result<()>
where
F: FnMut(&mut OutputSink<'_>, &[u8]) -> crate::Result<()>,
{
let raw_map = crate::writer::object::qpdf_obj_gen_map_from_object_ref_map(map);
let raw_removed_refs =
crate::writer::object::qpdf_obj_gen_set_from_object_ref_set(removed_refs)?;
emit_content_container_from_handle_with_qpdf_obj_gen_map_and_string_writer(
container,
options,
out,
&raw_map,
&raw_removed_refs,
write_string,
)
}
pub(crate) fn emit_content_container_from_handle_with_qpdf_obj_gen_map(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut OutputSink<'_>,
map: &dyn Fn(crate::qpdf_obj_gen::QpdfObjGen) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<crate::qpdf_obj_gen::QpdfObjGen>,
) -> crate::Result<()> {
let mut write_string =
|out: &mut OutputSink<'_>, value: &[u8]| crate::pdf_syntax::write_string_value(out, value);
emit_content_container_from_handle_with_qpdf_obj_gen_map_and_string_writer(
container,
options,
out,
map,
removed_refs,
&mut write_string,
)
}
pub(crate) fn emit_content_container_from_handle_with_qpdf_obj_gen_map_and_string_writer<F>(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut OutputSink<'_>,
map: &dyn Fn(crate::qpdf_obj_gen::QpdfObjGen) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<crate::qpdf_obj_gen::QpdfObjGen>,
write_string: &mut F,
) -> crate::Result<()>
where
F: FnMut(&mut OutputSink<'_>, &[u8]) -> crate::Result<()>,
{
let container = if options.content_normalization {
normalize_content_container(container, options)?
} else {
container.clone()
};
let mut emitter = ContentEmitter {
qdf: options.qdf,
out,
map,
removed_refs,
write_string,
};
emitter.emit_value(&container, true, 0)
}
const CONTENT_EMIT_STACK_RED_ZONE: usize = 32 * 1024;
const CONTENT_EMIT_STACK_GROWTH_SIZE: usize = 1024 * 1024;
thread_local! {
static CONTENT_EMIT_WALK_DEPTH: Cell<usize> = const { Cell::new(0) };
}
struct ContentEmitWalkDepthGuard;
impl ContentEmitWalkDepthGuard {
#[deprecated(
note = "no qpdf counterpart; QPDFWriter::unparseObject has no upper nesting limit"
)]
fn enter() -> crate::Result<Self> {
let depth = CONTENT_EMIT_WALK_DEPTH.with(|depth| {
let entered = depth.get();
depth.set(entered + 1);
entered
});
let guard = Self;
if depth > crate::parser::MAX_PARSE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"writer: direct content nesting exceeds maximum of {}",
crate::parser::MAX_PARSE_DEPTH
)));
}
Ok(guard)
}
}
impl Drop for ContentEmitWalkDepthGuard {
fn drop(&mut self) {
CONTENT_EMIT_WALK_DEPTH.with(|depth| depth.set(depth.get().saturating_sub(1)));
}
}
#[allow(deprecated)]
fn content_emit_walk_hub<T>(body: impl FnOnce() -> crate::Result<T>) -> crate::Result<T> {
let _depth = ContentEmitWalkDepthGuard::enter()?;
stacker::maybe_grow(
CONTENT_EMIT_STACK_RED_ZONE,
CONTENT_EMIT_STACK_GROWTH_SIZE,
body,
)
}
fn normalize_content_container(
container: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<ObjectHandle> {
container.try_dereference()?;
if let Some(entries) = container.try_as_dictionary()? {
let entries = entries
.into_iter()
.map(|(key, value)| {
if key.as_slice() == b"/Contents" {
Ok((key, normalize_content_value(&value, options)?))
} else {
Ok((key, value))
}
})
.collect::<crate::Result<Vec<_>>>()?;
return Ok(ObjectHandle::dictionary(entries));
}
if let Some(items) = container.try_as_array()? {
let items = items
.into_iter()
.map(|item| normalize_content_value(&item, options))
.collect::<crate::Result<Vec<_>>>()?;
return Ok(ObjectHandle::array(items));
} Ok(container.clone()) }
fn normalize_content_value(
value: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<ObjectHandle> {
content_emit_walk_hub(|| {
if value.is_indirect() {
return Ok(value.clone());
}
value.try_dereference()?;
if value.as_stream_dict().is_some() {
let (dict, data, _) = canonical_stream_output_for_rewrite(value, options, true)?; return Ok(ObjectHandle::stream(dict, Rc::new(data)));
}
if let Some(items) = value.try_as_array()? {
let items = items
.into_iter()
.map(|item| normalize_content_value(&item, options))
.collect::<crate::Result<Vec<_>>>()?;
return Ok(ObjectHandle::array(items));
}
Ok(value.clone())
})
}
struct ContentEmitter<'out, 'sink, 'map, 'removed, 'writer, F>
where
F: FnMut(&mut OutputSink<'_>, &[u8]) -> crate::Result<()>,
{
qdf: bool,
out: &'out mut OutputSink<'sink>,
map: &'map dyn Fn(crate::qpdf_obj_gen::QpdfObjGen) -> crate::Result<ObjectRef>,
removed_refs: &'removed BTreeSet<crate::qpdf_obj_gen::QpdfObjGen>,
write_string: &'writer mut F,
}
impl<F> ContentEmitter<'_, '_, '_, '_, '_, F>
where
F: FnMut(&mut OutputSink<'_>, &[u8]) -> crate::Result<()>,
{
fn emit_value(&mut self, value: &ObjectHandle, root: bool, indent: usize) -> crate::Result<()> {
content_emit_walk_hub(|| {
if !root {
if let Some(object_gen) = value.qpdf_obj_gen() {
if !object_gen.is_indirect() || self.removed_refs.contains(&object_gen) {
self.out.write_bytes(b"null")?;
} else {
write_object_ref(self.out, (self.map)(object_gen)?)?;
}
return Ok(());
}
}
value.try_dereference()?;
if value.as_stream_dict().is_some() {
return self.emit_direct_stream(value, indent);
}
if root {
if value.try_is_array()? && has_direct_stream_in_value(value)? {
let items = value.try_as_array()?.ok_or_else(|| {
crate::Error::Internal("content array disappeared during emission".into())
})?; return self.emit_array(&items, indent);
}
if let Some(entries) = value.try_as_dictionary()? {
let has_contents_stream = entries
.get(b"/Contents".as_slice())
.map(has_direct_stream_in_value)
.transpose()?
.unwrap_or(false);
if has_contents_stream {
return self.emit_dictionary(&entries, indent);
}
}
} else if has_direct_stream_in_value(value)? {
if let Some(items) = value.try_as_array()? {
return self.emit_array(&items, indent);
}
if let Some(entries) = value.try_as_dictionary()? {
return self.emit_dictionary(&entries, indent);
} }
if self.qdf {
value.unparse_object_qdf_with_qpdf_obj_gen_map_and_removed_with_string_writer(
self.out,
indent,
self.map,
self.removed_refs,
self.write_string,
)
} else {
value.unparse_object_with_qpdf_obj_gen_map_and_removed_with_string_writer(
self.out,
self.map,
self.removed_refs,
self.write_string,
)
}
})
}
fn emit_array(&mut self, items: &[ObjectHandle], indent: usize) -> crate::Result<()> {
if self.qdf {
self.out.write_bytes(b"[\n")?;
for item in items {
push_spaces(self.out, indent + 2)?;
self.emit_value(item, false, indent + 2)?;
self.out.write_bytes(b"\n")?;
}
push_spaces(self.out, indent)?;
self.out.write_bytes(b"]")?;
} else {
self.out.write_bytes(b"[")?;
for item in items {
self.out.write_bytes(b" ")?;
self.emit_value(item, false, indent)?;
}
self.out.write_bytes(b" ]")?;
}
Ok(())
}
fn emit_dictionary(
&mut self,
entries: &BTreeMap<Vec<u8>, ObjectHandle>,
indent: usize,
) -> crate::Result<()> {
if self.qdf {
self.out.write_bytes(b"<<\n")?;
} else {
self.out.write_bytes(b"<<")?;
}
for (key, value) in entries {
if value.try_is_null()? || is_removed_content_reference(value, self.removed_refs) {
continue;
}
if self.qdf {
push_spaces(self.out, indent + 2)?;
} else {
self.out.write_bytes(b" ")?;
}
write_content_key(self.out, key)?;
self.out.write_bytes(b" ")?;
self.emit_value(value, false, indent + 2)?; if self.qdf {
self.out.write_bytes(b"\n")?;
}
}
if self.qdf {
push_spaces(self.out, indent)?;
self.out.write_bytes(b">>")?;
} else {
self.out.write_bytes(b" >>")?;
}
Ok(())
}
fn emit_direct_stream(&mut self, stream: &ObjectHandle, indent: usize) -> crate::Result<()> {
let dict = stream.as_stream_dict().ok_or_else(|| {
crate::Error::Internal("direct content stream dictionary is missing".into())
})?; if self.qdf {
dict.unparse_object_qdf_with_qpdf_obj_gen_map_and_removed_with_string_writer(
self.out,
indent,
self.map,
self.removed_refs,
self.write_string,
)?; } else {
dict.unparse_object_with_qpdf_obj_gen_map_and_removed_with_string_writer(
self.out,
self.map,
self.removed_refs,
self.write_string,
)?; }
self.out.write_bytes(b"\nstream\n")?;
let payload = stream.get_raw_stream_data()?;
let payload_result = self.out.write_bytes(payload.as_ref());
let finish_result = self.out.finish_segment();
payload_result?;
finish_result?;
self.out.write_bytes(b"\nendstream")
}
}
fn has_direct_stream_in_value(value: &ObjectHandle) -> crate::Result<bool> {
has_direct_stream_in_value_body(value)
}
fn has_direct_stream_in_value_charged(value: &ObjectHandle) -> crate::Result<bool> {
content_emit_walk_hub(|| has_direct_stream_in_value_body(value))
}
fn has_direct_stream_in_value_body(value: &ObjectHandle) -> crate::Result<bool> {
{
if value.is_indirect() {
return Ok(false);
}
value.try_dereference()?;
if value.as_stream_dict().is_some() {
return Ok(true);
}
if let Some(items) = value.try_as_array()? {
for item in items {
if has_direct_stream_in_value_charged(&item)? {
return Ok(true);
}
}
} else if let Some(entries) = value.try_as_dictionary()? {
for (_, child) in entries {
if has_direct_stream_in_value_charged(&child)? {
return Ok(true);
} }
}
Ok(false)
}
}
fn is_removed_content_reference(
value: &ObjectHandle,
removed_refs: &BTreeSet<crate::qpdf_obj_gen::QpdfObjGen>,
) -> bool {
value
.qpdf_obj_gen()
.is_some_and(|object_gen| removed_refs.contains(&object_gen))
}
fn write_content_key(out: &mut OutputSink<'_>, key: &[u8]) -> crate::Result<()> {
out.write_bytes(b"/")?;
let key = key.strip_prefix(b"/").unwrap_or(key);
crate::pdf_syntax::write_name_escaped(out, key)?;
Ok(())
}
fn push_spaces(out: &mut OutputSink<'_>, count: usize) -> crate::Result<()> {
const SPACES: &[u8; 64] = b" ";
let mut remaining = count;
while remaining > 0 {
let chunk = remaining.min(SPACES.len());
out.write_bytes(&SPACES[..chunk])?;
remaining -= chunk;
}
Ok(())
}
pub(crate) fn canonical_stream_output_for_linearization(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
let (dict, data, dictionary_options) =
canonical_stream_output_for_linearization_with_status(handle, options, normalize_content)?;
Ok((dict, data, dictionary_options))
}
pub(crate) fn canonical_stream_output_for_linearization_with_status(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
canonical_stream_data_with_rewrite_policy(handle, options, true, normalize_content)
}
pub(crate) fn canonical_stream_will_be_refiltered_with_policy(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<bool> {
canonical_stream_filter_probe(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)
}
pub(crate) fn canonical_stream_filter_probe_for_linearization(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<bool> {
canonical_stream_filter_probe(handle, options, true, normalize_content)
}
fn canonical_stream_filter_probe(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<bool> {
let Some((encode_flags, decode_level, _normalized_content, _outer_filter)) =
canonical_stream_filter_plan(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)?
else {
let mut discard = crate::pipeline::Discard;
let mut filtering_attempted = false;
handle
.pipe_stream_data(
&mut discard,
&mut filtering_attempted,
0,
crate::writer::DecodeLevel::None,
false,
true,
)
.map_err(|error| stream_data_error(handle, error))?;
return Ok(false);
};
for attempt in 1..=2 {
let mut discard = crate::pipeline::Discard;
let mut filtering_attempted = false;
let (attempt_encode_flags, attempt_decode_level) = if attempt == 1 {
(encode_flags, decode_level)
} else {
(0, crate::writer::DecodeLevel::None)
};
let success = handle
.pipe_stream_data(
&mut discard,
&mut filtering_attempted,
attempt_encode_flags,
attempt_decode_level,
false,
attempt == 1,
)
.map_err(|error| stream_data_error(handle, error))?;
if success || attempt == 2 {
return Ok(filtering_attempted && success);
}
}
unreachable!("the two-attempt stream filter probe always returns") }
fn canonical_stream_output_with_rewrite_policy(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
let (stream_dict, data, dictionary_options) = canonical_stream_data_with_rewrite_policy(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)?;
let mut entries = stream_dict.try_as_dictionary()?.unwrap_or_default();
entries.insert(
b"/Length".to_vec(),
ObjectHandle::integer(i64::try_from(data.len()).unwrap_or(i64::MAX)),
);
let dict = ObjectHandle::dictionary(entries.into_iter().collect());
if dict.context().is_none() && handle.context().is_some() {
dict.set_child_description(handle, b" -> stream dictionary", b"");
}
Ok((dict, data, dictionary_options))
}
fn canonical_stream_data_with_rewrite_policy(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, StreamDictionaryOptions)> {
let stream_dict = handle
.as_stream_dict()
.ok_or_else(|| crate::Error::Internal("canonical stream dictionary is missing".into()))?;
let is_metadata_stream = apply_full_rewrite_metadata_policy
&& stream_dict.try_is_dictionary_of_type(b"Metadata", b"")?
&& options
.encrypt
.as_ref()
.is_none_or(|params| !params.encrypt_metadata)
&& options
.copy_encryption
.as_ref()
.is_none_or(|source| !crate::writer::copy_encryption_encrypts_metadata(source));
let normalize_content = normalize_content && !is_metadata_stream;
let policy = if is_metadata_stream {
Some(CompressStreams::No)
} else {
crate::writer::effective_stream_policy(options)
};
let source_for_pipe = handle.clone();
let filter_plan = canonical_stream_filter_plan(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)?; let (data, filtering_attempted, normalized_content) =
if let Some((encode_flags, decode_level, normalized_content, outer_filter)) = filter_plan {
let mut attempt = 1_u8;
let (data, filtering_attempted, _source_success) = loop {
let mut buffer =
crate::pipeline::buffer::Buffer::new("canonical writer stream", None);
let mut actual_filtering_attempted = false;
let (attempt_encode_flags, attempt_decode_level) = if attempt == 1 {
(encode_flags, decode_level)
} else {
(0, crate::writer::DecodeLevel::None)
};
let source_success = source_for_pipe
.pipe_stream_data(
&mut buffer,
&mut actual_filtering_attempted,
attempt_encode_flags,
attempt_decode_level,
false,
attempt == 1,
)
.map_err(|error| stream_data_error(&source_for_pipe, error))?;
if outer_filter && !actual_filtering_attempted && attempt == 1 {
attempt = 2;
continue;
}
break (
buffer.take_buffer()?,
actual_filtering_attempted,
source_success,
);
};
(data, filtering_attempted, normalized_content)
} else {
(
canonical_stream_source_data(&source_for_pipe)
.map_err(|error| stream_data_error(&source_for_pipe, error))?,
false,
false,
)
};
let dictionary_options = if filtering_attempted {
StreamDictionaryOptions::new(
true,
matches!(policy, Some(CompressStreams::Yes)) && !normalized_content,
)
} else {
StreamDictionaryOptions::preserve()
};
Ok((stream_dict, data, dictionary_options))
}
fn canonical_stream_source_data(handle: &ObjectHandle) -> crate::Result<Vec<u8>> {
let mut buffer = crate::pipeline::buffer::Buffer::new("canonical writer stream", None);
let mut filtering_attempted = false;
let _source_success = handle.pipe_stream_data(
&mut buffer,
&mut filtering_attempted,
0,
crate::writer::DecodeLevel::None,
false,
true,
)?; Ok(buffer.take_buffer()?)
}
fn stream_data_error(handle: &ObjectHandle, error: crate::Error) -> crate::Error {
if let Some(object_ref) = handle.object_ref() {
crate::Error::System(format!(
"error while getting stream data for {object_ref}: {error}"
))
} else {
error
}
}
fn canonical_stream_filter_plan(
handle: &ObjectHandle,
options: &WriterOptions,
apply_full_rewrite_metadata_policy: bool,
normalize_content: bool,
) -> crate::Result<Option<(u32, crate::writer::DecodeLevel, bool, bool)>> {
let stream_dict = handle
.as_stream_dict()
.ok_or_else(|| crate::Error::Internal("canonical stream dictionary is missing".into()))?;
if !handle.get_filter_on_write()? {
return Ok(None);
}
let normalization_applied = normalize_content && handle.content_normalization_applied();
let normalize_content = normalize_content && !normalization_applied;
let source_has_lone_flate = canonical_is_lone_flate(&stream_dict)?;
let is_metadata_stream = apply_full_rewrite_metadata_policy
&& stream_dict.try_is_dictionary_of_type(b"Metadata", b"")?
&& options
.encrypt
.as_ref()
.is_none_or(|params| !params.encrypt_metadata)
&& options
.copy_encryption
.as_ref()
.is_none_or(|source| !crate::writer::copy_encryption_encrypts_metadata(source));
let normalize_content = normalize_content && !is_metadata_stream;
let normalized_content = (normalize_content || normalization_applied) && !is_metadata_stream;
let policy = if is_metadata_stream {
Some(CompressStreams::No)
} else {
crate::writer::effective_stream_policy(options)
};
let decode_level = if is_metadata_stream {
crate::writer::DecodeLevel::All
} else {
options.decode_level
};
let preserve_lone_flate = matches!(policy, Some(CompressStreams::Yes))
&& source_has_lone_flate
&& !handle.is_data_modified()
&& !options.recompress_flate
&& !normalized_content;
if !handle.is_data_modified() && (policy.is_none() || preserve_lone_flate) {
return Ok(None);
}
let mut encode_flags = if matches!(policy, Some(CompressStreams::Yes)) && !normalized_content {
crate::object_handle::STREAM_ENCODE_COMPRESS
} else {
0
};
if normalize_content {
encode_flags |= crate::object_handle::STREAM_ENCODE_NORMALIZE;
}
let outer_filter = handle.is_data_modified()
|| matches!(options.compress_streams, CompressStreams::Yes)
|| options.decode_level != crate::writer::DecodeLevel::None
|| is_metadata_stream
|| normalize_content;
Ok(Some((
encode_flags,
decode_level,
normalized_content,
outer_filter,
)))
}
fn canonical_is_lone_flate(dict: &ObjectHandle) -> crate::Result<bool> {
let filter = dict.try_get_key(b"/Filter")?;
if filter.try_is_null()? {
return Ok(false);
}
if filter.try_is_name_and_equals(b"FlateDecode")? || filter.try_is_name_and_equals(b"Fl")? {
return Ok(true);
}
Ok(false)
}
#[cfg(test)]
fn validate_objstm_member_bodies<R: Read + Seek>(
pdf: &mut Pdf<R>,
plan: &PlainWritePlan,
) -> crate::Result<()> {
if !plan
.objects
.iter()
.any(|object| matches!(object, PlannedIndirectObject::ObjectStream { .. }))
{
return Ok(());
}
let context = object_streams::eligibility_context(pdf)?;
for planned in &plan.objects {
let PlannedIndirectObject::ObjectStream { members, .. } = planned else {
continue;
};
for member in members {
let member_handle = pdf.get_object_handle(member.source);
member_handle.try_dereference()?;
let violation = planned_member_body_violation(
member.source,
member.output,
&member_handle,
&context,
)?; if let Some(kind) = violation {
return Err(crate::Error::Unsupported(format!(
"plain writer body invariant: source {} planned as ObjStm member {} \
resolves to forbidden {kind}",
member.source, member.output
)));
}
}
}
Ok(())
}
#[cfg(test)]
fn planned_member_body_violation(
source: crate::ObjectRef,
output: crate::ObjectRef,
object: &ObjectHandle,
context: &object_streams::EligibilityContext,
) -> crate::Result<Option<&'static str>> {
if output.generation != 0 {
return Ok(Some("nonzero output generation"));
}
if object.as_stream_dict().is_some() {
return Ok(Some("stream body"));
}
if context.encryption_ref == Some(source) {
return Ok(Some("encryption dictionary"));
}
Ok(None)
}
#[cfg(test)]
mod final_handle_tests {
use super::{
canonical_stream_filter_probe_for_linearization, canonical_stream_output_for_rewrite,
emit_content_container_from_handle_with_qpdf_obj_gen_map,
emit_content_container_from_handle_with_ref_map,
emit_content_container_from_handle_with_ref_map_and_string_writer,
normalize_content_container, normalize_content_value, object_streams, PlainWritePlan,
PlannedIndirectObject, CONTENT_EMIT_WALK_DEPTH,
};
use crate::token_filter::{TokenFilter, TokenFilterOutput};
use crate::tokenizer::Token;
use crate::writer::{NewlineBeforeEndstream, WriterOptions};
use crate::{ObjectHandle, ObjectRef};
use std::cell::RefCell;
use std::collections::BTreeSet;
use std::rc::Rc;
fn unfiltered_stream_probe_pdf() -> Vec<u8> {
let mut pdf = b"%PDF-1.4\n".to_vec();
let object_start = |pdf: &Vec<u8>| pdf.len();
let mut offsets = Vec::new();
offsets.push(object_start(&pdf));
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push(object_start(&pdf));
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offsets.push(object_start(&pdf));
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 10 10] /Contents 4 0 R >>\nendobj\n",
);
offsets.push(object_start(&pdf));
pdf.extend_from_slice(
b"4 0 obj\n<< /Length 3 /Filter /FlateDecode >>\nstream\nabc\nendstream\nendobj\n",
);
let xref = pdf.len();
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
for offset in offsets {
pdf.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn linearization_probe_pipes_an_unfiltered_stream_like_qpdf() {
let mut pdf = crate::Pdf::open(std::io::Cursor::new(unfiltered_stream_probe_pdf()))
.expect("probe PDF");
let stream = pdf.get_object_handle(ObjectRef::new(4, 0));
stream.try_dereference().expect("resolve stream framing");
let before = pdf.source_last_offset();
let options = WriterOptions::default();
assert!(
!canonical_stream_filter_probe_for_linearization(&stream, &options, false)
.expect("qpdf raw stream probe")
);
assert_ne!(
pdf.source_last_offset(),
before,
"willFilterStream must pipe even when no filter is selected"
);
}
#[test]
fn content_container_emits_direct_streams_and_uses_the_handle_string_writer() {
let stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![
(b"/Length".to_vec(), ObjectHandle::integer(4)),
(b"/Label".to_vec(), ObjectHandle::string(b"data".to_vec())),
]),
Rc::new(b"data".to_vec()),
);
let container = ObjectHandle::dictionary(vec![(b"/Contents".to_vec(), stream)]);
let options = WriterOptions {
newline_before_endstream: NewlineBeforeEndstream::Never,
..WriterOptions::default()
};
let map = |object_ref| Ok(object_ref);
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_content_container_from_handle_with_ref_map(
&container,
&options,
out,
&map,
&BTreeSet::new(),
)
})
.expect("direct content stream emission");
assert!(output
.windows(b"/Contents".len())
.any(|window| window == b"/Contents"));
assert!(output
.windows(b"stream\ndata\nendstream".len())
.any(|window| { window == b"stream\ndata\nendstream" }));
}
#[test]
fn content_normalization_resolves_an_indirect_contents_array_receiver() -> crate::Result<()> {
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/qdf-contents-ref-array.pdf");
let bytes = std::fs::read(fixture).expect("indirect Contents array fixture");
let mut pdf = crate::Pdf::open(std::io::Cursor::new(bytes))?;
let page = pdf.get_object_handle(ObjectRef::new(3, 0));
let contents = page.try_get_key(b"/Contents")?;
assert!(
!contents.is_resolved(),
"getKey resolves the page but leaves its indirect child lazy"
);
let options = WriterOptions {
content_normalization: true,
..WriterOptions::default()
};
let normalized = normalize_content_container(&contents, &options)?;
assert!(
contents.is_resolved(),
"writer-body type inspection resolves the indirect array receiver"
);
let items = normalized
.try_as_array()?
.expect("normalized Contents remains an array");
assert_eq!(items.len(), 2);
assert_eq!(items[0].object_ref(), Some(ObjectRef::new(6, 0)));
assert_eq!(items[1].object_ref(), Some(ObjectRef::new(7, 0)));
Ok(())
}
#[test]
fn content_dictionary_skips_a_removed_indirect_value() -> crate::Result<()> {
let mut pdf = crate::Pdf::empty()?;
let removed = pdf.make_indirect_object_handle(ObjectHandle::integer(9))?;
let removed_ref = removed.object_ref().expect("removed value identity");
let contents = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(0))]),
Rc::new(Vec::new()),
);
let container = ObjectHandle::dictionary(vec![
(b"/Contents".to_vec(), contents),
(b"/Removed".to_vec(), removed),
]);
let mut output = Vec::new();
let removed_refs = [removed_ref].into_iter().collect();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_content_container_from_handle_with_ref_map(
&container,
&WriterOptions::default(),
out,
&|_| Err(crate::Error::Internal("removed value was mapped".into())), &removed_refs,
)
})?;
assert!(String::from_utf8_lossy(&output).contains("/Contents"));
assert!(!String::from_utf8_lossy(&output).contains("/Removed"));
Ok(())
}
fn reciprocal_direct_dictionary_cycle() -> crate::Result<ObjectHandle> {
let a = ObjectHandle::dictionary(vec![]);
let b = ObjectHandle::dictionary(vec![]);
a.replace_key(b"/B", b.clone())?;
b.replace_key(b"/A", a.clone())?;
assert!(
a.try_get_key(b"/B")?
.try_get_key(b"/A")?
.is_same_object_as(&a),
"the reciprocal replace_key pair must close into a direct cycle"
);
Ok(a)
}
fn content_holder(contents: ObjectHandle) -> ObjectHandle {
ObjectHandle::dictionary(vec![(b"/Contents".to_vec(), contents)])
}
fn direct_content_stream() -> ObjectHandle {
ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(4))]),
Rc::new(b"data".to_vec()),
)
}
fn nested_direct_content_dictionaries(n: usize) -> ObjectHandle {
let mut handle = direct_content_stream();
for _ in 0..n {
handle = ObjectHandle::dictionary(vec![(b"/K".to_vec(), handle)]);
}
handle
}
fn nested_direct_arrays(n: usize) -> ObjectHandle {
let mut handle = ObjectHandle::integer(1);
for _ in 0..n {
handle = ObjectHandle::array(vec![handle]);
}
handle
}
fn direct_array_depth(handle: &ObjectHandle) -> usize {
let mut current = handle.clone();
let mut depth = 0;
while let Some(items) = current.as_array() {
depth += 1;
current = items
.into_iter()
.next()
.expect("nested array holds a child");
}
depth
}
fn emit_content_container(
container: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<Vec<u8>> {
let map = |object_ref| Ok(object_ref);
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_content_container_from_handle_with_ref_map(
container,
options,
out,
&map,
&BTreeSet::new(),
)
})?;
Ok(output)
}
#[test]
fn direct_dictionary_cycle_is_rejected_by_the_content_emit_family() -> crate::Result<()> {
let options = WriterOptions {
newline_before_endstream: NewlineBeforeEndstream::Never,
..WriterOptions::default()
};
let holder = content_holder(reciprocal_direct_dictionary_cycle()?);
let probed = emit_content_container(&holder, &options)
.expect_err("a direct cycle must not be walked by the content shape probe");
assert!(
matches!(probed, crate::Error::Unsupported(_)),
"unexpected error kind: {probed:?}"
);
assert!(
probed
.to_string()
.contains("direct content nesting exceeds maximum of"),
"unexpected message: {probed}"
);
let cyclic = reciprocal_direct_dictionary_cycle()?;
cyclic.replace_key(b"/A_stream", direct_content_stream())?;
let streamed = emit_content_container(&content_holder(cyclic), &options)
.expect_err("a direct cycle must not be walked by the content emitter");
assert!(
matches!(streamed, crate::Error::Unsupported(_)),
"unexpected error kind: {streamed:?}"
);
assert!(
streamed
.to_string()
.contains("direct content nesting exceeds maximum of"),
"unexpected message: {streamed}"
);
assert_eq!(CONTENT_EMIT_WALK_DEPTH.with(std::cell::Cell::get), 0);
let plain = content_holder(direct_content_stream());
let ordinary = emit_content_container(&plain, &options)?;
assert!(ordinary
.windows(b"stream\ndata\nendstream".len())
.any(|window| window == b"stream\ndata\nendstream"));
Ok(())
}
#[test]
fn acyclic_direct_content_nesting_is_bounded_at_the_parser_limit() -> crate::Result<()> {
let options = WriterOptions {
newline_before_endstream: NewlineBeforeEndstream::Never,
..WriterOptions::default()
};
let within_bound = crate::parser::MAX_PARSE_DEPTH - 1;
let within = content_holder(nested_direct_content_dictionaries(within_bound));
let emitted = emit_content_container(&within, &options)?;
assert_eq!(
String::from_utf8_lossy(&emitted).matches("/K").count(),
within_bound,
"every level within the bound must still be emitted"
);
let past_bound = content_holder(nested_direct_content_dictionaries(within_bound + 1));
let error = emit_content_container(&past_bound, &options)
.expect_err("nesting past the bound must be reported");
assert!(matches!(error, crate::Error::Unsupported(_)));
assert_eq!(
error.to_string(),
format!(
"unsupported PDF feature: writer: direct content nesting exceeds maximum of {}",
crate::parser::MAX_PARSE_DEPTH
)
);
Ok(())
}
fn nested_contents_pdf(depth: usize) -> Vec<u8> {
let mut contents = String::from("0");
for _ in 0..depth {
contents = format!("[{contents}]");
}
let mut pdf = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::new();
offsets.push(pdf.len());
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push(pdf.len());
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offsets.push(pdf.len());
pdf.extend_from_slice(
format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 10 10] /Contents {contents} >>\nendobj\n"
)
.as_bytes(),
);
let xref = pdf.len();
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
for offset in offsets {
pdf.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
pdf
}
fn write_with_content_normalization(source: Vec<u8>) -> crate::Result<Vec<u8>> {
let mut pdf = crate::Pdf::open(std::io::Cursor::new(source))?;
let mut writer = crate::PdfWriter::new(&mut pdf);
writer.set_content_normalization(true);
writer.set_static_id(true);
writer.set_output_memory()?;
writer.write()?;
writer.get_buffer()
}
fn page_contents_depth(source: Vec<u8>) -> crate::Result<usize> {
let mut pdf = crate::Pdf::open(std::io::Cursor::new(source))?;
let page = crate::PageDocumentHelper::new(&mut pdf).get_all_pages()?[0];
Ok(direct_array_depth(
&pdf.get_object_handle(page).try_get_key(b"/Contents")?,
))
}
#[test]
fn deepest_parseable_page_contents_still_writes() -> crate::Result<()> {
let deepest = crate::parser::MAX_PARSE_DEPTH - 1;
let past_budget = page_contents_depth(nested_contents_pdf(deepest + 1))?;
assert_eq!(
past_budget, 0,
"one container past the parser's frame budget must be dropped, \
or this test is not measuring the real maximum"
);
assert_eq!(
page_contents_depth(nested_contents_pdf(deepest))?,
deepest,
"the parser must accept this depth, or the write below proves nothing"
);
let written = write_with_content_normalization(nested_contents_pdf(deepest))?;
assert_eq!(
String::from_utf8_lossy(&written).matches("[ 0 ]").count(),
1,
"the innermost content array must survive the write"
);
let mut reread = crate::Pdf::open(std::io::Cursor::new(written))?;
let page = crate::PageDocumentHelper::new(&mut reread).get_all_pages()?[0];
assert_eq!(
direct_array_depth(&reread.get_object_handle(page).try_get_key(b"/Contents")?),
deepest,
"every nested level must round-trip"
);
Ok(())
}
fn indirect_contents_holder_pdf(depth: usize) -> Vec<u8> {
let mut holder = String::from("0");
for _ in 0..depth {
holder = format!("[{holder}]");
}
let mut pdf = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::new();
offsets.push(pdf.len());
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push(pdf.len());
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offsets.push(pdf.len());
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 10 10] /Contents 4 0 R >>\nendobj\n",
);
offsets.push(pdf.len());
pdf.extend_from_slice(format!("4 0 obj\n{holder}\nendobj\n").as_bytes());
let xref = pdf.len();
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
for offset in offsets {
pdf.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn deepest_parseable_indirect_contents_holder_still_writes() -> crate::Result<()> {
let deepest = crate::parser::MAX_PARSE_DEPTH;
let mut source =
crate::Pdf::open(std::io::Cursor::new(indirect_contents_holder_pdf(deepest)))?;
let page = crate::PageDocumentHelper::new(&mut source).get_all_pages()?[0];
let holder = source.get_object_handle(page).try_get_key(b"/Contents")?;
holder.try_dereference()?;
assert_eq!(
direct_array_depth(&holder),
deepest,
"the parser must accept the full budget here, or this test is \
not measuring the shape qpdf accepts"
);
let written = write_with_content_normalization(indirect_contents_holder_pdf(deepest))?;
assert_eq!(
String::from_utf8_lossy(&written).matches("[ 0 ]").count(),
1,
"the innermost content array must survive the write"
);
Ok(())
}
#[test]
fn deep_direct_arrays_are_bounded_in_content_normalization() -> crate::Result<()> {
let options = WriterOptions {
content_normalization: true,
..WriterOptions::default()
};
let bound = crate::parser::MAX_PARSE_DEPTH;
let normalized = normalize_content_value(&nested_direct_arrays(bound), &options)?;
assert_eq!(
direct_array_depth(&normalized),
bound,
"every level within the bound must still be normalized"
);
let error = normalize_content_value(&nested_direct_arrays(bound + 1), &options)
.expect_err("nesting past the bound must be reported");
assert!(matches!(error, crate::Error::Unsupported(_)));
assert_eq!(
error.to_string(),
format!(
"unsupported PDF feature: writer: direct content nesting exceeds maximum of {bound}"
)
);
Ok(())
}
#[test]
fn rewrite_wrapper_returns_the_shared_stream_dictionary_policy() {
let pdf = crate::Pdf::empty().unwrap();
let stream = pdf
.new_stream_with_data(Rc::new(b"q Q\n".to_vec()))
.unwrap();
let (dictionary, data, policy) =
canonical_stream_output_for_rewrite(&stream, &WriterOptions::default(), false)
.expect("canonical rewrite stream output");
assert!(!data.is_empty());
assert_eq!(
dictionary.try_get_key(b"/Length").unwrap().as_integer(),
Some(data.len() as i64)
);
assert!(policy.add_flate_filter);
}
#[test]
fn planned_objstm_validation_covers_non_member_and_forbidden_shapes() -> crate::Result<()> {
let mut pdf = crate::Pdf::open(std::io::Cursor::new(
include_bytes!("../../../../../tests/fixtures/compat/one-page.pdf").to_vec(),
))?; let options = WriterOptions {
object_streams: crate::writer::ObjectStreamMode::Generate,
..WriterOptions::default()
};
let mut plan = PlainWritePlan::build(&mut pdf, &options)?;
if let Some(root) = pdf.root_ref() {
plan.objects.insert(
0,
PlannedIndirectObject::Source {
source: root,
output: ObjectRef::new(1, 0),
},
);
}
let stream_ref = pdf
.root_handle()?
.try_get_key(b"/Pages")?
.try_get_key(b"/Kids")?
.try_get_array_item(0)?
.try_get_key(b"/Contents")?
.object_ref()
.expect("fixture content stream identity");
if let Some(PlannedIndirectObject::ObjectStream { members, .. }) = plan
.objects
.iter_mut()
.find(|object| matches!(object, PlannedIndirectObject::ObjectStream { .. }))
{
members[0].source = stream_ref;
}
let error = super::validate_objstm_member_bodies(&mut pdf, &plan)
.expect_err("a stream cannot be an ObjStm member");
assert!(error.to_string().contains("forbidden stream body"));
let context = object_streams::EligibilityContext {
encryption_ref: Some(ObjectRef::new(99, 0)),
};
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(1, 0),
ObjectRef::new(1, 1),
&ObjectHandle::integer(1),
&context,
)?, Some("nonzero output generation")
);
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(1, 0),
ObjectRef::new(1, 0),
&ObjectHandle::stream(ObjectHandle::dictionary(Vec::new()), Rc::new(Vec::new()),),
&context,
)?, Some("stream body")
);
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(1, 0),
ObjectRef::new(1, 0),
&ObjectHandle::dictionary(vec![(
b"/Type".to_vec(),
ObjectHandle::name(b"XRef".to_vec()),
)]),
&context,
)?, None
);
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(1, 0),
ObjectRef::new(1, 0),
&ObjectHandle::dictionary(vec![(
b"/Type".to_vec(),
ObjectHandle::name(b"ObjStm".to_vec()),
)]),
&context,
)?, None
);
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(99, 0),
ObjectRef::new(1, 0),
&ObjectHandle::integer(1),
&context,
)?, Some("encryption dictionary")
);
assert_eq!(
super::planned_member_body_violation(
ObjectRef::new(1, 0),
ObjectRef::new(1, 0),
&ObjectHandle::integer(1),
&context,
)?, None
);
Ok(())
}
#[test]
fn modified_streams_use_the_canonical_refilter_probe() -> crate::Result<()> {
struct PassThrough;
impl TokenFilter for PassThrough {
fn handle_token(
&mut self,
token: &Token,
output: &mut TokenFilterOutput<'_>,
) -> crate::pipeline::PipelineResult<()> {
output.write_token(token)
}
}
let mut pdf = crate::Pdf::open(std::io::Cursor::new(unfiltered_stream_probe_pdf()))?;
let stream = pdf.get_object_handle(ObjectRef::new(4, 0));
stream.try_dereference()?;
stream.add_token_filter(Rc::new(RefCell::new(PassThrough)))?;
let before = pdf.source_last_offset();
assert!(!super::canonical_stream_will_be_refiltered_with_policy(
&stream,
&WriterOptions::default(),
true,
false,
)?); assert_ne!(
pdf.source_last_offset(),
before,
"the canonical modified-stream probe must pipe once before returning false"
);
Ok(())
}
#[test]
fn qdf_content_container_formats_nested_arrays_dictionaries_and_direct_streams(
) -> crate::Result<()> {
let mut pdf = crate::Pdf::empty()?;
let indirect = pdf.make_indirect_object_handle(ObjectHandle::integer(9))?;
let indirect_ref = indirect.object_ref().expect("indirect child identity");
let stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(4))]),
Rc::new(b"q Q\n".to_vec()),
);
let container = ObjectHandle::dictionary(vec![
(
b"/Array".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(1),
ObjectHandle::dictionary(vec![
(b"/Nested".to_vec(), ObjectHandle::integer(2)),
(
b"/NestedStream".to_vec(),
ObjectHandle::stream(
ObjectHandle::dictionary(vec![(
b"/Length".to_vec(),
ObjectHandle::integer(4),
)]),
Rc::new(b"q Q\n".to_vec()),
),
),
]),
]),
),
(b"/Contents".to_vec(), stream),
(b"/Indirect".to_vec(), indirect),
(b"/Text".to_vec(), ObjectHandle::string(b"text".to_vec())),
]);
let options = WriterOptions {
qdf: true,
content_normalization: true,
newline_before_endstream: NewlineBeforeEndstream::Never,
..WriterOptions::default()
};
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_content_container_from_handle_with_qpdf_obj_gen_map(
&container,
&options,
out,
&|object_gen| {
assert_eq!(object_gen.to_object_ref(), Some(indirect_ref));
Ok(indirect_ref)
},
&BTreeSet::new(),
)
})
.expect("QDF direct content-container emission");
let text = String::from_utf8(output).unwrap();
assert!(text.starts_with("<<\n /Array [\n"));
assert!(text.contains("/Nested 2"));
assert!(text.contains("/NestedStream"));
assert!(text.contains(&format!("/Indirect {indirect_ref}")));
assert!(text.contains("/Text (text)"));
assert!(
text.contains("stream\nq Q\n\nendstream"),
"QDF direct content output: {text}"
);
assert!(text.ends_with(">>"));
Ok(())
}
#[test]
fn content_array_frames_direct_streams_nulls_removed_refs_and_uses_string_writer() {
let mut pdf = crate::Pdf::empty().expect("create content-array owner");
let removed = pdf
.make_indirect_object_handle(ObjectHandle::integer(9))
.expect("create removed content reference");
let kept = pdf
.make_indirect_object_handle(ObjectHandle::integer(8))
.expect("create mapped content reference");
let kept_ref = kept.object_ref().expect("mapped identity");
let removed_refs = [removed.object_ref().expect("removed identity")]
.into_iter()
.collect();
let stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(4))]),
Rc::new(b"data".to_vec()),
);
let container = ObjectHandle::array(vec![
ObjectHandle::string(b"secret".to_vec()),
kept,
removed,
stream,
]);
for qdf in [false, true] {
let options = WriterOptions {
qdf,
newline_before_endstream: NewlineBeforeEndstream::Never,
..WriterOptions::default()
};
let mut output = Vec::new();
let mut write_string = |out: &mut crate::writer::output::OutputSink<'_>,
value: &[u8]| {
out.write_bytes(b"<wrapped:")?;
out.write_bytes(value)?;
out.write_bytes(b">")
};
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_content_container_from_handle_with_ref_map_and_string_writer(
&container,
&options,
out,
&|object_ref| {
assert_eq!(object_ref, kept_ref);
Ok(crate::ObjectRef::new(77, 0))
},
&removed_refs,
&mut write_string,
)
})
.expect("content-array emission");
let text = String::from_utf8(output).expect("content-array output is text");
assert!(text.contains("<wrapped:secret>"));
assert!(text.contains("null"));
assert!(text.contains("stream\ndata\nendstream"));
if qdf {
assert!(text.starts_with("[\n <wrapped:secret>\n 77 0 R\n null\n"));
assert!(text.ends_with("\n]"));
} else {
assert!(text.starts_with("[ <wrapped:secret> 77 0 R null "));
assert!(text.ends_with(" ]"));
}
}
}
}
#[cfg(test)]
mod object_emitter_tests {
use super::*;
use crate::writer::object::DynamicDirectStreamWriter;
use crate::writer::NewlineBeforeEndstream;
use std::io::Cursor;
#[test]
fn live_child_discovery_uses_cursors_instead_of_container_snapshots() {
let source = include_str!("body.rs");
let dictionary_start = source
.find("fn collect_live_dictionary_children")
.expect("live dictionary child helper");
let dictionary_body = &source[dictionary_start
..source[dictionary_start..]
.find("\nfn collect_live_seed_handles")
.expect("live dictionary child helper end")
+ dictionary_start];
let child_start = source
.find("fn collect_live_child_handles")
.expect("live child discovery helper");
let child_body = &source[child_start
..source[child_start..]
.find("\nfn enqueue_object")
.expect("live child discovery helper end")
+ child_start];
assert!(
dictionary_body.contains("next_dictionary_entry_for_live_walk"),
"writer child discovery must use the live dictionary cursor"
);
assert!(
!dictionary_body.contains("try_as_dictionary()")
&& !child_body.contains("try_as_dictionary()"),
"writer child discovery must not clone a complete dictionary map"
);
assert!(
!child_body.contains("try_as_array()?"),
"writer child discovery must not clone a complete array vector"
);
}
#[test]
fn qdf_object_stream_members_discover_children_at_the_write_boundary() {
let source = include_str!("body.rs");
let start = source
.find("fn emit_live_qdf_object_stream")
.expect("live QDF object-stream emitter");
let end = start
+ source[start..]
.find("\n #[test]")
.expect("live QDF object-stream emitter end");
let body = &source[start..end];
assert!(
body.contains("unparse_object_qdf_with_dynamic_ref_map"),
"QDF ObjStm members must assign child references while serializing"
);
assert!(
!body.contains("enqueue_surviving_children(&handle_to_write)"),
"QDF ObjStm members must not pre-walk the complete value graph"
);
}
fn pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(
include_bytes!("../../../../../tests/fixtures/compat/one-page-no-ext.pdf").to_vec(),
))
.unwrap()
}
#[test]
fn prepared_stream_children_drop_decode_parms_with_scalar_crypt() {
let dictionary = ObjectHandle::dictionary(vec![
(b"/Filter".to_vec(), ObjectHandle::name(b"Crypt".to_vec())),
(
b"/DecodeParms".to_vec(),
ObjectHandle::dictionary(vec![(
b"/Name".to_vec(),
ObjectHandle::name(b"Identity".to_vec()),
)]),
),
(b"/Keep".to_vec(), ObjectHandle::integer(42)),
]);
let surviving = crate::writer::object::prepared_stream_dictionary_children(
&dictionary,
StreamDictionaryOptions::preserve(),
)
.expect("prepare surviving stream children");
assert_eq!(surviving.len(), 1);
assert_eq!(surviving[0].unparse(), b"42");
}
#[test]
fn live_queue_helpers_report_overflow_depth_missing_map_and_direct_stream_children(
) -> crate::Result<()> {
let mut queue = LiveQueue::new(BTreeSet::new(), false);
queue.next_objid = u32::MAX;
let error = queue
.reserve_output_number()
.expect_err("live queue numbering must not wrap");
assert!(
matches!(error, crate::Error::Unsupported(message) if message.contains("overflows u32"))
);
let error = collect_live_child_handles(
&ObjectHandle::null(),
&mut Vec::new(),
crate::parser::MAX_PARSE_DEPTH + 1,
)
.expect_err("emission-time child traversal must enforce the parser depth");
assert!(
matches!(error, crate::Error::Unsupported(message) if message.contains("nesting exceeds maximum"))
);
let mut pdf = pdf();
let child = pdf
.make_indirect_object_handle(ObjectHandle::integer(7))
.expect("indirect stream dictionary child");
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Child".to_vec(), child.clone())]),
Rc::new(b"data".to_vec()),
);
let mut found = Vec::new();
collect_live_child_handles(&direct_stream, &mut found, 0)
.expect("direct stream dictionary traversal");
assert_eq!(found.len(), 1);
assert!(found[0].is_same_object_as(&child));
let missing = map_queued_output(&BTreeMap::new(), &BTreeSet::new(), ObjectRef::new(7, 2))
.expect_err("an absent queued output must be diagnosed");
assert!(
matches!(missing, crate::Error::Unsupported(message) if message.contains("7 2 R absent from queue"))
);
let raw_missing = map_queued_raw_output(
&BTreeMap::new(),
&BTreeMap::new(),
&BTreeSet::new(),
QpdfObjGen::new(7, 2),
)
.expect_err("an absent raw queued output must be diagnosed");
assert!(matches!(
raw_missing,
crate::Error::Unsupported(message) if message.contains("raw reference 7 2 R absent from queue")
));
let raw_identity = QpdfObjGen::new(7, 2);
let ignored = [raw_identity].into_iter().collect();
assert_eq!(
map_queued_raw_output(&BTreeMap::new(), &BTreeMap::new(), &ignored, raw_identity,)?,
ObjectRef::new(0, 0)
);
let mut queued = BTreeMap::new();
queued.insert(ObjectRef::new(7, 2), ObjectRef::new(4, 0));
assert_eq!(
map_queued_raw_output(&BTreeMap::new(), &queued, &BTreeSet::new(), raw_identity,)?,
ObjectRef::new(4, 0)
);
let mut spaces = Vec::new();
crate::writer::output::with_buffer_sink(&mut spaces, |out| push_spaces(out, 130))
.expect("space writer handles more than one static chunk");
assert_eq!(spaces, vec![b' '; 130]);
Ok(())
}
fn plan_with_objects(objects: Vec<PlannedIndirectObject>) -> PlainWritePlan {
PlainWritePlan {
version: "1.5".to_string(),
final_extension_level: 0,
objects,
root_source: None,
root: None,
direct_root: None,
old_to_new: std::collections::HashMap::new(),
removed_refs: BTreeSet::new(),
qdf_holder_numbers: BTreeSet::new(),
trailer: crate::writer::plain::xref::TrailerPlan {
form: crate::XrefForm::Stream,
root: None,
direct_root: None,
id: crate::writer::plain::xref::IdPlan::Materialized { value: None },
structural_filtered: false,
qdf: false,
},
}
}
#[test]
fn planned_group_adapter_preserves_source_and_generated_origins_and_rejects_synthetic() {
let member = crate::writer::plain::plan::PlannedMember {
source: ObjectRef::new(2, 0),
output: ObjectRef::new(2, 0),
};
let plan = plan_with_objects(vec![
PlannedIndirectObject::Source {
source: ObjectRef::new(1, 0),
output: ObjectRef::new(1, 0),
},
PlannedIndirectObject::ObjectStream {
origin: PlannedObjectStreamOrigin::SourceBacked(ObjectRef::new(8, 0)),
output: ObjectRef::new(3, 0),
members: vec![member.clone()],
},
PlannedIndirectObject::ObjectStream {
origin: PlannedObjectStreamOrigin::Generated(ObjectRef::new(9, 0)),
output: ObjectRef::new(4, 0),
members: vec![member.clone()],
},
]);
let groups = planned_object_stream_groups(&plan).expect("adapt supported ObjStm origins");
assert!(
matches!(groups[0], object_streams::ObjectStreamGroup::SourceBacked { source, .. } if source == ObjectRef::new(8, 0))
);
assert!(
matches!(groups[1], object_streams::ObjectStreamGroup::Generated { source, .. } if source == ObjectRef::new(9, 0))
);
let synthetic = plan_with_objects(vec![PlannedIndirectObject::ObjectStream {
origin: PlannedObjectStreamOrigin::Synthetic,
output: ObjectRef::new(3, 0),
members: vec![member],
}]);
let error = planned_object_stream_groups(&synthetic)
.expect_err("the live queue cannot emit a synthetic planned ObjStm");
assert!(
matches!(error, crate::Error::Unsupported(message) if message.contains("synthetic ObjStm"))
);
}
#[test]
fn objstm_body_validation_walks_a_valid_planned_member() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let member_source = pdf.root_ref().expect("fixture Catalog");
let plan = plan_with_objects(vec![PlannedIndirectObject::ObjectStream {
origin: PlannedObjectStreamOrigin::SourceBacked(ObjectRef::new(99, 0)),
output: ObjectRef::new(2, 0),
members: vec![crate::writer::plain::plan::PlannedMember {
source: member_source,
output: ObjectRef::new(1, 0),
}],
}]);
validate_objstm_member_bodies(&mut pdf, &plan)?;
Ok(())
}
fn encryption_context() -> crate::writer::EncryptionContext {
crate::writer::EncryptionContext {
encrypt_dict: ObjectHandle::dictionary(Vec::new()),
file_key: vec![1; 5],
cipher: crate::writer::WriteCipher::PerObject(
crate::encryption::standard::ObjectKeyAlg::Rc4,
),
encryption_v: 2,
encryption_r: 3,
encrypt_ref: ObjectRef::new(0, 0),
id0: b"id".to_vec(),
static_aes_iv: true,
encrypt_metadata: true,
metadata_ref: None,
}
}
#[test]
fn direct_stream_policy_reaches_nested_dictionary_and_array_streams() -> crate::Result<()> {
let inner = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(5))]),
Rc::new(b"inner".to_vec()),
);
let outer = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(
b"/Nested".to_vec(),
ObjectHandle::array(vec![inner]),
)]),
Rc::new(b"outer".to_vec()),
);
let options = WriterOptions {
compress_streams: CompressStreams::No,
newline_before_endstream: NewlineBeforeEndstream::Yes,
..WriterOptions::default()
};
let mut direct_stream_writer = LiveDirectStreamWriter {
options: &options,
output: ObjectRef::new(7, 0),
encryption_context: None,
};
let mut map = |_handle: &ObjectHandle| Ok(ObjectRef::new(8, 0));
let mut write_string = |out: &mut OutputSink<'_>, value: &[u8]| out.write_bytes(value);
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
direct_stream_writer.write_direct_stream(
&outer,
out,
&mut map,
&BTreeSet::new(),
&mut write_string,
)
})?;
let text = String::from_utf8(output).expect("direct stream output is text");
assert!(
text.contains("inner\nendstream"),
"nested direct stream must inherit NewlineBeforeEndstream::Yes: {text:?}"
);
assert!(text.contains("outer\nendstream"));
Ok(())
}
#[test]
fn encrypted_direct_stream_policy_reaches_nested_streams() -> crate::Result<()> {
let inner = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(12))]),
Rc::new(b"inner-secret".to_vec()),
);
let outer = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(
b"/Nested".to_vec(),
ObjectHandle::dictionary(vec![(
b"/Array".to_vec(),
ObjectHandle::array(vec![inner]),
)]),
)]),
Rc::new(b"outer-secret".to_vec()),
);
let options = WriterOptions {
compress_streams: CompressStreams::No,
newline_before_endstream: NewlineBeforeEndstream::Yes,
..WriterOptions::default()
};
let context = encryption_context();
let mut direct_stream_writer = LiveDirectStreamWriter {
options: &options,
output: ObjectRef::new(7, 0),
encryption_context: Some(&context),
};
let mut map = |_handle: &ObjectHandle| Ok(ObjectRef::new(8, 0));
let mut write_string = |out: &mut OutputSink<'_>, value: &[u8]| out.write_bytes(value);
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
direct_stream_writer.write_direct_stream(
&outer,
out,
&mut map,
&BTreeSet::new(),
&mut write_string,
)
})?;
assert!(!output
.windows(b"inner-secret".len())
.any(|window| window == b"inner-secret"));
assert!(!output
.windows(b"outer-secret".len())
.any(|window| window == b"outer-secret"));
assert_eq!(
output
.windows(b"\nendstream".len())
.filter(|window| *window == b"\nendstream")
.count(),
2,
"outer and inner encrypted streams must both use the inherited framing policy"
);
Ok(())
}
#[test]
fn encrypted_live_body_covers_compact_qdf_stream_and_content_container_routes(
) -> crate::Result<()> {
for qdf in [false, true] {
let mut pdf = pdf();
let root_source = pdf.root_ref();
let stream = pdf
.new_stream_with_data(Rc::new(b"stream-data".to_vec()))
.expect("indirect encrypted stream");
stream
.as_stream_dict()
.unwrap()
.replace_key(b"/Label", ObjectHandle::string(b"stream-secret".to_vec()))
.expect("attach encrypted stream-dictionary string");
let encrypted_object =
pdf.make_indirect_from_object_handle(ObjectHandle::dictionary(vec![(
b"/Label".to_vec(),
ObjectHandle::string(b"object-secret".to_vec()),
)]))?;
pdf.root_handle()
.unwrap()
.replace_key(b"/EncryptedStream", stream)
.expect("attach encrypted stream");
pdf.root_handle()?
.replace_key(b"/EncryptedObject", encrypted_object)
.expect("attach encrypted ordinary object");
let options = WriterOptions {
qdf,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let content_stream_state = if qdf {
qdf_page_context(&mut pdf)?
} else {
crate::writer::LiveContentStreamState::default()
};
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
Some(&encryption_context()),
&BTreeSet::new(),
content_stream_state,
)
})
.expect("encrypted live body");
assert!(output
.windows(b"stream\n".len())
.any(|window| window == b"stream\n"));
assert!(!output
.windows(b"stream-secret".len())
.any(|window| window == b"stream-secret"));
assert!(!output
.windows(b"object-secret".len())
.any(|window| window == b"object-secret"));
}
let mut pdf = pdf();
let root_source = pdf.root_ref().expect("indirect Catalog");
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(10))]),
Rc::new(b"direct-raw".to_vec()),
);
let root = pdf.root_handle().unwrap();
root.replace_key(b"/Label", ObjectHandle::string(b"root-secret".to_vec()))
.expect("attach encrypted container string");
root.replace_key(b"/Contents", direct_stream)
.expect("attach direct content stream");
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&WriterOptions::default(),
"1.4",
0,
Some(root_source),
BTreeSet::new(),
&[],
Some(&encryption_context()),
&[QpdfObjGen::from_valid_object_ref_for_test(root_source)]
.into_iter()
.collect(),
crate::writer::LiveContentStreamState::default(),
)
})
.expect("encrypted live content container");
assert!(output
.windows(b"stream\ndirect-raw\nendstream".len())
.any(|window| window == b"stream\ndirect-raw\nendstream"));
assert!(!output
.windows(b"root-secret".len())
.any(|window| window == b"root-secret"));
Ok(())
}
#[test]
fn plain_live_content_normalization_gate_reads_the_raw_normalized_streams_set(
) -> crate::Result<()> {
let options = WriterOptions {
content_normalization: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
{
let mut pdf = pdf();
let stream = pdf.new_stream_with_data(Rc::new(b"q\r\nQ".to_vec()))?;
let stream_gen =
QpdfObjGen::from_valid_object_ref_for_test(stream.object_ref().unwrap());
pdf.root_handle()?
.replace_key(b"/Contents", stream)
.expect("attach indirect content stream");
let root_source = pdf.root_ref();
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState {
normalized_streams: [stream_gen].into_iter().collect(),
..Default::default()
},
)
})?;
let text = String::from_utf8_lossy(&output);
assert!(
text.contains("stream\nq\nQ"),
"normalized_streams membership alone must normalize the stream: {text}"
);
}
{
let mut pdf = pdf();
let stream = pdf.new_stream_with_data(Rc::new(b"q\r\nQ".to_vec()))?;
let stream_ref = stream.object_ref().unwrap();
pdf.root_handle()?
.replace_key(b"/Contents", stream)
.expect("attach indirect content stream");
let root_source = pdf.root_ref();
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState {
contents_sequences: [(
QpdfObjGen::from_valid_object_ref_for_test(stream_ref),
1,
)]
.into_iter()
.collect(),
..Default::default()
},
)
})?;
let text = String::from_utf8_lossy(&output);
assert!(
text.contains("stream\nq\r\nQ"),
"contents_sequences membership alone must not normalize the stream: {text}"
);
}
Ok(())
}
#[test]
fn plain_live_content_container_emits_its_direct_stream_to_the_sink() -> crate::Result<()> {
let mut pdf = pdf();
let root_source = pdf.root_ref().expect("indirect Catalog");
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(13))]),
Rc::new(b"plain-content".to_vec()),
);
pdf.root_handle()?
.replace_key(b"/Contents", direct_stream)
.expect("attach direct content stream");
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&WriterOptions::default(),
"1.4",
0,
Some(root_source),
BTreeSet::new(),
&[],
None,
&[QpdfObjGen::from_valid_object_ref_for_test(root_source)]
.into_iter()
.collect(),
crate::writer::LiveContentStreamState::default(),
)
})?;
assert!(output
.windows(b"stream\nplain-content\nendstream".len())
.any(|window| window == b"stream\nplain-content\nendstream"));
Ok(())
}
#[test]
fn qdf_live_body_emits_an_unencrypted_ordinary_object() -> crate::Result<()> {
let mut pdf = pdf();
let root_source = pdf.root_ref();
let plain_object =
pdf.make_indirect_from_object_handle(ObjectHandle::dictionary(vec![(
b"/Label".to_vec(),
ObjectHandle::string(b"qdf-object-secret".to_vec()),
)]))?;
pdf.root_handle()?
.replace_key(b"/PlainObject", plain_object)
.expect("attach QDF ordinary object");
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let mut output = Vec::new();
let content_stream_state = qdf_page_context(&mut pdf)?;
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
None,
&BTreeSet::new(),
content_stream_state,
)
})?;
let text = String::from_utf8_lossy(&output);
assert!(text.contains("/PlainObject"));
assert!(text.contains("qdf-object-secret"));
Ok(())
}
#[test]
fn qdf_live_body_reads_the_caller_supplied_page_sequence_snapshot() -> crate::Result<()> {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../../../tests/fixtures/compat/one-page.pdf").to_vec(),
))?; let root_source = pdf.root_ref();
let page_ref = PageDocumentHelper::new(&mut pdf).get_all_pages()?[0];
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let content_stream_state = crate::writer::LiveContentStreamState {
page_sequences: [(QpdfObjGen::from_valid_object_ref_for_test(page_ref), 99)]
.into_iter()
.collect(),
..Default::default()
};
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
None,
&BTreeSet::new(),
content_stream_state,
)
})?;
let text = String::from_utf8_lossy(&output);
assert!(
text.contains("%% Page 99"),
"QDF page marker must reflect the caller-supplied snapshot, not a fresh page walk: {text}"
);
Ok(())
}
#[test]
fn qdf_page_context_walks_a_real_pages_content_stream() -> crate::Result<()> {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../../../tests/fixtures/compat/one-page.pdf").to_vec(),
))?; let page_ref = ObjectRef::new(3, 0);
let content_ref = ObjectRef::new(7, 0);
assert_eq!(
PageDocumentHelper::new(&mut pdf).get_all_pages()?,
vec![page_ref]
);
let content_stream_state = qdf_page_context(&mut pdf)?;
assert_eq!(
content_stream_state
.page_sequences
.get(&QpdfObjGen::from_valid_object_ref_for_test(page_ref)),
Some(&1)
);
assert_eq!(
content_stream_state
.contents_sequences
.get(&QpdfObjGen::from_valid_object_ref_for_test(content_ref)),
Some(&1)
);
assert!(content_stream_state
.normalized_streams
.contains(&QpdfObjGen::from_valid_object_ref_for_test(content_ref)));
Ok(())
}
#[test]
fn encrypted_live_body_adjusts_aes_stream_length_before_emission() -> crate::Result<()> {
let mut pdf = pdf();
let root_source = pdf.root_ref();
let stream = pdf.new_stream_with_data(Rc::new(b"aes-stream-data".to_vec()))?;
pdf.root_handle()?
.replace_key(b"/AesStream", stream)
.expect("attach AES stream");
let mut context = encryption_context();
context.file_key = vec![1; 32];
context.cipher = crate::writer::WriteCipher::FileKeyAes256;
context.encryption_v = 5;
context.encryption_r = 6;
let options = WriterOptions {
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let mut output = Vec::new();
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.7",
3,
root_source,
BTreeSet::new(),
&[],
Some(&context),
&BTreeSet::new(),
crate::writer::LiveContentStreamState::default(),
)
})?;
assert!(!output.is_empty());
Ok(())
}
#[test]
fn live_queue_checks_owner_deduplicates_and_walks_direct_seed_containers() -> crate::Result<()>
{
let mut local_pdf = super::object_emitter_tests::pdf();
let mut foreign_pdf = super::object_emitter_tests::pdf();
let foreign = foreign_pdf
.make_indirect_object_handle(ObjectHandle::integer(1))
.unwrap();
let mut queue = LiveQueue::new(BTreeSet::new(), false);
let error = queue
.enqueue_handle(&mut local_pdf, foreign)
.expect_err("foreign live handles must be rejected");
assert!(error.to_string().contains("different QPDF"));
let child = local_pdf
.make_indirect_object_handle(ObjectHandle::integer(42))
.unwrap();
let child_ref = child.object_ref().unwrap();
let mut removed_queue = LiveQueue::new([child_ref].into_iter().collect(), false);
assert_eq!(
removed_queue.enqueue_handle(&mut local_pdf, child.clone())?,
None
);
let output_ref = queue.enqueue_handle(&mut local_pdf, child.clone())?;
assert_eq!(output_ref, Some(ObjectRef::new(1, 0)));
assert_eq!(
queue.enqueue_handle(&mut local_pdf, child.clone())?,
output_ref
);
assert_eq!(
queue.pop().and_then(|handle| handle.object_ref()),
Some(child_ref)
);
assert!(queue.pop().is_none());
let direct_array = ObjectHandle::array(vec![child.clone(), ObjectHandle::null()]);
let mut seeds = Vec::new();
collect_live_seed_handles(&direct_array, &mut seeds, 0)?;
assert_eq!(seeds.len(), 1);
assert!(seeds[0].is_same_object_as(&child));
let direct_dictionary = ObjectHandle::dictionary(vec![
(b"/Child".to_vec(), child.clone()),
(b"/Null".to_vec(), ObjectHandle::null()),
]);
seeds.clear();
collect_live_seed_handles(&direct_dictionary, &mut seeds, 0)?;
assert_eq!(seeds.len(), 1);
assert!(seeds[0].is_same_object_as(&child));
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Child".to_vec(), child.clone())]),
Rc::new(b"seed".to_vec()),
);
seeds.clear();
collect_live_seed_handles(&direct_stream, &mut seeds, 0)?;
assert_eq!(seeds.len(), 1);
assert!(seeds[0].is_same_object_as(&child));
local_pdf
.trailer()
.replace_key(b"/DecodeParms", ObjectHandle::integer(1))?;
let root_source = local_pdf.root_ref();
let options = WriterOptions::default();
let mut bytes = Vec::new();
crate::writer::output::with_buffer_sink(&mut bytes, |out| {
emit_live(
&mut local_pdf,
out,
&options,
"1.4",
0,
root_source,
BTreeSet::new(),
&[],
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState::default(),
)
})?; assert!(!bytes.is_empty());
Ok(())
}
#[test]
fn preserve_queue_orders_raw_generation_handles_after_mapped_handles() -> crate::Result<()> {
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 /Pages 2 0 R >>\nendobj\n");
let pages_offset = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
let orphan_offset = bytes.len();
bytes.extend_from_slice(b"5 65536 obj\n45\nendobj\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(format!("{pages_offset:010} 00000 n \n").as_bytes());
bytes.extend_from_slice(b"0000000000 00000 f \n0000000000 00000 f \n");
bytes.extend_from_slice(format!("{orphan_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(),
);
let mut pdf = Pdf::open(Cursor::new(bytes))?;
pdf.set_writer_object_order(BTreeMap::new());
let options = WriterOptions {
preserve_unreferenced_objects: true,
..WriterOptions::default()
};
let queue = initialize_live_queue(&mut pdf, &options, BTreeSet::new(), &[])?;
assert!(queue
.raw_old_to_new
.contains_key(&QpdfObjGen::new(5, 65_536)));
Ok(())
}
#[test]
fn enqueue_ignores_an_object_stream_that_contains_itself() -> crate::Result<()> {
let container = ObjectRef::new(5, 0);
let mut pdf = super::object_emitter_tests::pdf();
let mut queue = LiveQueue::new(BTreeSet::new(), false);
queue.register_object_streams(
&pdf,
&[object_streams::ObjectStreamGroup::SourceBacked {
source: container,
members: vec![container],
}],
)?;
let handle = pdf.get_object_handle(container);
assert_eq!(queue.enqueue_handle(&mut pdf, handle)?, None);
assert!(queue.old_to_new.is_empty());
let other = ObjectRef::new(6, 0);
let mut queue = LiveQueue::new(BTreeSet::new(), false);
queue.register_object_streams(
&pdf,
&[
object_streams::ObjectStreamGroup::SourceBacked {
source: container,
members: vec![other],
},
object_streams::ObjectStreamGroup::SourceBacked {
source: other,
members: vec![container],
},
],
)?; let handle = pdf.get_object_handle(container);
assert_eq!(queue.enqueue_handle(&mut pdf, handle)?, None);
assert!(queue.old_to_new.is_empty());
Ok(())
}
#[test]
fn register_object_streams_skips_a_group_whose_members_are_all_removed() -> crate::Result<()> {
let pdf = super::object_emitter_tests::pdf();
let source = ObjectRef::new(3, 0);
let member = ObjectRef::new(2, 0);
let mut queue = LiveQueue::new([member].into_iter().collect(), false);
queue.register_object_streams(
&pdf,
&[object_streams::ObjectStreamGroup::SourceBacked {
source,
members: vec![member],
}],
)?; assert!(queue.member_to_container.is_empty());
assert!(queue.container_to_members.is_empty());
Ok(())
}
#[test]
fn removed_source_container_still_numbers_retained_members() -> crate::Result<()> {
let container = ObjectRef::new(3, 0);
let member = ObjectRef::new(2, 0);
let mut pdf = super::object_emitter_tests::pdf();
let mut queue = LiveQueue::new([container].into_iter().collect(), false);
queue.register_object_streams(
&pdf,
&[object_streams::ObjectStreamGroup::SourceBacked {
source: container,
members: vec![member],
}],
)?;
let handle = pdf.get_object_handle(container);
let output = queue
.enqueue_handle(&mut pdf, handle)?
.expect("qpdf enqueues a removed ObjStm container");
assert_eq!(output, ObjectRef::new(1, 0));
assert_eq!(
queue.old_to_new.get(&container),
Some(&ObjectRef::new(1, 0))
);
assert_eq!(queue.old_to_new.get(&member), Some(&ObjectRef::new(2, 0)));
Ok(())
}
#[test]
fn generated_members_reserve_numbers_when_the_container_is_enqueued() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let first = pdf.make_indirect_object_handle(ObjectHandle::integer(1))?;
let second = pdf.make_indirect_object_handle(ObjectHandle::integer(2))?;
let first_ref = first.object_ref().unwrap();
let second_ref = second.object_ref().unwrap();
let container = pdf.make_indirect_object_handle(ObjectHandle::null())?;
let container_ref = container.object_ref().unwrap();
let mut queue = LiveQueue::new(BTreeSet::new(), false);
queue.register_object_streams(
&pdf,
&[object_streams::ObjectStreamGroup::Generated {
source: container_ref,
members: vec![second_ref, first_ref],
}],
)?;
assert_eq!(
queue.enqueue_handle(&mut pdf, first)?,
Some(ObjectRef::new(2, 0))
);
assert_eq!(
queue.old_to_new.get(&container_ref),
Some(&ObjectRef::new(1, 0))
);
assert_eq!(
queue.old_to_new.get(&first_ref),
Some(&ObjectRef::new(2, 0))
);
assert_eq!(
queue.old_to_new.get(&second_ref),
Some(&ObjectRef::new(3, 0))
);
Ok(())
}
#[test]
fn qdf_queue_reserves_a_length_holder_after_each_stream() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let old_xref = pdf.new_stream_with_data(Rc::new(b"old xref".to_vec()))?;
old_xref
.as_stream_dict()
.unwrap()
.replace_key(b"/Type", ObjectHandle::name(b"XRef".to_vec()))?;
let stream = pdf.new_stream_with_data(Rc::new(b"stream".to_vec()))?;
let stream_ref = stream.object_ref().unwrap();
let scalar = pdf.make_indirect_object_handle(ObjectHandle::integer(42))?;
let scalar_ref = scalar.object_ref().unwrap();
let mut queue = LiveQueue::new(BTreeSet::new(), true);
assert_eq!(queue.enqueue_handle(&mut pdf, old_xref)?, None);
assert_eq!(
queue.enqueue_handle(&mut pdf, stream)?,
Some(ObjectRef::new(1, 0))
);
assert_eq!(
queue.stream_length_holders.get(&stream_ref),
Some(&ObjectRef::new(2, 0))
);
assert_eq!(
queue.enqueue_handle(&mut pdf, scalar)?,
Some(ObjectRef::new(3, 0))
);
assert_eq!(
queue.old_to_new.get(&scalar_ref),
Some(&ObjectRef::new(3, 0))
);
Ok(())
}
#[test]
fn live_object_stream_with_a_non_stream_source_omits_extends() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let source = pdf.make_indirect_from_object_handle(ObjectHandle::null())?;
let source_id = source.object_ref().unwrap();
let member = pdf.make_indirect_from_object_handle(ObjectHandle::integer(42))?;
let member_id = member.object_ref().unwrap();
pdf.root_handle()?.replace_key(b"/Member", member)?;
let root_source = pdf.root_ref();
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: source_id,
members: vec![member_id],
}];
let options = WriterOptions::default();
let mut bytes = Vec::new();
crate::writer::output::with_buffer_sink(&mut bytes, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
root_source,
BTreeSet::new(),
&object_streams,
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState::default(),
)
})?; assert!(bytes
.windows(b"/Type /ObjStm".len())
.any(|window| window == b"/Type /ObjStm"));
assert!(!bytes
.windows(b"/Extends".len())
.any(|window| window == b"/Extends"));
Ok(())
}
#[test]
fn live_object_stream_extends_an_unreferenced_predecessor_through_live_enqueue(
) -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let predecessor = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let predecessor_id = predecessor.object_ref().unwrap();
let source = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let source_id = source.object_ref().unwrap();
source
.as_stream_dict()
.unwrap()
.replace_key(b"/Extends", predecessor)?;
let member = pdf.make_indirect_from_object_handle(ObjectHandle::integer(7))?;
let member_id = member.object_ref().unwrap();
pdf.root_handle()?.replace_key(b"/Member", member)?;
let root_source = pdf.root_ref();
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: source_id,
members: vec![member_id],
}];
let options = WriterOptions::default();
let mut bytes = Vec::new();
let body = crate::writer::output::with_buffer_sink(&mut bytes, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
root_source,
BTreeSet::new(),
&object_streams,
None,
&BTreeSet::new(),
crate::writer::LiveContentStreamState::default(),
)
})?; let predecessor_output = body
.old_to_new
.get(&predecessor_id)
.expect("an unreferenced /Extends predecessor is still discovered and numbered");
let expected = format!("/Extends {} 0 R", predecessor_output.number);
assert!(bytes
.windows(expected.len())
.any(|window| window == expected.as_bytes()));
Ok(())
}
#[test]
fn live_qdf_object_stream_covers_plain_and_encrypted_members_with_extends() -> crate::Result<()>
{
for encrypted in [false, true] {
let mut pdf = super::object_emitter_tests::pdf();
let predecessor = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let source = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
source
.as_stream_dict()
.unwrap()
.replace_key(b"/Extends", predecessor)?;
let member = pdf.make_indirect_from_object_handle(ObjectHandle::dictionary(vec![(
b"/Secret".to_vec(),
ObjectHandle::string(b"qdf-member-secret".to_vec()),
)]))?;
let member_ref = member.object_ref().unwrap();
pdf.root_handle()?.replace_key(b"/Member", member)?;
let root_source = pdf.root_ref();
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: source.object_ref().unwrap(),
members: vec![member_ref],
}];
pdf.set_writer_object_order(std::collections::BTreeMap::from([(
member_ref,
crate::pdf::WriterObjectOrderKey::foreign_with_allocation_identity(
member_ref,
ObjectRef::new(12, 1),
),
)]));
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let context = encryption_context();
let mut bytes = Vec::new();
let content_stream_state = qdf_page_context(&mut pdf)?;
crate::writer::output::with_buffer_sink(&mut bytes, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
root_source,
BTreeSet::new(),
&object_streams,
encrypted.then_some(&context),
&BTreeSet::new(),
content_stream_state,
)
})?;
let text = String::from_utf8_lossy(&bytes);
assert!(text.contains("/Type /ObjStm"));
assert!(text.contains("/Extends"));
assert!(text.contains("endstream"));
if encrypted {
assert!(!text.contains("qdf-member-secret"));
} else {
assert!(text.contains("%% Object stream: object"));
assert!(text.contains("/Secret (qdf-member-secret)"));
}
if !encrypted {
assert!(
text.contains("original object ID: 12 1"),
"QDF object-stream output: {text}"
);
}
}
Ok(())
}
#[test]
fn live_qdf_object_stream_rewrites_a_catalog_member_with_adbe_extensions() -> crate::Result<()>
{
let mut pdf = super::object_emitter_tests::pdf();
let root_source = pdf.root_ref().expect("fixture Catalog");
let container = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: container.object_ref().expect("ObjStm source identity"),
members: vec![root_source],
}];
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let mut bytes = Vec::new();
let content_stream_state = qdf_page_context(&mut pdf)?;
crate::writer::output::with_buffer_sink(&mut bytes, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
Some(root_source),
BTreeSet::new(),
&object_streams,
None,
&BTreeSet::new(),
content_stream_state,
)
})?;
let text = String::from_utf8_lossy(&bytes);
assert!(text.contains("/Type /ObjStm"));
assert!(text.contains("/Type /Catalog"));
assert!(text.contains("endstream"));
Ok(())
}
#[test]
fn live_qdf_object_stream_rewrites_a_stream_member_as_null() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let container = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let member = pdf.new_stream_with_data(Rc::new(b"stream-member".to_vec()))?;
let member_ref = member.object_ref().expect("stream member identity");
pdf.root_handle()?.replace_key(b"/Member", member)?;
let root_source = pdf.root_ref();
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: container.object_ref().expect("container identity"),
members: vec![member_ref],
}];
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let mut output = Vec::new();
let content_stream_state = qdf_page_context(&mut pdf)?;
crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
root_source,
BTreeSet::new(),
&object_streams,
None,
&BTreeSet::new(),
content_stream_state,
)
})?;
let text = String::from_utf8_lossy(&output);
assert!(text.contains("%% Object stream: object"));
assert!(text.contains("null\n"));
Ok(())
}
#[test]
fn live_qdf_object_stream_rejects_a_removed_extends_target() -> crate::Result<()> {
let mut pdf = super::object_emitter_tests::pdf();
let predecessor = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
let predecessor_ref = predecessor.object_ref().expect("predecessor identity");
let container = pdf.new_stream_with_data(Rc::new(Vec::new()))?;
container
.as_stream_dict()
.expect("container dictionary")
.replace_key(b"/Extends", predecessor)
.expect("attach removed predecessor");
let member = pdf.make_indirect_from_object_handle(ObjectHandle::integer(7))?;
let member_ref = member.object_ref().expect("member identity");
pdf.root_handle()?.replace_key(b"/Member", member)?;
let root_source = pdf.root_ref();
let object_streams = [object_streams::ObjectStreamGroup::SourceBacked {
source: container.object_ref().expect("container identity"),
members: vec![member_ref],
}];
let options = WriterOptions {
qdf: true,
compress_streams: CompressStreams::No,
..WriterOptions::default()
};
let mut output = Vec::new();
let content_stream_state = qdf_page_context(&mut pdf)?;
let result = crate::writer::output::with_buffer_sink(&mut output, |out| {
emit_live(
&mut pdf,
out,
&options,
"1.5",
0,
root_source,
[predecessor_ref].into_iter().collect(),
&object_streams,
None,
&BTreeSet::new(),
content_stream_state,
)
});
let error = match result {
Ok(_) => panic!("a removed QDF /Extends target must be rejected"), Err(error) => error,
};
assert!(error.to_string().contains("QDF object-stream /Extends"));
Ok(())
}
}