use super::show::{
read_h_generic, read_h_page_offset, read_h_shared_object, read_hint_offsets, HGeneric,
HPageOffset, HSharedObject, ShowLinearizationError,
};
use crate::optimization::{ObjectUser, Optimization};
use crate::{DecodeLevel, ObjectHandle, ObjectRef, PageDocumentHelper, Pdf, Result, XrefEntry};
use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
use std::io::{BufReader, Read, Seek};
use std::rc::Rc;
#[derive(Debug)]
pub enum LinearizationCheckError {
NotLinearized,
InvalidParam { message: String },
QpdfExc(crate::QpdfExc),
Io(Box<dyn std::error::Error + Send + Sync>),
}
impl fmt::Display for LinearizationCheckError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
LinearizationCheckError::NotLinearized => {
write!(
f,
"not a linearized PDF: the first object in the file has no /Linearized key"
)
}
LinearizationCheckError::InvalidParam { message } => {
write!(f, "linearization check failed: {message}")
}
LinearizationCheckError::QpdfExc(error) => error.fmt(f),
LinearizationCheckError::Io(e) => write!(f, "I/O error: {e}"),
}
}
}
impl std::error::Error for LinearizationCheckError {}
impl From<crate::Error> for LinearizationCheckError {
fn from(e: crate::Error) -> Self {
match e {
crate::Error::QpdfExc(error) => LinearizationCheckError::QpdfExc(error),
other => LinearizationCheckError::Io(Box::new(other)),
}
}
}
impl From<std::io::Error> for LinearizationCheckError {
fn from(e: std::io::Error) -> Self {
LinearizationCheckError::Io(Box::new(e))
}
}
pub type CheckResult = std::result::Result<(), LinearizationCheckError>;
impl<R: Read + Seek> Pdf<R> {
pub fn is_linearized(&mut self) -> Result<bool> {
let Some(object_ref) = self.linearization_candidate_ref()? else {
return Ok(false);
};
let candidate = self.get_object_handle(object_ref);
let Some(dictionary) = candidate.try_as_dictionary()? else {
return Ok(false);
};
let Some(linearized) = dictionary.get(&b"/Linearized"[..]) else {
return Ok(false);
};
linearized.try_dereference()?;
let value = if let Some(value) = linearized.try_as_integer()? {
value as f64
} else if let Some(value) = linearized.as_real() {
value
} else {
return Ok(false);
};
if !value.is_finite() || value.floor() != 1.0 {
return Ok(false);
}
if let Some(l_value) = dictionary.get(&b"/L"[..]) {
l_value.try_dereference()?;
if let Some(l_value) = l_value.try_as_integer()? {
let file_size = self.resolver.source_length()?;
if l_value < 0 || l_value as u64 != file_size {
return Ok(false);
}
}
}
Ok(true)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum LinearizationParameterCheck {
Clean,
Warning(&'static str),
Error {
object: &'static str,
message: &'static str,
},
}
pub(crate) fn check_linearization_parameters<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> Result<LinearizationParameterCheck> {
let Some(object_ref) = pdf.linearization_candidate_ref()? else {
return Ok(LinearizationParameterCheck::Clean); };
let candidate = pdf.get_object_handle(object_ref);
if !candidate.try_is_dictionary()? {
return Ok(LinearizationParameterCheck::Clean);
}
let h = candidate.try_get_key(b"/H")?;
let o = candidate.try_get_key(b"/O")?;
let e = candidate.try_get_key(b"/E")?;
let n = candidate.try_get_key(b"/N")?;
let t = candidate.try_get_key(b"/T")?;
let p = candidate.try_get_key(b"/P")?;
let h_is_array = resolved_is_array(&h)?;
let o_is_integer = resolved_is_integer(&o)?;
let e_is_integer = resolved_is_integer(&e)?;
let n_is_integer = resolved_is_integer(&n)?;
let t_is_integer = resolved_is_integer(&t)?;
let p_is_valid = {
p.try_dereference()?;
p.try_is_null()? || p.try_as_integer()?.is_some()
};
if !(h_is_array && o_is_integer && e_is_integer && n_is_integer && t_is_integer && p_is_valid) {
return Ok(LinearizationParameterCheck::Error {
object: "linearization dictionary",
message: "some keys in linearization dictionary are of the wrong type",
});
}
let pages = PageDocumentHelper::new(pdf).get_all_pages()?;
let page_count = pages.len() as i64;
if n.try_as_integer()? != Some(page_count) {
return Ok(LinearizationParameterCheck::Error {
object: "linearization hint table",
message: "/N does not match number of pages",
});
}
let Some(first_page) = pages.first() else {
return Ok(LinearizationParameterCheck::Clean);
};
if o.try_as_integer()? != Some(first_page.number as i64) {
return Ok(LinearizationParameterCheck::Warning(
"first page object (/O) mismatch",
));
}
Ok(LinearizationParameterCheck::Clean)
}
fn resolved_is_array(handle: &ObjectHandle) -> Result<bool> {
handle.try_is_array()
}
fn resolved_is_integer(handle: &ObjectHandle) -> Result<bool> {
Ok(handle.try_as_integer()?.is_some())
}
macro_rules! fail {
($($arg:tt)*) => {
return Err(LinearizationCheckError::InvalidParam {
message: format!($($arg)*),
})
};
}
fn as_u64(obj: &ObjectHandle, key: &str) -> std::result::Result<u64, LinearizationCheckError> {
match obj
.try_as_integer()
.map_err(LinearizationCheckError::from)?
{
Some(n) if n >= 0 => Ok(n as u64),
_ => {
let type_name = obj.type_name().map_err(LinearizationCheckError::from)?;
Err(LinearizationCheckError::InvalidParam {
message: format!("/{key} is not a non-negative integer (got {type_name})"),
})
}
}
}
fn map_show_error(error: ShowLinearizationError) -> LinearizationCheckError {
match error {
ShowLinearizationError::Malformed { message } => {
LinearizationCheckError::InvalidParam { message }
}
ShowLinearizationError::Io(error) => LinearizationCheckError::Io(error),
}
}
fn is_pdf_whitespace(b: u8) -> bool {
matches!(b, b'\0' | b'\t' | b'\n' | b'\x0c' | b'\r' | b' ')
}
const OPEN_DOCUMENT_ROOT_KEYS: [&[u8]; 5] = [
b"ViewerPreferences",
b"PageMode",
b"Threads",
b"OpenAction",
b"AcroForm",
];
fn is_open_document_user(user: &ObjectUser) -> bool {
match user {
ObjectUser::TrailerKey(key) => key == b"Encrypt",
ObjectUser::RootKey(key) => OPEN_DOCUMENT_ROOT_KEYS.contains(&key.as_slice()),
_ => false,
}
}
fn first_page_source_extent<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<(i64, i64)> {
let mut object_stream_data = BTreeMap::new();
for (object_ref, entry) in pdf.get_xref_table() {
if let XrefEntry::Compressed { stream, .. } = entry {
object_stream_data.insert(object_ref.number, stream);
}
}
let optimization =
Optimization::optimize(pdf, &object_stream_data, false, |_, _stream| Ok(0u8))?;
let outlines_in_first_page = {
let mut use_outlines_with_outlines = false;
let root = pdf.root_handle()?;
root.try_dereference()?;
if let Some(root_dict) = root.try_as_dictionary()? {
let page_mode = root_dict.get(b"/PageMode" as &[u8]).cloned();
let use_outlines = if let Some(page_mode) = page_mode {
page_mode.try_as_name()?.as_deref() == Some(b"UseOutlines")
} else {
false
};
if use_outlines {
use_outlines_with_outlines = root_dict.contains_key(b"/Outlines" as &[u8]);
}
} use_outlines_with_outlines
};
let mut max_end_before_space = -1_i64;
let mut max_end_after_space = -1_i64;
for (object_ref, users) in optimization.object_users() {
let is_root = users.contains(&ObjectUser::Root);
let in_outlines = users
.iter()
.any(|user| matches!(user, ObjectUser::RootKey(key) if key == b"Outlines"));
let in_open_document = users.iter().any(is_open_document_user);
let in_first_page = users.contains(&ObjectUser::Page(0));
let in_part6 = if is_root {
false
} else if in_outlines {
outlines_in_first_page
} else if in_open_document {
false
} else {
in_first_page
};
if !in_part6 {
continue;
}
let object = pdf.get_object_handle(object_ref);
object.try_dereference()?;
let (end_before_space, end_after_space) = object.end_offsets();
if end_before_space < 0 || end_after_space < 0 {
continue;
}
max_end_before_space = max_end_before_space.max(end_before_space);
max_end_after_space = max_end_after_space.max(end_after_space);
}
Ok((max_end_before_space, max_end_after_space))
}
struct ComputedHintData {
optimization: Optimization,
page_object_counts: Vec<u32>,
page_shared_objects: Vec<Vec<ObjectRef>>,
part8_objects: Vec<ObjectRef>,
outline_root: Option<ObjectRef>,
outline_objects: BTreeSet<ObjectRef>,
}
fn uncompressed_object_ref(
object_ref: ObjectRef,
xref: &BTreeMap<ObjectRef, XrefEntry>,
) -> ObjectRef {
match xref.get(&object_ref) {
Some(XrefEntry::Compressed { stream, .. }) => ObjectRef::new(*stream, 0),
_ => object_ref,
}
}
fn root_outlines_ref<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Option<ObjectRef>> {
let root = pdf.root_handle()?;
let outlines = root.try_get_key(b"/Outlines")?;
Ok(outlines.object_ref())
}
fn outlines_in_first_page<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<bool> {
let root = pdf.root_handle()?;
let page_mode = root.try_get_key(b"/PageMode")?;
page_mode.try_dereference()?;
let outlines = root.try_get_key(b"/Outlines")?;
outlines.try_dereference()?;
let has_outlines = !outlines.try_is_null()?;
Ok(page_mode.try_as_name()?.as_deref() == Some(b"UseOutlines") && has_outlines)
}
fn compute_hint_data<R: Read + Seek>(
pdf: &mut Pdf<R>,
pages: &[ObjectRef],
) -> Result<ComputedHintData> {
let xref = pdf.get_xref_table();
let mut object_stream_data = BTreeMap::new();
for (object_ref, entry) in &xref {
if let XrefEntry::Compressed { stream, .. } = entry {
object_stream_data.insert(object_ref.number, *stream);
}
}
let optimization = Optimization::optimize(pdf, &object_stream_data, false, |_, _| Ok(0u8))?;
let mut first_page_private = BTreeSet::new();
let mut first_page_shared = BTreeSet::new();
let mut other_page_private = BTreeSet::new();
let mut other_page_shared = BTreeSet::new();
let mut outline_objects = BTreeSet::new();
for (object_ref, users) in optimization.object_users() {
let mut in_first_page = false;
let mut other_pages = 0_u32;
let mut thumbs = 0_u32;
let mut others = 0_u32;
let mut in_open_document = false;
let mut in_outlines = false;
let mut is_root = false;
for user in users {
match user {
ObjectUser::Page(page) if *page == 0 => in_first_page = true,
ObjectUser::Page(_) => other_pages += 1,
ObjectUser::Thumbnail(_) => thumbs += 1,
ObjectUser::TrailerKey(key) if key == b"Encrypt" => in_open_document = true,
ObjectUser::TrailerKey(_) => others += 1,
ObjectUser::RootKey(key) if key == b"Outlines" => in_outlines = true,
ObjectUser::RootKey(key) if OPEN_DOCUMENT_ROOT_KEYS.contains(&key.as_slice()) => {
in_open_document = true
}
ObjectUser::RootKey(_) => others += 1,
ObjectUser::Root => is_root = true,
}
}
if is_root {
continue;
}
if in_outlines {
outline_objects.insert(object_ref);
} else if in_open_document {
continue;
} else if in_first_page && others == 0 && other_pages == 0 && thumbs == 0 {
first_page_private.insert(object_ref);
} else if in_first_page {
first_page_shared.insert(object_ref);
} else if other_pages == 1 && others == 0 && thumbs == 0 {
other_page_private.insert(object_ref);
} else if other_pages > 1 {
other_page_shared.insert(object_ref);
}
}
let first_page = pages.first().copied().ok_or_else(|| {
crate::Error::Unsupported("no pages found while calculating hint data".to_owned())
})?;
let first_page = uncompressed_object_ref(first_page, &xref);
first_page_private.remove(&first_page);
let outline_root =
root_outlines_ref(pdf)?.map(|object_ref| uncompressed_object_ref(object_ref, &xref));
let mut ordered_outlines = Vec::with_capacity(outline_objects.len());
if let Some(outline_root) = outline_root {
if outline_objects.remove(&outline_root) {
ordered_outlines.push(outline_root);
}
}
ordered_outlines.extend(outline_objects.iter().copied());
let mut part6_objects = Vec::new();
part6_objects.push(first_page);
part6_objects.extend(first_page_private.iter().copied());
part6_objects.extend(first_page_shared.iter().copied());
if outlines_in_first_page(pdf)? {
part6_objects.extend(ordered_outlines.iter().copied());
}
let mut page_object_counts = Vec::with_capacity(pages.len());
page_object_counts.push(part6_objects.len() as u32);
for (page_number, page_ref) in pages.iter().enumerate().skip(1) {
let page_object = uncompressed_object_ref(*page_ref, &xref);
let private_count = optimization
.objects_for(&ObjectUser::Page(page_number as u32))
.filter(|object_ref| {
*object_ref != page_object && other_page_private.contains(object_ref)
})
.count();
page_object_counts.push((private_count + 1) as u32);
}
let part8_objects: Vec<ObjectRef> = other_page_shared.into_iter().collect();
let shared_object_numbers: BTreeSet<u32> = part6_objects
.iter()
.chain(&part8_objects)
.map(|r| r.number)
.collect();
let mut page_shared_objects = Vec::with_capacity(pages.len());
page_shared_objects.push(Vec::new());
for page_number in 1..pages.len() {
let shared = optimization
.objects_for(&ObjectUser::Page(page_number as u32))
.filter(|object_ref| {
optimization.users_for(*object_ref).len() > 1
&& shared_object_numbers.contains(&object_ref.number)
})
.collect();
page_shared_objects.push(shared);
}
Ok(ComputedHintData {
optimization,
page_object_counts,
page_shared_objects,
part8_objects,
outline_root,
outline_objects: ordered_outlines.into_iter().collect(),
})
}
fn hint_warning(
collect_soft_warnings: bool,
warnings: &mut Vec<String>,
message: impl Into<String>,
) -> std::result::Result<(), LinearizationCheckError> {
let message = message.into();
if collect_soft_warnings {
warnings.push(message);
Ok(())
} else {
Err(LinearizationCheckError::InvalidParam { message })
}
}
fn adjusted_hint_offset(offset: u64, h_offset: u64, h_length: u64) -> u64 {
if offset >= h_offset {
offset.wrapping_add(h_length)
} else {
offset
}
}
fn linearization_offset(
xref: &BTreeMap<ObjectRef, XrefEntry>,
object_ref: ObjectRef,
seen: &mut BTreeSet<ObjectRef>,
) -> std::result::Result<u64, LinearizationCheckError> {
if !seen.insert(object_ref) {
return Err(LinearizationCheckError::InvalidParam {
message: format!("xref object-stream chain cycles at {object_ref}"),
});
}
let result = match xref.get(&object_ref).copied() {
Some(XrefEntry::Uncompressed { offset }) => Ok(offset),
Some(XrefEntry::Compressed { stream, .. }) => {
linearization_offset(xref, ObjectRef::new(stream, 0), seen)
}
Some(XrefEntry::Free { .. }) | None => Err(LinearizationCheckError::InvalidParam {
message: format!("no usable xref table entry for {object_ref}"),
}),
};
seen.remove(&object_ref);
result
}
fn length_next_n<R: Read + Seek>(
pdf: &mut Pdf<R>,
xref: &BTreeMap<ObjectRef, XrefEntry>,
first_object: u32,
nobjects: u64,
file_len: u64,
collect_soft_warnings: bool,
warnings: &mut Vec<String>,
) -> std::result::Result<i128, LinearizationCheckError> {
let bound = file_len.min(xref.len() as u64 + 1_000_000);
if nobjects > bound {
return Err(LinearizationCheckError::InvalidParam {
message: format!("hint table object count {nobjects} exceeds bound {bound}"),
});
}
let mut length = 0_i128;
for index in 0..nobjects {
let index = u32::try_from(index).map_err(|_| {
LinearizationCheckError::InvalidParam {
message: format!("object sequence starting at {first_object} overflows u32"),
}
})?; let object_number = first_object.checked_add(index).ok_or_else(|| {
LinearizationCheckError::InvalidParam {
message: format!("object sequence starting at {first_object} overflows u32"),
}
})?;
let object_ref = ObjectRef::new(object_number, 0);
if !xref.contains_key(&object_ref) {
hint_warning(
collect_soft_warnings,
warnings,
format!("no xref table entry for {object_number} 0"),
)?; continue;
}
let mut seen = BTreeSet::new();
let offset = linearization_offset(xref, object_ref, &mut seen)?;
let object = pdf.get_object_handle(object_ref);
object
.try_dereference()
.map_err(LinearizationCheckError::from)?;
let (_, end_after_space) = object.end_offsets();
if end_after_space < 0 {
return Err(LinearizationCheckError::InvalidParam {
message: format!("object {object_ref} has no source extent"),
});
}
length += i128::from(end_after_space) - i128::from(offset);
}
Ok(length)
}
struct HintTableCheckInput<'a> {
page_hints: &'a HPageOffset,
shared_hints: &'a HSharedObject,
outline_hints: Option<&'a HGeneric>,
h_offset: u64,
h_length: u64,
file_len: u64,
collect_soft_warnings: bool,
warnings: &'a mut Vec<String>,
}
fn check_hint_tables<R: Read + Seek>(
pdf: &mut Pdf<R>,
pages: &[ObjectRef],
input: HintTableCheckInput<'_>,
) -> std::result::Result<(), LinearizationCheckError> {
let HintTableCheckInput {
page_hints,
shared_hints,
outline_hints,
h_offset,
h_length,
file_len,
collect_soft_warnings,
warnings,
} = input;
let computed = compute_hint_data(pdf, pages).map_err(LinearizationCheckError::from)?;
let xref = pdf.get_xref_table();
if page_hints.entries.len() != pages.len() {
return Err(LinearizationCheckError::InvalidParam {
message: format!(
"page offset hint table has {} entries but the document has {} pages",
page_hints.entries.len(),
pages.len()
),
});
}
let mut shared_idx_to_obj = BTreeMap::new();
let first_page = pages[0];
if shared_hints.nshared_total < shared_hints.nshared_first_page {
hint_warning(
collect_soft_warnings,
warnings,
"shared object hint table: ntotal < nfirst_page",
)?; } else {
let mut current_object = first_page.number;
for index in 0..shared_hints.nshared_total as usize {
if index == shared_hints.nshared_first_page as usize {
let first_shared_obj =
u32::try_from(shared_hints.first_shared_obj).map_err(|_| {
LinearizationCheckError::InvalidParam {
message: "first shared object number does not fit in u32".to_owned(),
}
})?;
if let Some(first_part8) = computed.part8_objects.first() {
if first_shared_obj != first_part8.number {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"first shared object number mismatch: hint table = {}; computed = {}",
shared_hints.first_shared_obj, first_part8.number
),
)?; }
} else {
hint_warning(
collect_soft_warnings,
warnings,
"part 8 is empty but nshared_total > nshared_first_page",
)?; }
current_object = first_shared_obj;
let object_ref = ObjectRef::new(current_object, 0);
let mut seen = BTreeSet::new();
if !computed.part8_objects.is_empty() {
let computed_offset = linearization_offset(&xref, object_ref, &mut seen)?;
let hint_offset =
adjusted_hint_offset(shared_hints.first_shared_offset, h_offset, h_length);
if computed_offset != hint_offset {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"first shared object offset mismatch: hint table = {hint_offset}; computed = {computed_offset}"
),
)?; }
}
}
let entry = shared_hints.entries.get(index).ok_or_else(|| {
LinearizationCheckError::InvalidParam {
message: format!("shared object hint table is missing entry {index}"),
}
})?;
let nobjects = entry.nobjects_minus_one.checked_add(1).ok_or_else(|| {
LinearizationCheckError::InvalidParam {
message: format!("shared object {index} object count overflows"),
}
})?;
let nobjects_u32 =
u32::try_from(nobjects).map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("shared object {index} object count does not fit in u32"),
})?;
let computed_length = length_next_n(
pdf,
&xref,
current_object,
nobjects,
file_len,
collect_soft_warnings,
warnings,
)?; let hint_length =
i128::from(shared_hints.min_group_length) + i128::from(entry.delta_group_length);
if computed_length != hint_length {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"shared object {index} length mismatch: hint table = {hint_length}; computed = {computed_length}"
),
)?;
}
shared_idx_to_obj.insert(index as u64, current_object);
current_object = current_object.checked_add(nobjects_u32).ok_or_else(|| {
LinearizationCheckError::InvalidParam {
message: format!("shared object {index} sequence overflows u32"),
}
})?;
}
}
let mut seen = BTreeSet::new();
let computed_first_page_offset = linearization_offset(&xref, first_page, &mut seen)?;
let hint_first_page_offset =
adjusted_hint_offset(page_hints.first_page_offset, h_offset, h_length);
if hint_first_page_offset != computed_first_page_offset {
hint_warning(
collect_soft_warnings,
warnings,
"first page object offset mismatch",
)?;
}
for (page_number, (entry, &computed_count)) in page_hints
.entries
.iter()
.zip(&computed.page_object_counts)
.enumerate()
{
let hint_count = page_hints
.min_nobjects
.checked_add(u32::try_from(entry.delta_nobjects).map_err(|_| {
LinearizationCheckError::InvalidParam {
message: format!("page {page_number} object count does not fit in u32"),
}
})?)
.ok_or_else(|| LinearizationCheckError::InvalidParam {
message: format!("page {page_number} object count overflows"),
})?;
if hint_count != computed_count {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"object count mismatch for page {page_number}: hint table = {hint_count}; computed = {computed_count}"
),
)?; }
let first_object = pages[page_number].number;
let computed_length = length_next_n(
pdf,
&xref,
first_object,
hint_count as u64,
file_len,
collect_soft_warnings,
warnings,
)?; let hint_length =
i128::from(page_hints.min_page_length) + i128::from(entry.delta_page_length);
if computed_length != hint_length {
let mut seen = BTreeSet::new();
let offset = linearization_offset(&xref, pages[page_number], &mut seen)?;
hint_warning(
collect_soft_warnings,
warnings,
format!(
"page length mismatch for page {page_number}: hint table = {hint_length}; computed length = {computed_length} (offset = {offset})"
),
)?; }
let mut hint_shared = BTreeSet::new();
for identifier in &entry.shared_identifiers {
let Some(object_number) = shared_idx_to_obj.get(identifier) else {
return Err(LinearizationCheckError::InvalidParam {
message: format!(
"unable to get object for item {identifier} in shared objects hint table"
),
});
};
hint_shared.insert(*object_number);
}
let computed_shared: BTreeSet<u32> = computed.page_shared_objects[page_number]
.iter()
.map(|object_ref| object_ref.number)
.collect();
if page_number == 0 && entry.nshared_objects > 0 {
hint_warning(
collect_soft_warnings,
warnings,
"page 0 has shared identifier entries",
)?; }
for object_number in hint_shared.difference(&computed_shared) {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"page {page_number}: shared object {object_number}: in hint table but not computed list"
),
)?; }
for object_number in computed_shared.difference(&hint_shared) {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"page {page_number}: shared object {object_number}: in computed list but not hint table"
),
)?; }
}
let computed_outline_count = computed.outline_objects.len() as u32;
let outline_hint = outline_hints.cloned().unwrap_or(HGeneric {
first_object: 0,
first_object_offset: 0,
nobjects: 0,
group_length: 0,
});
if computed_outline_count == outline_hint.nobjects {
if computed_outline_count != 0 {
let Some(computed_outline_root) = computed.outline_root else {
return Err(LinearizationCheckError::InvalidParam {
message:
"outline objects are present but the root /Outlines reference is missing"
.to_owned(),
});
};
if u64::from(computed_outline_root.number) == outline_hint.first_object {
let mut seen = BTreeSet::new();
let computed_offset =
linearization_offset(&xref, computed_outline_root, &mut seen)?;
let mut max_end = 0_i64;
for object_ref in computed.optimization.objects_for_root_key(b"Outlines") {
let object = pdf.get_object_handle(object_ref);
object
.try_dereference()
.map_err(LinearizationCheckError::from)?;
max_end = max_end.max(object.end_offsets().1);
}
if max_end < 0 {
return Err(LinearizationCheckError::InvalidParam {
message: "outline objects have no source extent".to_owned(),
});
}
let hint_offset =
adjusted_hint_offset(outline_hint.first_object_offset, h_offset, h_length);
if computed_offset != hint_offset {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"incorrect offset in outlines table: hint table = {hint_offset}; computed = {computed_offset}"
),
)?; }
let computed_length = i128::from(max_end) - i128::from(computed_offset);
if computed_length != i128::from(outline_hint.group_length) {
hint_warning(
collect_soft_warnings,
warnings,
format!(
"incorrect length in outlines table: hint table = {}; computed = {computed_length}",
outline_hint.group_length
),
)?; }
} else {
hint_warning(
collect_soft_warnings,
warnings,
"incorrect first object number in outline hints table.",
)?; }
}
} else {
hint_warning(
collect_soft_warnings,
warnings,
"incorrect object count in outline hint table",
)?; }
Ok(())
}
pub fn check_linearization<R: Read + Seek>(pdf: &mut Pdf<R>, file_bytes: &[u8]) -> CheckResult {
check_linearization_inner(pdf, file_bytes, false, false, None).map(|_| ())
}
pub(crate) fn check_linearization_warnings<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
skip_first_page_warning: bool,
) -> std::result::Result<Vec<String>, LinearizationCheckError> {
check_linearization_inner(pdf, file_bytes, true, skip_first_page_warning, None)
}
pub(crate) fn check_linearization_warnings_with_hint_data<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
skip_first_page_warning: bool,
hint_dict: &ObjectHandle,
hint_bytes: &[u8],
) -> std::result::Result<Vec<String>, LinearizationCheckError> {
check_linearization_inner(
pdf,
file_bytes,
true,
skip_first_page_warning,
Some((hint_dict, hint_bytes)),
)
}
fn check_linearization_inner<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
collect_soft_warnings: bool,
skip_first_page_warning: bool,
preloaded_hint: Option<(&ObjectHandle, &[u8])>,
) -> std::result::Result<Vec<String>, LinearizationCheckError> {
let file_len = file_bytes.len() as u64;
let mut warnings = Vec::new();
if !pdf.is_linearized().map_err(LinearizationCheckError::from)? {
return Err(LinearizationCheckError::NotLinearized);
}
let first_obj_ref = pdf
.linearization_candidate_ref()
.map_err(LinearizationCheckError::from)?
.ok_or(LinearizationCheckError::NotLinearized)?;
let first_obj = pdf.get_object_handle(first_obj_ref);
if !first_obj
.try_is_dictionary()
.map_err(LinearizationCheckError::from)?
{
return Err(LinearizationCheckError::NotLinearized);
}
let n_obj = first_obj
.try_get_key(b"/N")
.map_err(LinearizationCheckError::from)?;
let n_val = as_u64(&n_obj, "N")?;
let pages = PageDocumentHelper::new(pdf)
.get_all_pages()
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?;
let page_count = pages.len() as u64;
if n_val != page_count {
fail!("/N ({n_val}) does not match page count ({page_count})");
}
let o_obj = first_obj
.try_get_key(b"/O")
.map_err(LinearizationCheckError::from)?;
if !skip_first_page_warning {
let o_num = as_u64(&o_obj, "O")?;
let o_num_u32 =
u32::try_from(o_num).map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("/O ({o_num}) does not fit in u32 — invalid object number"),
})?;
let o_ref = ObjectRef::new(o_num_u32, 0);
let o_object = pdf.get_object_handle(o_ref);
let is_null = o_object
.try_is_null()
.map_err(LinearizationCheckError::from)?;
if !o_object
.try_is_dictionary()
.map_err(LinearizationCheckError::from)?
{
if is_null {
fail!("/O ({o_num}) refers to a non-existent object");
}
fail!("/O ({o_num}) does not refer to a dictionary");
}
let type_obj = o_object
.try_get_key(b"/Type")
.map_err(LinearizationCheckError::from)?;
type_obj
.try_dereference()
.map_err(LinearizationCheckError::from)?;
if let Some(type_name) = type_obj
.try_as_name()
.map_err(LinearizationCheckError::from)?
{
if type_name != b"Page" {
fail!(
"/O ({o_num}) points to an object with /Type /{} instead of /Page",
String::from_utf8_lossy(&type_name)
);
}
} else if type_obj
.try_is_null()
.map_err(LinearizationCheckError::from)?
{
let parent = o_object
.try_get_key(b"/Parent")
.map_err(LinearizationCheckError::from)?;
let media_box = o_object
.try_get_key(b"/MediaBox")
.map_err(LinearizationCheckError::from)?;
if parent
.try_is_null()
.map_err(LinearizationCheckError::from)?
&& media_box
.try_is_null()
.map_err(LinearizationCheckError::from)?
{
fail!(
"/O ({o_num}) points to a dictionary with no /Type, /Parent or /MediaBox \
— does not look like a Page object"
);
} }
let Some(first_page_ref) = pages.first().copied() else {
fail!("/O ({o_num}) cannot be checked because the document has no pages");
};
if first_page_ref.number as u64 != o_num {
if collect_soft_warnings {
warnings.push("first page object (/O) mismatch".to_owned());
} else {
fail!(
"/O ({o_num}) does not match the first page object ({})",
first_page_ref.number
);
}
}
}
let p_obj = first_obj
.try_get_key(b"/P")
.map_err(LinearizationCheckError::from)?;
p_obj
.try_dereference()
.map_err(LinearizationCheckError::from)?;
if !p_obj.try_is_null().map_err(LinearizationCheckError::from)?
&& p_obj
.try_as_integer()
.map_err(LinearizationCheckError::from)?
.is_none()
{
fail!("/P is present but is neither an integer nor null");
}
let h_obj = first_obj
.try_get_key(b"/H")
.map_err(LinearizationCheckError::from)?;
h_obj
.try_dereference()
.map_err(LinearizationCheckError::from)?;
let Some(h_items) = h_obj
.try_as_array()
.map_err(LinearizationCheckError::from)?
else {
fail!("/H is missing or has unexpected format (expected [offset length])");
};
if !matches!(h_items.len(), 2 | 4) {
fail!("linearization dictionary: H has the wrong number of items");
}
for (index, item) in h_items.iter().enumerate() {
let _ = as_u64(item, &format!("H[{index}]"))?;
}
let h_offset = as_u64(&h_items[0], "H[0]")?;
let h_length = as_u64(&h_items[1], "H[1]")?;
let mut load_checked_hint = |index: usize,
offset: u64,
length: u64|
-> std::result::Result<_, LinearizationCheckError> {
if offset >= file_len {
fail!("/H[{index}] offset ({offset}) is beyond file length ({file_len})");
}
let end = offset
.checked_add(length)
.ok_or_else(|| LinearizationCheckError::InvalidParam {
message: format!("/H[{index}] offset plus length overflows"),
})?;
if end > file_len {
fail!(
"/H[{index}] offset plus length ({offset}+{length}) extends beyond file length ({file_len})"
);
}
let offset = usize::try_from(offset)
.map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("/H[{index}] offset ({offset}) does not fit in platform usize"),
})?;
load_hint_stream(pdf, file_bytes, offset, length).map_err(|error| match error {
crate::Error::Unsupported(message) => LinearizationCheckError::InvalidParam { message },
error => LinearizationCheckError::Io(Box::new(error)), })
};
let (hint_dict, hint_bytes) = if let Some((hint_dict, hint_bytes)) = preloaded_hint {
(hint_dict.clone(), hint_bytes.to_vec())
} else {
let (hint_dict, primary_decompressed) = load_checked_hint(0, h_offset, h_length)?;
let mut hint_bytes = (*primary_decompressed).clone();
if h_items.len() == 4 {
let overflow_offset = as_u64(&h_items[2], "H[2]")?;
let overflow_length = as_u64(&h_items[3], "H[3]")?;
if overflow_offset != 0 {
let (_overflow_dict, overflow_decompressed) =
load_checked_hint(2, overflow_offset, overflow_length)?;
hint_bytes.extend_from_slice(&overflow_decompressed);
} }
(hint_dict, hint_bytes)
};
let (shared_offset, outline_offset) = read_hint_offsets(&hint_dict).map_err(map_show_error)?;
if shared_offset >= hint_bytes.len() {
let offset = pdf.source_last_offset();
return Err(LinearizationCheckError::QpdfExc(crate::QpdfExc::new(
crate::QpdfErrorCode::DamagedPdf,
pdf.input_description(),
b"linearization hint table",
i64::try_from(offset).unwrap_or(i64::MAX),
b"/S (shared object) offset is out of bounds",
)));
}
let n_pages = u32::try_from(n_val).map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("/N ({n_val}) does not fit in u32"),
})?;
let page_hints = read_h_page_offset(&hint_bytes, n_pages).map_err(map_show_error)?;
let shared_hints =
read_h_shared_object(&hint_bytes[shared_offset..]).map_err(map_show_error)?;
let outline_hints = match outline_offset {
Some(offset) => {
if offset >= hint_bytes.len() {
fail!("linearization hint table: /O (outline) offset is out of bounds");
}
Some(read_h_generic(&hint_bytes[offset..]).map_err(map_show_error)?)
}
None => None,
};
let t_obj = first_obj
.try_get_key(b"/T")
.map_err(LinearizationCheckError::from)?;
let t_val = as_u64(&t_obj, "T")?;
let mut file_cursor = t_val;
if t_val < file_bytes.len() as u64 {
let mut cursor = t_val as usize;
while cursor < file_bytes.len() && is_pdf_whitespace(file_bytes[cursor]) {
cursor += 1;
}
file_cursor = cursor as u64;
}
let computed = pdf.first_xref_item_offset();
if file_cursor != computed {
let message = format!(
"space before first xref item (/T) mismatch (computed = {computed}; file = {file_cursor}"
);
if collect_soft_warnings {
warnings.push(message);
} else {
fail!("/T ({t_val}) does not match the first xref item offset ({computed})");
}
}
if pdf.uncompressed_after_compressed() {
let message =
"linearized file contains an uncompressed object after a compressed one in a cross-reference stream"
.to_string();
if collect_soft_warnings {
warnings.push(message);
} else {
fail!("{message}");
}
}
let e_obj = first_obj
.try_get_key(b"/E")
.map_err(LinearizationCheckError::from)?;
let e_val = as_u64(&e_obj, "E")?;
if e_val >= file_len {
fail!("/E ({e_val}) must be less than file length ({file_len})");
}
let (min_e, max_e) = first_page_source_extent(pdf).map_err(LinearizationCheckError::from)?;
if min_e >= 0 && max_e >= 0 {
let min_e = min_e as u64;
let max_e = max_e as u64;
if e_val < min_e || e_val > max_e {
if collect_soft_warnings {
warnings.push(format!(
"end of first page section (/E) mismatch: /E = {e_val}; computed = {min_e}..{max_e}"
));
} else {
fail!(
"/E ({e_val}) does not match the part-6 source extent range ({min_e}..{max_e})"
);
}
}
}
check_hint_tables(
pdf,
&pages,
HintTableCheckInput {
page_hints: &page_hints,
shared_hints: &shared_hints,
outline_hints: outline_hints.as_ref(),
h_offset,
h_length,
file_len,
collect_soft_warnings,
warnings: &mut warnings,
},
)?;
Ok(warnings)
}
pub(crate) struct HintStreamDamage {
pub(crate) object: &'static str,
pub(crate) offset: u64,
pub(crate) detail: String,
legacy: String,
}
impl HintStreamDamage {
fn new(
object: &'static str,
offset: u64,
detail: impl Into<String>,
legacy: impl Into<String>,
) -> Self {
Self {
object,
offset,
detail: detail.into(),
legacy: legacy.into(),
}
}
}
pub(crate) enum HintStreamLoadError {
Damage(HintStreamDamage),
Core(crate::Error),
}
impl From<crate::Error> for HintStreamLoadError {
fn from(error: crate::Error) -> Self {
Self::Core(error)
}
}
pub(crate) fn load_hint_stream<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
offset: usize,
expected_h_length: u64,
) -> Result<(ObjectHandle, Rc<Vec<u8>>)> {
load_hint_stream_with_damage(pdf, file_bytes, offset, expected_h_length).map_err(|error| {
match error {
HintStreamLoadError::Damage(damage) => crate::Error::Unsupported(damage.legacy),
HintStreamLoadError::Core(error) => error,
}
})
}
pub(crate) fn load_hint_stream_with_damage<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
offset: usize,
expected_h_length: u64,
) -> std::result::Result<(ObjectHandle, Rc<Vec<u8>>), HintStreamLoadError> {
const SCAN_WINDOW: usize = 64;
if offset >= file_bytes.len() {
return Err(HintStreamLoadError::Damage(HintStreamDamage::new(
"linearization hint stream",
offset as u64,
"expected n n obj",
format!(
"/H[0] offset ({offset}) is beyond file length ({})",
file_bytes.len()
),
)));
}
let scan_end = offset.saturating_add(SCAN_WINDOW).min(file_bytes.len());
let window = &file_bytes[offset..scan_end];
let Some((obj_num, obj_gen)) = parse_obj_header_at(window) else {
return Err(HintStreamLoadError::Damage(HintStreamDamage::new(
"linearization hint stream",
offset as u64,
"expected n n obj",
format!(
"/H[0] offset ({offset}) does not point at an indirect object header \
(expected `N G obj`)"
),
)));
};
let hint_ref = ObjectRef::new(obj_num, obj_gen);
let (hint_obj, hint_object_damage_offset) = pdf.resolve_at_offset_with_description(
offset as u64,
hint_ref,
b"linearization hint stream",
)?;
let Some(hint_dict) = hint_obj.as_stream_dict() else {
if hint_obj.try_is_null()? {
return Err(HintStreamLoadError::Damage(HintStreamDamage::new(
"linearization dictionary",
hint_object_damage_offset.unwrap_or_else(|| pdf.source_last_offset()), "hint table is not a stream",
format!(
"hint stream object {obj_num} {obj_gen} (at /H[0] offset {offset}) does not exist"
),
)));
}
return Err(HintStreamLoadError::Damage(HintStreamDamage::new(
"linearization dictionary",
hint_object_damage_offset.unwrap_or_else(|| pdf.source_last_offset()),
"hint table is not a stream",
format!(
"hint stream object {obj_num} {obj_gen} (at /H[0] offset {offset}) is not a stream"
),
)));
};
let (mut end_before_space, mut end_after_space) = hint_obj.end_offsets();
let length_obj = hint_dict.try_get_key(b"/Length")?;
if length_obj.object_ref().is_some() {
length_obj.try_dereference()?;
(end_before_space, end_after_space) = length_obj.end_offsets();
}
if end_before_space < 0 || end_after_space < 0 {
return Err(HintStreamLoadError::Core(crate::Error::Unsupported(
format!("hint stream object {obj_num} {obj_gen} has no source extent"),
)));
}
let expected_h_length_usize = usize::try_from(expected_h_length).map_err(|_| {
crate::Error::Unsupported(format!(
"/H[1] ({expected_h_length}) does not fit in platform usize"
))
})?;
let computed_end = offset.checked_add(expected_h_length_usize).ok_or_else(|| {
crate::Error::Unsupported(format!(
"/H[0] ({offset}) plus /H[1] ({expected_h_length}) overflows"
))
})?;
if end_before_space >= 0
&& end_after_space >= 0
&& (i64::try_from(computed_end).unwrap_or(i64::MAX) < end_before_space
|| i64::try_from(computed_end).unwrap_or(i64::MAX) > end_after_space)
{
return Err(HintStreamLoadError::Damage(HintStreamDamage::new(
"linearization dictionary",
pdf.source_last_offset(),
"hint table length mismatch",
format!(
"/H[1] ({expected_h_length}) does not match hint stream object span \
{end_before_space}..{end_after_space} from offset {offset}"
),
)));
}
let decoded = hint_obj.get_stream_data(DecodeLevel::Specialized)?;
Ok((hint_dict, decoded))
}
fn parse_obj_header_at(window: &[u8]) -> Option<(u32, u16)> {
let mut i = 0;
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
let num_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == num_start {
return None;
}
let obj_num: u32 = std::str::from_utf8(&window[num_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_pdf_whitespace(window[i]) {
return None;
}
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
let gen_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == gen_start {
return None;
}
let obj_gen: u16 = std::str::from_utf8(&window[gen_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_pdf_whitespace(window[i]) {
return None;
}
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
if window.get(i..i + 3) != Some(b"obj") {
return None;
}
i += 3;
match window.get(i) {
None => {}
Some(&b) if is_pdf_whitespace(b) => {}
_ => return None,
}
Some((obj_num, obj_gen))
}
#[cfg(test)]
pub(crate) fn add_overflow_hint_items_for_test(mut bytes: Vec<u8>) -> Vec<u8> {
fn token_range(bytes: &[u8], mut cursor: usize) -> (usize, usize) {
while cursor < bytes.len() && is_pdf_whitespace(bytes[cursor]) {
cursor += 1;
}
let start = cursor;
while cursor < bytes.len() && !is_pdf_whitespace(bytes[cursor]) && bytes[cursor] != b']' {
cursor += 1;
}
(start, cursor)
}
let h_key = b"/H [";
let h_key_start = bytes
.windows(h_key.len())
.position(|window| window == h_key)
.expect("linearization parameter dictionary has /H array");
let h_values_start = h_key_start + h_key.len();
let (h0_start, h0_end) = token_range(&bytes, h_values_start);
let (h1_start, h1_end) = token_range(&bytes, h0_end);
let close = h1_end
+ bytes[h1_end..]
.iter()
.position(|&byte| byte == b']')
.expect("linearization /H array terminator");
let param_end = close
+ bytes[close..]
.windows(b"endobj".len())
.position(|window| window == b"endobj")
.expect("linearization parameter endobj")
+ b"endobj".len();
let insertion = {
let mut value = Vec::with_capacity(2 + h0_end - h0_start + h1_end - h1_start);
value.push(b' ');
value.extend_from_slice(&bytes[h0_start..h0_end]);
value.push(b' ');
value.extend_from_slice(&bytes[h1_start..h1_end]);
value
};
let delta = insertion.len();
let padding_boundary = param_end
+ bytes[param_end..]
.iter()
.position(|&byte| !is_pdf_whitespace(byte))
.expect("non-whitespace after the parameter dictionary");
assert!(padding_boundary >= delta, "parameter padding is too short");
assert!(
bytes[padding_boundary - delta..padding_boundary]
.iter()
.all(|&byte| is_pdf_whitespace(byte)),
"parameter dictionary has no trailing padding for /H overflow fixture"
);
bytes.splice(close..close, insertion);
assert!(
bytes[padding_boundary..padding_boundary + delta]
.iter()
.all(|&byte| is_pdf_whitespace(byte)),
"inserted /H overflow fixture did not land in parameter padding"
);
bytes.drain(padding_boundary..padding_boundary + delta);
bytes
}
pub fn check_linearization_bytes(file_bytes: &[u8]) -> CheckResult {
use std::io::Cursor;
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec()))
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?;
check_linearization(&mut pdf, file_bytes)
}
pub fn check_linearization_path(
path: &std::path::Path,
) -> std::result::Result<(), LinearizationCheckError> {
let file_bytes = std::fs::read(path)?;
let mut pdf = Pdf::open(BufReader::new(std::io::Cursor::new(file_bytes.clone())))
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?;
check_linearization(&mut pdf, &file_bytes)
}
#[cfg(test)]
mod tests {
use super::{
check_linearization_warnings, length_next_n, load_hint_stream_with_damage,
LinearizationCheckError,
};
use crate::Pdf;
use std::collections::BTreeMap;
use std::io::Cursor;
#[test]
fn qpdf_exception_conversion_preserves_structured_display() {
let check_error =
LinearizationCheckError::from(crate::Error::QpdfExc(crate::QpdfExc::new(
crate::QpdfErrorCode::DamagedPdf,
b"input.pdf",
b"trailer",
7,
b"broken trailer",
)));
assert!(matches!(
&check_error,
LinearizationCheckError::QpdfExc(error)
if error.get_filename() == b"input.pdf"
&& error.get_object() == b"trailer"
&& error.get_file_position() == 7
&& error.get_message_detail() == b"broken trailer"
));
assert_eq!(
check_error.to_string(),
"input.pdf (trailer, offset 7): broken trailer"
);
}
#[test]
fn length_next_n_rejects_object_number_wrap() {
let mut pdf = Pdf::empty().expect("empty PDF");
let mut warnings = Vec::new();
let error = length_next_n(
&mut pdf,
&BTreeMap::new(),
u32::MAX - 1,
3,
3,
true,
&mut warnings,
)
.expect_err("a hint sequence that wraps u32 must be rejected");
assert!(matches!(
error,
LinearizationCheckError::InvalidParam { message }
if message == "object sequence starting at 4294967294 overflows u32"
));
assert_eq!(
warnings.len(),
2,
"the two missing entries precede the wrap"
);
}
#[test]
fn load_hint_stream_uses_qpdf_description_route_for_valid_fixture() {
let file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-one-page.pdf"
));
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec())).expect("fixture should open");
let result = load_hint_stream_with_damage(&mut pdf, file_bytes, 601, 118);
assert!(
result.is_ok(),
"the fixture hint stream should resolve and decode"
);
let (_hint_dict, decoded) = result.ok().unwrap();
assert!(!decoded.is_empty());
}
#[test]
fn load_hint_stream_propagates_offset_resolver_failure() {
let file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-one-page.pdf"
));
let mut pdf = Pdf::empty().expect("empty PDF should be constructible");
assert!(matches!(
load_hint_stream_with_damage(&mut pdf, file_bytes, 601, 118),
Err(super::HintStreamLoadError::Core(_))
));
}
#[test]
fn check_reports_uncompressed_after_compressed_like_qpdf() {
let file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-uncompressed-after-compressed.pdf"
));
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec())).expect("fixture should open");
let warnings = check_linearization_warnings(&mut pdf, file_bytes, false)
.expect("the fixture is linearized enough to reach every soft-warning check");
assert!(
warnings.iter().any(|warning| warning
== "linearized file contains an uncompressed object after a compressed one in a cross-reference stream"),
"{warnings:?}"
);
}
#[test]
fn check_linearization_strict_mode_fails_on_uncompressed_after_compressed() {
let file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-uncompressed-after-compressed.pdf"
));
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec())).expect("fixture should open");
let error = super::check_linearization(&mut pdf, file_bytes)
.expect_err("the fixture's cross-reference stream entry order must fail strict mode");
assert!(
matches!(
&error,
LinearizationCheckError::InvalidParam { message }
if message == "linearized file contains an uncompressed object after a compressed one in a cross-reference stream"
),
"{error:?}"
);
}
#[test]
fn is_linearized_accepts_a_real_linearized_marker() {
let mut file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-one-page.pdf"
))
.to_vec();
let original_length = file_bytes.len();
let old = format!("/Linearized 1 /L {original_length}");
let new = format!("/Linearized 1.0 /L {}", original_length + 2);
let offset = file_bytes
.windows(old.len())
.position(|window| window == old.as_bytes())
.expect("fixture must contain its linearization marker");
file_bytes.splice(offset..offset + old.len(), new.bytes());
let mut pdf = Pdf::open(Cursor::new(file_bytes)).expect("fixture should open");
assert!(pdf
.is_linearized()
.expect("real-valued /Linearized should be accepted"));
}
#[test]
fn check_linearization_loads_the_four_item_overflow_hint_stream() {
let file_bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/compat/linearized-one-page.pdf"
));
let bytes = super::add_overflow_hint_items_for_test(file_bytes.to_vec());
super::check_linearization_bytes(&bytes)
.expect("the checker should load and merge a four-item /H fixture");
}
}