use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use std::rc::Rc;
use crate::writer::object_streams;
use crate::writer::plain::plan::{PlainWritePlan, PlannedIndirectObject};
use crate::writer::plain::xref::{BodyLayout, CompressedLocation};
use crate::writer::WriterOptions;
use crate::writer::{serialize, CompressStreams, ObjectWriterEmission, QPDF_BINARY_MARKER};
use crate::{ObjectHandle, ObjectRef, Pdf};
pub(crate) fn emit_bodies<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
plan: &PlainWritePlan,
) -> crate::Result<(Vec<u8>, BodyLayout)> {
validate_objstm_member_bodies(pdf, plan)?;
let mut bytes = Vec::new();
bytes.extend_from_slice(format!("%PDF-{}\n", plan.version).as_bytes());
bytes.extend_from_slice(QPDF_BINARY_MARKER);
let mut layout = BodyLayout::default();
for planned in &plan.objects {
match planned {
PlannedIndirectObject::Source { source, output } => {
let offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", output.number, output.generation).as_bytes(),
);
emit_source_from_handle(pdf, options, plan, *source, &mut bytes)?;
bytes.extend_from_slice(b"\nendobj\n");
layout
.uncompressed
.insert(output.number, (output.generation, offset));
crate::writer::report_progress_event(options)?;
}
PlannedIndirectObject::ObjectStream {
origin,
output,
members,
} => {
let mut handles = Vec::with_capacity(members.len());
for member in members {
let handle = pdf.get_object_handle(member.source);
pdf.resolve(&handle)?;
handles.push((member.output, handle));
}
let map = |object_ref| {
plan.new_for_original(object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain writer: reference {} {} R absent from renumber map",
object_ref.number, object_ref.generation
))
})
};
let body = object_streams::emit_objstm_body_from_handles_with_writer(
&handles,
&mut |out, _member_index, _member_ref, handle| {
let result = handle.write_object_with_ref_map_and_removed(
out,
&map,
&plan.removed_refs,
);
if result.is_ok() {
crate::writer::report_progress_event(options)?;
}
result
},
)?;
let offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", output.number, output.generation).as_bytes(),
);
let structural_compress = if plan.trailer.structural_filtered {
CompressStreams::Yes
} else {
CompressStreams::No
};
let extends = match origin {
crate::writer::plain::plan::PlannedObjectStreamOrigin::SourceBacked(source) => {
let source_handle = pdf.get_object_handle(*source);
pdf.resolve(&source_handle)?;
if let Some(source_dict) = source_handle.as_stream_dict() {
let extends = source_dict.try_get_key(b"/Extends")?;
match extends.object_ref() {
Some(extends) => Some(
plan.old_to_new.get(&extends).copied().ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain writer: source ObjStm /Extends {} {} R is absent from renumber map",
extends.number, extends.generation
))
})?,
),
_ => None,
}
} else {
None
}
}
crate::writer::plain::plan::PlannedObjectStreamOrigin::Synthetic => None,
};
serialize::write_objstm_stream_with_extends(
&mut bytes,
&body,
structural_compress,
options.newline_before_endstream,
extends,
)?; bytes.extend_from_slice(b"\nendobj\n");
layout
.uncompressed
.insert(output.number, (output.generation, offset));
for (index, member) in members.iter().enumerate() {
layout.compressed.insert(
member.output.number,
CompressedLocation {
container: output.number,
index: u32::try_from(index).unwrap_or(u32::MAX),
},
);
}
}
}
}
Ok((bytes, layout))
}
fn emit_source_from_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
plan: &PlainWritePlan,
source: crate::ObjectRef,
bytes: &mut Vec<u8>,
) -> crate::Result<()> {
let handle = pdf.get_object_handle(source);
pdf.resolve(&handle)?;
let map = |object_ref| {
plan.new_for_original(object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"plain writer: reference {} {} R absent from renumber map",
object_ref.number, object_ref.generation
))
})
};
if handle.as_stream_dict().is_some() {
let cached = if let Some(cached) = plan.cached_stream_outputs.get(&source) {
if cached.fingerprint == crate::writer::plain::plan::stream_cache_fingerprint(&handle)?
{
Some(cached)
} else {
None
}
} else {
None };
let (dict, data, refiltered) = if let Some(cached) = cached {
(cached.dict.clone(), cached.data.clone(), cached.refiltered)
} else {
canonical_stream_output(&handle, options)?
};
dict.write_stream_body_with_ref_map_and_removed(
bytes,
refiltered,
&map,
&plan.removed_refs,
)?; serialize::write_stream_payload(bytes, &data, options.newline_before_endstream);
} else {
handle.write_object_with_ref_map_and_removed(bytes, &map, &plan.removed_refs)?;
}
Ok(())
}
pub(crate) fn canonical_stream_output(
handle: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<(ObjectHandle, Vec<u8>, bool)> {
let (dict, data, refiltered, _) =
canonical_stream_output_with_status(handle, options, true, false)?;
Ok((dict, data, refiltered))
}
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>, bool, bool)> {
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>, bool)> {
let (dict, data, refiltered, _) =
canonical_stream_output_for_rewrite_with_status(handle, options, normalize_content)?;
Ok((dict, data, refiltered))
}
pub(crate) fn canonical_stream_output_for_rewrite_with_status(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, bool, bool)> {
canonical_stream_output_with_status(handle, options, true, normalize_content)
}
pub(crate) fn emit_content_container_from_handle_with_ref_map(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut Vec<u8>,
map: &dyn Fn(ObjectRef) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<ObjectRef>,
) -> crate::Result<()> {
let mut write_string = |out: &mut Vec<u8>, value: &[u8]| {
crate::pdf_syntax::write_string_value(out, value);
Ok(())
};
emit_content_container_from_handle_with_ref_map_and_string_writer(
container,
options,
out,
map,
removed_refs,
&mut write_string,
)
}
pub(crate) fn emit_content_container_from_handle_with_ref_map_and_string_writer<F>(
container: &ObjectHandle,
options: &WriterOptions,
out: &mut Vec<u8>,
map: &dyn Fn(ObjectRef) -> crate::Result<ObjectRef>,
removed_refs: &BTreeSet<ObjectRef>,
write_string: &mut F,
) -> crate::Result<()>
where
F: FnMut(&mut Vec<u8>, &[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;
fn normalize_content_container(
container: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<ObjectHandle> {
container.try_dereference()?;
if let Some(entries) = container.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.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> {
stacker::maybe_grow(
CONTENT_EMIT_STACK_RED_ZONE,
CONTENT_EMIT_STACK_GROWTH_SIZE,
|| {
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.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<'a, F>
where
F: FnMut(&mut Vec<u8>, &[u8]) -> crate::Result<()>,
{
qdf: bool,
out: &'a mut Vec<u8>,
map: &'a dyn Fn(ObjectRef) -> crate::Result<ObjectRef>,
removed_refs: &'a BTreeSet<ObjectRef>,
write_string: &'a mut F,
}
impl<F> ContentEmitter<'_, F>
where
F: FnMut(&mut Vec<u8>, &[u8]) -> crate::Result<()>,
{
fn emit_value(&mut self, value: &ObjectHandle, root: bool, indent: usize) -> crate::Result<()> {
stacker::maybe_grow(
CONTENT_EMIT_STACK_RED_ZONE,
CONTENT_EMIT_STACK_GROWTH_SIZE,
|| {
if !root {
if let Some(object_ref) = value.object_ref() {
if object_ref.number == 0 || self.removed_refs.contains(&object_ref) {
self.out.extend_from_slice(b"null");
} else {
self.out
.extend_from_slice((self.map)(object_ref)?.to_string().as_bytes());
}
return Ok(());
}
}
value.try_dereference()?;
if value.as_stream_dict().is_some() {
return self.emit_direct_stream(value, indent);
}
if root {
if value.as_array().is_some() && has_direct_stream_in_value(value)? {
let items = value.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.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.as_array() {
return self.emit_array(&items, indent);
}
if let Some(entries) = value.as_dictionary() {
return self.emit_dictionary(&entries, indent);
} }
if self.qdf {
value.write_object_qdf_with_ref_map_and_removed_with_string_writer(
self.out,
indent,
self.map,
self.removed_refs,
self.write_string,
)
} else {
value.write_object_with_ref_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.extend_from_slice(b"[\n");
for item in items {
push_spaces(self.out, indent + 2);
self.emit_value(item, false, indent + 2)?;
self.out.push(b'\n');
}
push_spaces(self.out, indent);
self.out.push(b']');
} else {
self.out.push(b'[');
for item in items {
self.out.push(b' ');
self.emit_value(item, false, indent)?;
}
self.out.extend_from_slice(b" ]");
}
Ok(())
}
fn emit_dictionary(
&mut self,
entries: &BTreeMap<Vec<u8>, ObjectHandle>,
indent: usize,
) -> crate::Result<()> {
if self.qdf {
self.out.extend_from_slice(b"<<\n");
} else {
self.out.extend_from_slice(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.push(b' ');
}
write_content_key(self.out, key);
self.out.push(b' ');
self.emit_value(value, false, indent + 2)?; if self.qdf {
self.out.push(b'\n');
}
}
if self.qdf {
push_spaces(self.out, indent);
self.out.extend_from_slice(b">>");
} else {
self.out.extend_from_slice(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.write_object_qdf_with_ref_map_and_removed_with_string_writer(
self.out,
indent,
self.map,
self.removed_refs,
self.write_string,
)?; } else {
dict.write_object_with_ref_map_and_removed_with_string_writer(
self.out,
self.map,
self.removed_refs,
self.write_string,
)?; }
self.out.extend_from_slice(b"\nstream\n");
self.out
.extend_from_slice(stream.get_raw_stream_data()?.as_ref());
self.out.extend_from_slice(b"\nendstream");
Ok(())
}
}
fn has_direct_stream_in_value(value: &ObjectHandle) -> crate::Result<bool> {
stacker::maybe_grow(
CONTENT_EMIT_STACK_RED_ZONE,
CONTENT_EMIT_STACK_GROWTH_SIZE,
|| {
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.as_array() {
for item in items {
if has_direct_stream_in_value(&item)? {
return Ok(true);
}
}
} else if let Some(entries) = value.as_dictionary() {
for (_, child) in entries {
if has_direct_stream_in_value(&child)? {
return Ok(true);
} }
}
Ok(false)
},
)
}
fn is_removed_content_reference(value: &ObjectHandle, removed_refs: &BTreeSet<ObjectRef>) -> bool {
value
.object_ref()
.is_some_and(|object_ref| removed_refs.contains(&object_ref))
}
fn write_content_key(out: &mut Vec<u8>, key: &[u8]) {
out.push(b'/');
let key = key.strip_prefix(b"/").unwrap_or(key);
crate::pdf_syntax::write_name_escaped(out, key);
}
fn push_spaces(out: &mut Vec<u8>, count: usize) {
out.resize(out.len().saturating_add(count), b' ');
}
pub(crate) fn canonical_stream_output_for_linearization(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, bool)> {
let (dict, data, refiltered, _) =
canonical_stream_output_for_linearization_with_status(handle, options, normalize_content)?;
Ok((dict, data, refiltered))
}
pub(crate) fn canonical_stream_output_for_linearization_with_status(
handle: &ObjectHandle,
options: &WriterOptions,
normalize_content: bool,
) -> crate::Result<(ObjectHandle, Vec<u8>, bool, bool)> {
canonical_stream_output_with_status(handle, options, true, normalize_content)
}
pub(crate) fn canonical_stream_will_be_refiltered(
handle: &ObjectHandle,
options: &WriterOptions,
) -> crate::Result<bool> {
canonical_stream_will_be_refiltered_with_policy(handle, options, true, false)
}
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> {
if handle.is_data_modified() {
return Ok(false);
}
let Some((encode_flags, decode_level, _normalized_content)) = canonical_stream_filter_plan(
handle,
options,
apply_full_rewrite_metadata_policy,
normalize_content,
)?
else {
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,
true,
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>, bool, bool)> {
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)) = filter_plan {
let mut attempt = 1_u8;
let (data, filtering_attempted) = loop {
let mut buffer =
crate::pipeline::buffer::Buffer::new("canonical writer stream", None);
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 = source_for_pipe
.pipe_stream_data(
&mut buffer,
&mut filtering_attempted,
attempt_encode_flags,
attempt_decode_level,
false,
attempt == 1,
)
.map_err(|error| stream_data_error(&source_for_pipe, error))?;
if success || attempt == 2 {
break (
buffer.take_buffer()?.to_vec(),
filtering_attempted && success,
);
}
attempt = 2;
};
(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 mut entries = stream_dict.try_as_dictionary()?.unwrap_or_default();
entries.remove(b"/Length".as_slice());
if !filtering_attempted {
remove_crypt_filter_for_unfiltered_stream(&mut entries)?;
}
if filtering_attempted {
entries.retain(|key, _| {
!matches!(
key.as_slice(),
b"/Filter" | b"/DecodeParms" | b"/F" | b"/FFilter" | b"/FDecodeParms"
)
});
if matches!(policy, Some(CompressStreams::Yes)) && !normalized_content {
entries.insert(
b"/Filter".to_vec(),
ObjectHandle::name(b"FlateDecode".to_vec()),
);
}
}
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());
let refiltered =
filtering_attempted && matches!(policy, Some(CompressStreams::Yes)) && !normalized_content;
Ok((dict, data, refiltered, filtering_attempted))
}
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()?.to_vec())
}
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)>> {
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
&& !stream_dict.try_has_key(b"/F")?;
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;
}
Ok(Some((encode_flags, decode_level, normalized_content)))
}
fn remove_crypt_filter_for_unfiltered_stream(
entries: &mut std::collections::BTreeMap<Vec<u8>, ObjectHandle>,
) -> crate::Result<()> {
let Some(filter) = entries.get(b"/Filter".as_slice()).cloned() else {
return Ok(());
};
if filter.try_is_name_and_equals(b"Crypt")? {
entries.remove(b"/Filter".as_slice());
entries.remove(b"/DecodeParms".as_slice());
return Ok(());
}
let Some(filters) = filter.try_as_array()? else {
return Ok(());
};
let mut crypt_index = None;
for (index, item) in filters.iter().enumerate() {
if item.try_is_name_and_equals(b"Crypt")? {
crypt_index = Some(index);
break;
}
}
let Some(crypt_index) = crypt_index else {
return Ok(());
};
let mut remaining_filters = filters;
remaining_filters.remove(crypt_index);
entries.insert(b"/Filter".to_vec(), ObjectHandle::array(remaining_filters));
let Some(decode_parms) = entries.get(b"/DecodeParms".as_slice()).cloned() else {
return Ok(());
};
let Some(mut decode_items) = decode_parms.try_as_array()? else {
return Ok(());
};
if decode_items.len() > crypt_index {
decode_items.remove(crypt_index);
entries.insert(b"/DecodeParms".to_vec(), ObjectHandle::array(decode_items));
}
Ok(())
}
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)
}
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);
pdf.resolve(&member_handle)?;
let is_signature = object_streams::is_qpdf_signature_dict(pdf, &member_handle)?;
let violation = planned_member_body_violation(
member.source,
member.output,
&member_handle,
&context,
)? .or(is_signature.then_some("signature dictionary"));
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(())
}
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 object.try_is_dictionary_of_type(b"XRef", b"")? {
return Ok(Some("/Type /XRef dictionary"));
}
if object.try_is_dictionary_of_type(b"ObjStm", b"")? {
return Ok(Some("/Type /ObjStm dictionary"));
}
if context.encryption_ref == Some(source) {
return Ok(Some("encryption dictionary"));
}
Ok(None)
}
#[cfg(test)]
mod final_handle_tests {
use super::emit_content_container_from_handle_with_ref_map;
use crate::writer::{NewlineBeforeEndstream, WriterOptions};
use crate::ObjectHandle;
use std::collections::BTreeSet;
use std::rc::Rc;
#[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();
emit_content_container_from_handle_with_ref_map(
&container,
&options,
&mut output,
&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" }));
}
}