use super::check::{
check_linearization_parameters, check_linearization_warnings_with_hint_data,
load_hint_stream_with_damage, HintStreamLoadError, LinearizationCheckError,
LinearizationParameterCheck,
};
use crate::bit_stream::{BitStream, BitStreamError};
#[cfg(test)]
use crate::ObjectRef;
use crate::{ObjectHandle, Pdf, QpdfErrorCode, QpdfExc};
use std::fmt;
use std::io::{Cursor, Read, Seek};
use std::rc::Rc;
#[derive(Debug)]
pub enum ShowLinearizationError {
Malformed { message: String },
Io(Box<dyn std::error::Error + Send + Sync>),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ShowLinearizationOutput {
pub dump: Vec<u8>,
pub warnings: Vec<Vec<u8>>,
}
impl fmt::Display for ShowLinearizationError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ShowLinearizationError::Malformed { message } => {
write!(f, "malformed linearization data: {message}")
}
ShowLinearizationError::Io(e) => write!(f, "I/O error: {e}"),
}
}
}
impl std::error::Error for ShowLinearizationError {}
impl From<crate::Error> for ShowLinearizationError {
fn from(e: crate::Error) -> Self {
ShowLinearizationError::Io(Box::new(e))
}
}
impl From<std::io::Error> for ShowLinearizationError {
fn from(e: std::io::Error) -> Self {
ShowLinearizationError::Io(Box::new(e))
}
}
impl From<BitStreamError> for ShowLinearizationError {
fn from(error: BitStreamError) -> Self {
ShowLinearizationError::Malformed {
message: error.to_string(),
}
}
}
pub(crate) type ShowResult<T> = std::result::Result<T, ShowLinearizationError>;
macro_rules! malformed {
($($arg:tt)*) => {
ShowLinearizationError::Malformed { message: format!($($arg)*) }
};
}
enum ShowTablesError {
QpdfDamage {
object: &'static str,
offset: u64,
detail: String,
},
Other(ShowLinearizationError),
}
impl From<ShowLinearizationError> for ShowTablesError {
fn from(error: ShowLinearizationError) -> Self {
Self::Other(error)
}
}
fn load_hint_stream_for_show<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
offset: usize,
expected_h_length: u64,
) -> std::result::Result<(ObjectHandle, Rc<Vec<u8>>), ShowTablesError> {
match load_hint_stream_with_damage(pdf, file_bytes, offset, expected_h_length) {
Ok(result) => Ok(result),
Err(HintStreamLoadError::Damage(damage)) => Err(ShowTablesError::QpdfDamage {
object: damage.object,
offset: damage.offset,
detail: damage.detail,
}),
Err(HintStreamLoadError::Core(crate::Error::QpdfExc(error)))
if error.get_error_code() == crate::QpdfErrorCode::Unsupported =>
{
Err(malformed!("{error}").into())
}
Err(HintStreamLoadError::Core(error)) => Err(ShowLinearizationError::from(error).into()), }
}
struct LinParameters {
file_size: u64,
first_page_object: u64,
first_page_end: u64,
npages: u32,
xref_zero_offset: u64,
first_page: i64,
h_offset: u64,
h_length: u64,
h_overflow_offset: u64,
h_overflow_length: u64,
}
impl LinParameters {
fn adjusted_offset(&self, offset: u64) -> u64 {
if offset >= self.h_offset {
offset.wrapping_add(self.h_length)
} else {
offset
}
}
}
#[derive(Clone)]
pub(crate) struct HPageOffset {
pub(crate) min_nobjects: u32,
pub(crate) first_page_offset: u64,
pub(crate) nbits_delta_nobjects: u32,
pub(crate) min_page_length: u64,
pub(crate) nbits_delta_page_length: u32,
pub(crate) min_content_offset: u64,
pub(crate) nbits_delta_content_offset: u32,
pub(crate) min_content_length: u64,
pub(crate) nbits_delta_content_length: u32,
pub(crate) nbits_nshared_objects: u32,
pub(crate) nbits_shared_identifier: u32,
pub(crate) nbits_shared_numerator: u32,
pub(crate) shared_denominator: u32,
pub(crate) entries: Vec<HPageOffsetEntry>,
}
#[derive(Clone, Default)]
pub(crate) struct HPageOffsetEntry {
pub(crate) delta_nobjects: u64,
pub(crate) delta_page_length: u64,
pub(crate) nshared_objects: u32,
pub(crate) shared_identifiers: Vec<u64>,
pub(crate) shared_numerators: Vec<u64>,
pub(crate) delta_content_offset: u64,
pub(crate) delta_content_length: u64,
}
#[derive(Clone)]
pub(crate) struct HSharedObject {
pub(crate) first_shared_obj: u64,
pub(crate) first_shared_offset: u64,
pub(crate) nshared_first_page: u32,
pub(crate) nshared_total: u32,
pub(crate) nbits_nobjects: u32,
pub(crate) min_group_length: u64,
pub(crate) nbits_delta_group_length: u32,
pub(crate) entries: Vec<HSharedObjectEntry>,
}
#[derive(Clone, Default)]
pub(crate) struct HSharedObjectEntry {
pub(crate) delta_group_length: u64,
pub(crate) signature_present: bool,
pub(crate) nobjects_minus_one: u64,
}
#[derive(Clone)]
pub(crate) struct HGeneric {
pub(crate) first_object: u64,
pub(crate) first_object_offset: u64,
pub(crate) nobjects: u32,
pub(crate) group_length: u64,
}
pub(crate) fn read_h_page_offset(buf: &[u8], npages: u32) -> ShowResult<HPageOffset> {
let mut bits = BitStream::new(buf);
let min_nobjects = bits.get_bits_i32(32)? as u32;
let first_page_offset = bits.get_bits_i32(32)? as u32 as u64;
let nbits_delta_nobjects = bits.get_bits_i32(16)? as u32;
let min_page_length = bits.get_bits_i32(32)? as u32 as u64;
let nbits_delta_page_length = bits.get_bits_i32(16)? as u32;
let min_content_offset = bits.get_bits_i32(32)? as u32 as u64;
let nbits_delta_content_offset = bits.get_bits_i32(16)? as u32;
let min_content_length = bits.get_bits_i32(32)? as u32 as u64;
let nbits_delta_content_length = bits.get_bits_i32(16)? as u32;
let nbits_nshared_objects = bits.get_bits_i32(16)? as u32;
let nbits_shared_identifier = bits.get_bits_i32(16)? as u32;
let nbits_shared_numerator = bits.get_bits_i32(16)? as u32;
let shared_denominator = bits.get_bits_i32(16)? as u32;
let n = npages as usize;
let mut entries: Vec<HPageOffsetEntry> = Vec::new();
for _ in 0..n {
entries.push(HPageOffsetEntry::default());
let e = entries
.last_mut()
.expect("the entry was appended immediately above");
e.delta_nobjects = bits.get_bits_i32(nbits_delta_nobjects as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
e.delta_page_length = bits.get_bits_i32(nbits_delta_page_length as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
e.nshared_objects = bits.get_bits_i32(nbits_nshared_objects as usize)? as u32;
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
for _ in 0..e.nshared_objects {
e.shared_identifiers
.push(bits.get_bits_i32(nbits_shared_identifier as usize)? as u32 as u64);
}
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
for _ in 0..e.nshared_objects {
e.shared_numerators
.push(bits.get_bits_i32(nbits_shared_numerator as usize)? as u32 as u64);
}
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
e.delta_content_offset =
bits.get_bits_i32(nbits_delta_content_offset as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
e.delta_content_length =
bits.get_bits_i32(nbits_delta_content_length as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
Ok(HPageOffset {
min_nobjects,
first_page_offset,
nbits_delta_nobjects,
min_page_length,
nbits_delta_page_length,
min_content_offset,
nbits_delta_content_offset,
min_content_length,
nbits_delta_content_length,
nbits_nshared_objects,
nbits_shared_identifier,
nbits_shared_numerator,
shared_denominator,
entries,
})
}
pub(crate) fn read_h_shared_object(buf: &[u8]) -> ShowResult<HSharedObject> {
let mut bits = BitStream::new(buf);
let first_shared_obj = bits.get_bits_i32(32)? as u32 as u64;
let first_shared_offset = bits.get_bits_i32(32)? as u32 as u64;
let nshared_first_page = bits.get_bits_i32(32)? as u32;
let nshared_total = bits.get_bits_i32(32)? as u32;
let nbits_nobjects = bits.get_bits_i32(16)? as u32;
let min_group_length = bits.get_bits_i32(32)? as u32 as u64;
let nbits_delta_group_length = bits.get_bits_i32(16)? as u32;
let n = nshared_total as usize;
let mut entries: Vec<HSharedObjectEntry> = Vec::new();
for _ in 0..n {
entries.push(HSharedObjectEntry::default());
let e = entries
.last_mut()
.expect("the entry was appended immediately above");
e.delta_group_length = bits.get_bits_i32(nbits_delta_group_length as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
for e in entries.iter_mut() {
e.signature_present = bits.get_bits_i32(1)? != 0;
}
bits.skip_to_next_byte()?;
for e in entries.iter() {
if e.signature_present {
for _ in 0..4 {
let _ = bits.get_bits(32)?;
}
}
}
for e in entries.iter_mut() {
e.nobjects_minus_one = bits.get_bits_i32(nbits_nobjects as usize)? as u32 as u64;
}
bits.skip_to_next_byte()?;
Ok(HSharedObject {
first_shared_obj,
first_shared_offset,
nshared_first_page,
nshared_total,
nbits_nobjects,
min_group_length,
nbits_delta_group_length,
entries,
})
}
pub(crate) fn read_h_generic(buf: &[u8]) -> ShowResult<HGeneric> {
let mut bits = BitStream::new(buf);
let first_object = bits.get_bits_i32(32)? as u32 as u64;
let first_object_offset = bits.get_bits_i32(32)? as u32 as u64;
let nobjects = bits.get_bits_i32(32)? as u32;
let group_length = bits.get_bits_i32(32)? as u32 as u64;
Ok(HGeneric {
first_object,
first_object_offset,
nobjects,
group_length,
})
}
fn dump_page_offset(out: &mut String, p: &LinParameters, t: &HPageOffset) {
use std::fmt::Write;
let _ = write!(
out,
"min_nobjects: {}\n\
first_page_offset: {}\n\
nbits_delta_nobjects: {}\n\
min_page_length: {}\n\
nbits_delta_page_length: {}\n\
min_content_offset: {}\n\
nbits_delta_content_offset: {}\n\
min_content_length: {}\n\
nbits_delta_content_length: {}\n\
nbits_nshared_objects: {}\n\
nbits_shared_identifier: {}\n\
nbits_shared_numerator: {}\n\
shared_denominator: {}\n",
t.min_nobjects,
p.adjusted_offset(t.first_page_offset),
t.nbits_delta_nobjects,
t.min_page_length,
t.nbits_delta_page_length,
t.min_content_offset,
t.nbits_delta_content_offset,
t.min_content_length,
t.nbits_delta_content_length,
t.nbits_nshared_objects,
t.nbits_shared_identifier,
t.nbits_shared_numerator,
t.shared_denominator,
);
for (i, pe) in t.entries.iter().enumerate() {
let _ = write!(
out,
"Page {i}:\n \
nobjects: {}\n \
length: {}\n \
content_offset: {}\n \
content_length: {}\n \
nshared_objects: {}\n",
pe.delta_nobjects.wrapping_add(t.min_nobjects as u64),
pe.delta_page_length.wrapping_add(t.min_page_length),
pe.delta_content_offset.wrapping_add(t.min_content_offset),
pe.delta_content_length.wrapping_add(t.min_content_length),
pe.nshared_objects,
);
for j in 0..pe.nshared_objects as usize {
let _ = writeln!(out, " identifier {j}: {}", pe.shared_identifiers[j]);
let _ = writeln!(out, " numerator {j}: {}", pe.shared_numerators[j]);
}
}
}
fn dump_shared_object(out: &mut String, p: &LinParameters, t: &HSharedObject) {
use std::fmt::Write;
let _ = write!(
out,
"first_shared_obj: {}\n\
first_shared_offset: {}\n\
nshared_first_page: {}\n\
nshared_total: {}\n\
nbits_nobjects: {}\n\
min_group_length: {}\n\
nbits_delta_group_length: {}\n",
t.first_shared_obj,
p.adjusted_offset(t.first_shared_offset),
t.nshared_first_page,
t.nshared_total,
t.nbits_nobjects,
t.min_group_length,
t.nbits_delta_group_length,
);
for (i, se) in t.entries.iter().enumerate() {
let _ = write!(
out,
"Shared Object {i}:\n group length: {}\n",
se.delta_group_length.wrapping_add(t.min_group_length)
);
if se.signature_present {
out.push_str(" signature present\n");
}
if se.nobjects_minus_one != 0 {
let _ = writeln!(out, " nobjects: {}", se.nobjects_minus_one.wrapping_add(1));
}
}
}
fn dump_generic(out: &mut String, p: &LinParameters, t: &HGeneric) {
use std::fmt::Write;
let _ = write!(
out,
"first_object: {}\n\
first_object_offset: {}\n\
nobjects: {}\n\
group_length: {}\n",
t.first_object,
p.adjusted_offset(t.first_object_offset),
t.nobjects,
t.group_length,
);
}
fn param_u64(dict: &ObjectHandle, key: &'static str) -> ShowResult<u64> {
let value = dict
.try_get_key(format!("/{key}").as_bytes())
.map_err(ShowLinearizationError::from)?;
integer_u64(&value, key)
}
fn integer_u64(value: &ObjectHandle, _key: &str) -> ShowResult<u64> {
match value
.try_as_integer()
.map_err(ShowLinearizationError::from)?
{
Some(n) if n >= 0 => Ok(n as u64),
_ => Err(malformed!(
"some keys in linearization dictionary are of the wrong type"
)),
}
}
#[cfg(test)]
fn is_linearized(dict: &ObjectHandle, file_size: u64) -> ShowResult<bool> {
dict.try_dereference()
.map_err(ShowLinearizationError::from)?;
let linearized = dict
.try_get_key(b"/Linearized")
.map_err(ShowLinearizationError::from)?;
linearized
.try_dereference()
.map_err(ShowLinearizationError::from)?;
let linearized_ok = linearized
.as_integer()
.map(|value| value as f64)
.or_else(|| linearized.as_real())
.is_some_and(|value| value.is_finite() && value.floor() == 1.0);
if !linearized_ok {
return Ok(false);
}
let length = dict
.try_get_key(b"/L")
.map_err(ShowLinearizationError::from)?;
if let Some(l) = length
.try_as_integer()
.map_err(ShowLinearizationError::from)?
{
if l < 0 || l as u64 != file_size {
return Ok(false);
}
}
Ok(true)
}
fn read_lin_parameters(dict: &ObjectHandle, file_size: u64) -> ShowResult<LinParameters> {
let first_page_object = param_u64(dict, "O")?;
let first_page_end = param_u64(dict, "E")?;
let npages_u64 = param_u64(dict, "N")?;
let npages = u32::try_from(npages_u64)
.map_err(|_| malformed!("/N ({npages_u64}) does not fit in u32"))?;
let xref_zero_offset = param_u64(dict, "T")?;
let p = dict
.try_get_key(b"/P")
.map_err(ShowLinearizationError::from)?;
let first_page: i64 =
if let Some(n) = p.try_as_integer().map_err(ShowLinearizationError::from)? {
n
} else if p.try_is_null().map_err(ShowLinearizationError::from)? {
0
} else {
return Err(malformed!(
"some keys in linearization dictionary are of the wrong type"
));
};
let h = dict
.try_get_key(b"/H")
.map_err(ShowLinearizationError::from)?;
let Some(h_items) = h.try_as_array().map_err(ShowLinearizationError::from)? else {
return Err(malformed!(
"some keys in linearization dictionary are of the wrong type"
));
};
if !matches!(h_items.len(), 2 | 4) {
return Err(malformed!("H has the wrong number of items"));
}
let h_offset = integer_u64(&h_items[0], "H[0]")?;
let h_length = integer_u64(&h_items[1], "H[1]")?;
let (h_overflow_offset, h_overflow_length) = if h_items.len() == 4 {
(
integer_u64(&h_items[2], "H[2]")?,
integer_u64(&h_items[3], "H[3]")?,
)
} else {
(0, 0)
};
Ok(LinParameters {
file_size,
first_page_object,
first_page_end,
npages,
xref_zero_offset,
first_page,
h_offset,
h_length,
h_overflow_offset,
h_overflow_length,
})
}
fn linearization_runtime_warning(display_name: &[u8], detail: &str) -> Vec<u8> {
let mut result = display_name.to_vec();
result.extend_from_slice(b": ");
result.extend_from_slice(detail.as_bytes());
result
}
fn linearization_damage_warning(
display_name: &[u8],
object: &str,
offset: u64,
detail: &str,
) -> Vec<u8> {
let mut result = display_name.to_vec();
result.extend_from_slice(b" (");
result.extend_from_slice(object.as_bytes());
result.extend_from_slice(b", offset ");
result.extend_from_slice(offset.to_string().as_bytes());
result.extend_from_slice(b"): ");
result.extend_from_slice(detail.as_bytes());
result
}
pub(crate) fn read_hint_offsets(hint_dict: &ObjectHandle) -> ShowResult<(usize, Option<usize>)> {
let s = hint_dict
.try_get_key(b"/S")
.map_err(ShowLinearizationError::from)?;
let s_value = integer_u64(&s, "S")?;
let s_offset = usize::try_from(s_value)
.map_err(|_| malformed!("hint stream /S offset does not fit in platform usize"))?;
let outline = hint_dict
.try_get_key(b"/O")
.map_err(ShowLinearizationError::from)?;
let outline_offset = if let Some(value) = outline
.try_as_integer()
.map_err(ShowLinearizationError::from)?
{
if value < 0 {
return Err(malformed!("hint stream /O offset is negative"));
}
Some(
usize::try_from(value as u64)
.map_err(|_| malformed!("hint stream /O offset does not fit in platform usize"))?,
)
} else {
None
};
Ok((s_offset, outline_offset))
}
fn show_with_pdf<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
display_name: &[u8],
) -> ShowResult<ShowLinearizationOutput> {
let file_size = file_bytes.len() as u64;
let not_linearized = || {
let mut dump = display_name.to_vec();
dump.extend_from_slice(b" is not linearized\n");
Ok(ShowLinearizationOutput {
dump,
warnings: Vec::new(),
})
};
let Some(first_obj_ref) = pdf
.linearization_candidate_ref()
.map_err(ShowLinearizationError::from)?
else {
return not_linearized();
};
let parameter_offset = pdf.source_last_offset();
if !pdf.is_linearized().map_err(ShowLinearizationError::from)? {
return not_linearized();
}
let param_dict = pdf.get_object_handle(first_obj_ref);
if !param_dict
.try_is_dictionary()
.map_err(ShowLinearizationError::from)?
{
return not_linearized();
}
let mut warnings = Vec::new();
let tables = (|| -> std::result::Result<
(LinParameters, HPageOffset, HSharedObject, Option<HGeneric>),
ShowTablesError,
> {
let params = read_lin_parameters(¶m_dict, file_size).map_err(|error| match error {
ShowLinearizationError::Malformed { message } => ShowTablesError::QpdfDamage {
object: "linearization dictionary",
offset: parameter_offset,
detail: message,
},
other => ShowTablesError::Other(other),
})?;
match check_linearization_parameters(pdf) {
Ok(LinearizationParameterCheck::Clean) => {}
Ok(LinearizationParameterCheck::Warning(message)) => {
warnings.push(message.as_bytes().to_vec());
}
Ok(LinearizationParameterCheck::Error { object, message }) => {
return Err(ShowTablesError::QpdfDamage {
object,
offset: pdf.source_last_offset(),
detail: message.to_owned(),
});
}
Err(error) => return Err(ShowTablesError::Other(error.into())),
}
let h_usize = usize::try_from(params.h_offset)
.map_err(|_| malformed!("/H[0] does not fit in platform usize"))?;
let (hint_dict, primary_decompressed) =
load_hint_stream_for_show(pdf, file_bytes, h_usize, params.h_length)?;
let mut decompressed =
Rc::try_unwrap(primary_decompressed).unwrap_or_else(|shared| (*shared).clone());
if params.h_overflow_offset != 0 {
let overflow_offset = usize::try_from(params.h_overflow_offset)
.map_err(|_| malformed!("/H[2] does not fit in platform usize"))?;
let (_overflow_dict, overflow_decompressed) = load_hint_stream_for_show(
pdf,
file_bytes,
overflow_offset,
params.h_overflow_length,
)?;
decompressed.extend_from_slice(&overflow_decompressed);
}
let (s_offset, outline_offset) = read_hint_offsets(&hint_dict)?;
if s_offset >= decompressed.len() {
return Err(ShowTablesError::QpdfDamage {
object: "linearization hint table",
offset: pdf.source_last_offset(),
detail: "/S (shared object) offset is out of bounds".to_owned(),
});
}
let page_offset = read_h_page_offset(&decompressed, params.npages)?;
let shared_object = read_h_shared_object(&decompressed[s_offset..])?;
let outline = match outline_offset {
Some(off) => {
if off >= decompressed.len() {
return Err(ShowTablesError::QpdfDamage {
object: "linearization hint table",
offset: pdf.source_last_offset(),
detail: "/O (outline) offset is out of bounds".to_owned(),
});
}
Some(read_h_generic(&decompressed[off..])?)
}
None => None,
};
match check_linearization_warnings_with_hint_data(
pdf,
file_bytes,
true,
&hint_dict,
&decompressed,
) {
Ok(messages) => warnings.extend(messages.into_iter().map(String::into_bytes)),
Err(LinearizationCheckError::Io(error)) => {
return Err(ShowLinearizationError::Io(error).into()); }
Err(LinearizationCheckError::InvalidParam { message }) => {
warnings.push(message.into_bytes());
}
Err(LinearizationCheckError::QpdfExc(error)) => {
warnings.push(
QpdfExc::new(
QpdfErrorCode::Linearization,
display_name,
error.get_object(),
error.get_file_position(),
error.get_message_detail(),
)
.what_bytes()
.to_vec(),
);
}
Err(LinearizationCheckError::NotLinearized) => {
return Err(malformed!(
"not a linearized PDF: the first object in the file has no /Linearized key"
)
.into());
} }
Ok((params, page_offset, shared_object, outline))
})();
match tables {
Ok((params, page_offset, shared_object, outline)) => Ok(ShowLinearizationOutput {
dump: format_dump(
display_name,
¶ms,
&page_offset,
&shared_object,
outline.as_ref(),
),
warnings,
}),
Err(ShowTablesError::QpdfDamage {
object,
offset,
detail,
}) => Ok(ShowLinearizationOutput {
dump: Vec::new(),
warnings: vec![linearization_damage_warning(
display_name,
object,
offset,
&detail,
)],
}),
Err(ShowTablesError::Other(ShowLinearizationError::Malformed { message })) => {
Ok(ShowLinearizationOutput {
dump: Vec::new(),
warnings: vec![linearization_runtime_warning(display_name, &message)],
})
}
Err(ShowTablesError::Other(err @ ShowLinearizationError::Io(_))) => Err(err), }
}
fn format_dump(
display_name: &[u8],
p: &LinParameters,
page_offset: &HPageOffset,
shared_object: &HSharedObject,
outline: Option<&HGeneric>,
) -> Vec<u8> {
use std::fmt::Write;
let mut out = display_name.to_vec();
out.extend_from_slice(b": linearization data:\n\n");
let mut body = String::new();
let _ = write!(
body,
"file_size: {}\n\
first_page_object: {}\n\
first_page_end: {}\n\
npages: {}\n\
xref_zero_offset: {}\n\
first_page: {}\n\
H_offset: {}\n\
H_length: {}\n\n",
p.file_size,
p.first_page_object,
p.first_page_end,
p.npages,
p.xref_zero_offset,
p.first_page,
p.h_offset,
p.h_length,
);
body.push_str("Page Offsets Hint Table\n\n");
dump_page_offset(&mut body, p, page_offset);
body.push_str("\nShared Objects Hint Table\n\n");
dump_shared_object(&mut body, p, shared_object);
if let Some(g) = outline {
if g.nobjects > 0 {
body.push_str("\nOutlines Hint Table\n\n");
dump_generic(&mut body, p, g);
}
}
out.extend_from_slice(body.as_bytes());
out
}
#[cfg(test)]
fn parse_obj_header(window: &[u8]) -> Option<ObjectRef> {
fn is_ws(b: u8) -> bool {
matches!(b, b'\0' | b'\t' | b'\n' | b'\x0c' | b'\r' | b' ')
}
let mut i = 0;
while i < window.len() && is_ws(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 num: u32 = std::str::from_utf8(&window[num_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_ws(window[i]) {
return None;
}
while i < window.len() && is_ws(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 gen: u16 = std::str::from_utf8(&window[gen_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_ws(window[i]) {
return None;
}
while i < window.len() && is_ws(window[i]) {
i += 1;
}
if window.get(i..i + 3) != Some(b"obj") {
return None;
}
Some(ObjectRef::new(num, gen))
}
pub fn show_linearization_bytes(
file_bytes: &[u8],
display_name: impl AsRef<[u8]>,
) -> std::result::Result<String, ShowLinearizationError> {
show_linearization_bytes_with_warnings(file_bytes, display_name)
.map(|result| String::from_utf8_lossy(&result.dump).into_owned())
}
pub fn show_linearization_bytes_with_warnings(
file_bytes: &[u8],
display_name: impl AsRef<[u8]>,
) -> std::result::Result<ShowLinearizationOutput, ShowLinearizationError> {
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec()))
.map_err(|e| ShowLinearizationError::Io(Box::new(e)))?;
show_with_pdf(&mut pdf, file_bytes, display_name.as_ref())
}
pub fn show_linearization_pdf_with_warnings<R: Read + Seek>(
pdf: &mut Pdf<R>,
display_name: impl AsRef<[u8]>,
) -> std::result::Result<ShowLinearizationOutput, ShowLinearizationError> {
let file_bytes = pdf
.source_bytes()
.map_err(|error| ShowLinearizationError::Io(Box::new(error)))?;
show_with_pdf(pdf, &file_bytes, display_name.as_ref())
}
pub fn show_linearization_path(
path: &std::path::Path,
) -> std::result::Result<String, ShowLinearizationError> {
show_linearization_path_with_warnings(path)
.map(|result| String::from_utf8_lossy(&result.dump).into_owned())
}
pub fn show_linearization_path_with_warnings(
path: &std::path::Path,
) -> std::result::Result<ShowLinearizationOutput, ShowLinearizationError> {
let file_bytes = std::fs::read(path)?;
let mut pdf = Pdf::open(Cursor::new(file_bytes.clone()))
.map_err(|e| ShowLinearizationError::Io(Box::new(e)))?;
show_with_pdf(&mut pdf, &file_bytes, &path_description_bytes(path))
}
fn path_description_bytes(path: &std::path::Path) -> Vec<u8> {
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
path.as_os_str().as_bytes().to_vec()
}
#[cfg(not(unix))]
{
path.to_string_lossy().into_owned().into_bytes()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bit_writer::BitWriter;
use crate::linearization::hint_stream::encode_hint_stream;
use crate::pipeline::buffer::Buffer;
use crate::pipeline::{Pipeline, PipelineResult};
fn bit_writer_bytes(write: impl FnOnce(&mut BitWriter<'_>) -> PipelineResult<()>) -> Vec<u8> {
let mut sink = Buffer::new("show test bit writer", None);
{
let mut writer = BitWriter::new(&mut sink);
write(&mut writer).expect("write test bitstream");
writer.flush().expect("flush test bitstream");
}
sink.finish().expect("finish test bitstream");
sink.take_buffer().expect("take test bitstream")
}
use crate::linearization::hint_page::{
bits_needed, PageOffsetEntry, PageOffsetHeader, PageOffsetHintTable,
};
use crate::linearization::hint_shared::{
SharedObjectEntry, SharedObjectHeader, SharedObjectHintTable,
};
fn rich_page_offset_table() -> PageOffsetHintTable {
let header = PageOffsetHeader {
least_object_count: 2,
location_of_first_page: 1000,
bits_object_count_delta: 2,
least_page_length: 50,
bits_page_length_delta: 8,
least_content_offset: 4,
bits_content_offset_delta: 4,
least_content_length: 50,
bits_content_length_delta: 8,
bits_shared_object_count: 2,
bits_shared_object_id: 3,
bits_numerator: 2,
denominator: 4,
};
let entries = vec![
PageOffsetEntry {
object_count_minus_least: 0,
page_length_minus_least: 0,
shared_object_count: 0,
shared_object_ids: vec![],
shared_object_numerators: vec![],
content_stream_offset: 0,
content_stream_length: 0,
},
PageOffsetEntry {
object_count_minus_least: 3,
page_length_minus_least: 130,
shared_object_count: 2,
shared_object_ids: vec![5, 1],
shared_object_numerators: vec![3, 0],
content_stream_offset: 9,
content_stream_length: 130,
},
PageOffsetEntry {
object_count_minus_least: 1,
page_length_minus_least: 7,
shared_object_count: 1,
shared_object_ids: vec![4],
shared_object_numerators: vec![2],
content_stream_offset: 3,
content_stream_length: 7,
},
];
PageOffsetHintTable { header, entries }
}
fn rich_shared_object_table() -> SharedObjectHintTable {
let header = SharedObjectHeader {
first_object_number: 17,
location: 2000,
first_page_entries: 2,
section_entries: 3,
bits_group_object_count: 0,
least_length: 33,
bits_length_delta: 8,
};
let objects = vec![
SharedObjectEntry {
length_minus_least: 0,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
SharedObjectEntry {
length_minus_least: 157,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
SharedObjectEntry {
length_minus_least: 75,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
];
SharedObjectHintTable { header, objects }
}
#[test]
fn round_trip_page_offset_table() {
let po = rich_page_offset_table();
let so = rich_shared_object_table();
let encoded = encode_hint_stream(&po, &so, None).expect("encode");
let decoded = read_h_page_offset(&encoded.uncompressed, po.entries.len() as u32)
.expect("decode page offset");
assert_eq!(decoded.min_nobjects, po.header.least_object_count);
assert_eq!(decoded.first_page_offset, po.header.location_of_first_page);
assert_eq!(
decoded.nbits_delta_nobjects,
po.header.bits_object_count_delta
);
assert_eq!(decoded.min_page_length, po.header.least_page_length);
assert_eq!(
decoded.nbits_delta_page_length,
po.header.bits_page_length_delta
);
assert_eq!(decoded.min_content_offset, po.header.least_content_offset);
assert_eq!(
decoded.nbits_delta_content_offset,
po.header.bits_content_offset_delta
);
assert_eq!(decoded.min_content_length, po.header.least_content_length);
assert_eq!(
decoded.nbits_delta_content_length,
po.header.bits_content_length_delta
);
assert_eq!(
decoded.nbits_nshared_objects,
po.header.bits_shared_object_count
);
assert_eq!(
decoded.nbits_shared_identifier,
po.header.bits_shared_object_id
);
assert_eq!(decoded.nbits_shared_numerator, po.header.bits_numerator);
assert_eq!(decoded.shared_denominator, po.header.denominator);
assert_eq!(decoded.entries.len(), po.entries.len());
for (d, o) in decoded.entries.iter().zip(po.entries.iter()) {
assert_eq!(d.delta_nobjects, o.object_count_minus_least as u64);
assert_eq!(d.delta_page_length, o.page_length_minus_least);
assert_eq!(d.nshared_objects, o.shared_object_count);
assert_eq!(
d.shared_identifiers,
o.shared_object_ids
.iter()
.map(|&x| x as u64)
.collect::<Vec<_>>()
);
assert_eq!(
d.shared_numerators,
o.shared_object_numerators
.iter()
.map(|&x| x as u64)
.collect::<Vec<_>>()
);
assert_eq!(d.delta_content_offset, o.content_stream_offset);
assert_eq!(d.delta_content_length, o.content_stream_length);
}
}
#[test]
fn round_trip_shared_object_table() {
let po = rich_page_offset_table();
let so = rich_shared_object_table();
let encoded = encode_hint_stream(&po, &so, None).expect("encode");
let decoded = read_h_shared_object(
&encoded.uncompressed[encoded.shared_section_offset_in_uncompressed..],
)
.expect("decode shared object");
assert_eq!(
decoded.first_shared_obj,
so.header.first_object_number as u64
);
assert_eq!(decoded.first_shared_offset, so.header.location);
assert_eq!(decoded.nshared_first_page, so.header.first_page_entries);
assert_eq!(decoded.nshared_total, so.header.section_entries);
assert_eq!(decoded.nbits_nobjects, so.header.bits_group_object_count);
assert_eq!(decoded.min_group_length, so.header.least_length);
assert_eq!(
decoded.nbits_delta_group_length,
so.header.bits_length_delta
);
assert_eq!(decoded.entries.len(), so.objects.len());
for (d, o) in decoded.entries.iter().zip(so.objects.iter()) {
assert_eq!(d.delta_group_length, o.length_minus_least as u64);
assert_eq!(d.signature_present, o.signature_present);
assert_eq!(d.nobjects_minus_one, o.nobjects_minus_one as u64);
}
}
#[test]
fn round_trip_uses_nonzero_bit_widths() {
let po = rich_page_offset_table();
assert!(po.header.bits_page_length_delta >= 8);
assert_eq!(bits_needed(130), 8);
}
#[test]
fn adjusted_offset_adds_h_length_at_or_above_h_offset() {
let p = LinParameters {
file_size: 0,
first_page_object: 0,
first_page_end: 0,
npages: 0,
xref_zero_offset: 0,
first_page: 0,
h_offset: 100,
h_length: 50,
h_overflow_offset: 0,
h_overflow_length: 0,
};
assert_eq!(p.adjusted_offset(99), 99); assert_eq!(p.adjusted_offset(100), 150); assert_eq!(p.adjusted_offset(200), 250); }
#[test]
fn outlines_section_emitted_only_when_nobjects_positive() {
let p = LinParameters {
file_size: 10,
first_page_object: 1,
first_page_end: 5,
npages: 1,
xref_zero_offset: 8,
first_page: 0,
h_offset: 100,
h_length: 50,
h_overflow_offset: 0,
h_overflow_length: 0,
};
let po = HPageOffset {
min_nobjects: 1,
first_page_offset: 0,
nbits_delta_nobjects: 0,
min_page_length: 0,
nbits_delta_page_length: 0,
min_content_offset: 0,
nbits_delta_content_offset: 0,
min_content_length: 0,
nbits_delta_content_length: 0,
nbits_nshared_objects: 0,
nbits_shared_identifier: 0,
nbits_shared_numerator: 0,
shared_denominator: 4,
entries: vec![HPageOffsetEntry {
delta_nobjects: 0,
delta_page_length: 0,
nshared_objects: 0,
shared_identifiers: vec![],
shared_numerators: vec![],
delta_content_offset: 0,
delta_content_length: 0,
}],
};
let so = HSharedObject {
first_shared_obj: 0,
first_shared_offset: 0,
nshared_first_page: 0,
nshared_total: 0,
nbits_nobjects: 0,
min_group_length: 0,
nbits_delta_group_length: 0,
entries: vec![],
};
let empty_outline = HGeneric {
first_object: 0,
first_object_offset: 0,
nobjects: 0,
group_length: 0,
};
let dump_no_outline = format_dump(b"f.pdf", &p, &po, &so, Some(&empty_outline));
assert!(!dump_no_outline
.windows(b"Outlines Hint Table".len())
.any(|window| { window == b"Outlines Hint Table" }));
let outline = HGeneric {
first_object: 30,
first_object_offset: 120, nobjects: 2,
group_length: 99,
};
let dump_outline = format_dump(b"f.pdf", &p, &po, &so, Some(&outline));
assert!(dump_outline
.windows(b"\nOutlines Hint Table\n\n".len())
.any(|window| window == b"\nOutlines Hint Table\n\n"));
assert!(dump_outline
.windows(b"first_object: 30\n".len())
.any(|window| window == b"first_object: 30\n"));
assert!(dump_outline
.windows(b"first_object_offset: 170\n".len())
.any(|window| window == b"first_object_offset: 170\n"));
assert!(dump_outline
.windows(b"nobjects: 2\n".len())
.any(|window| window == b"nobjects: 2\n"));
assert!(dump_outline
.windows(b"group_length: 99\n".len())
.any(|window| window == b"group_length: 99\n"));
}
#[test]
fn shared_object_conditional_lines() {
let p = LinParameters {
file_size: 0,
first_page_object: 0,
first_page_end: 0,
npages: 0,
xref_zero_offset: 0,
first_page: 0,
h_offset: 0,
h_length: 0,
h_overflow_offset: 0,
h_overflow_length: 0,
};
let t = HSharedObject {
first_shared_obj: 0,
first_shared_offset: 0,
nshared_first_page: 2,
nshared_total: 2,
nbits_nobjects: 1,
min_group_length: 10,
nbits_delta_group_length: 0,
entries: vec![
HSharedObjectEntry {
delta_group_length: 0,
signature_present: true,
nobjects_minus_one: 2,
},
HSharedObjectEntry {
delta_group_length: 5,
signature_present: false,
nobjects_minus_one: 0,
},
],
};
let mut out = String::new();
dump_shared_object(&mut out, &p, &t);
assert!(out.contains(
"Shared Object 0:\n group length: 10\n signature present\n nobjects: 3\n"
));
assert!(out.contains("Shared Object 1:\n group length: 15\n"));
assert!(!out.contains("Shared Object 1:\n group length: 15\n signature present"));
}
#[test]
fn shared_object_signature_present_skips_128_bits() {
let nbits_delta_group_length = 4u32;
let nbits_nobjects = 4u32;
let nshared_total = 2u32;
let buf = bit_writer_bytes(|writer| {
writer.write_bits(1, 32)?; writer.write_bits(0, 32)?; writer.write_bits(2, 32)?; writer.write_bits(nshared_total as u64, 32)?; writer.write_bits(nbits_nobjects as u64, 16)?; writer.write_bits(0, 32)?; writer.write_bits(nbits_delta_group_length as u64, 16)?; writer.write_bits(3, nbits_delta_group_length as usize)?;
writer.write_bits(9, nbits_delta_group_length as usize)?;
writer.flush()?;
writer.write_bits(1, 1)?;
writer.write_bits(0, 1)?;
writer.flush()?;
for _ in 0..4 {
writer.write_bits(0xDEAD_BEEF, 32)?;
}
writer.write_bits(5, nbits_nobjects as usize)?;
writer.write_bits(7, nbits_nobjects as usize)?;
writer.flush()
});
let decoded = read_h_shared_object(&buf).expect("decode");
assert!(decoded.entries[0].signature_present);
assert_eq!(decoded.entries[0].delta_group_length, 3);
assert_eq!(decoded.entries[0].nobjects_minus_one, 5);
assert!(!decoded.entries[1].signature_present);
assert_eq!(decoded.entries[1].delta_group_length, 9);
assert_eq!(decoded.entries[1].nobjects_minus_one, 7);
}
#[test]
fn shared_object_oversized_nshared_total_reports_bitstream_exhaustion() {
let buf = bit_writer_bytes(|writer| {
writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(1_000_000, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(12_556, 16) });
assert_eq!(buf.len(), 24, "header is exactly 24 bytes, no column data");
assert!(matches!(
read_h_shared_object(&buf),
Err(ShowLinearizationError::Malformed { message })
if message == "overflow reading bit stream: wanted = 12556; available = 0"
));
}
#[test]
fn shared_object_zero_width_column_defers_to_bit_stream_overflow() {
let buf = bit_writer_bytes(|writer| {
writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(32, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16) });
assert_eq!(buf.len(), 24, "header is exactly 24 bytes, no column data");
let result = read_h_shared_object(&buf);
assert!(result.is_err(), "signature column must exhaust input");
let error = result.err().unwrap();
assert_eq!(
error.to_string(),
"malformed linearization data: overflow reading bit stream: wanted = 1; available = 0"
);
}
#[test]
fn page_offset_oversized_nshared_objects_reports_bitstream_exhaustion() {
let buf = bit_writer_bytes(|writer| {
writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(32, 16)?; writer.write_bits(1, 16)?; writer.write_bits(0, 16)?; writer.write_bits(1, 16)?; writer.write_bits(1_000_000, 32)?;
writer.flush()
});
assert_eq!(
buf.len(),
40,
"36-byte header + 4-byte nshared_objects column"
);
assert!(matches!(
read_h_page_offset(&buf, 1),
Err(ShowLinearizationError::Malformed { message })
if message == "overflow reading bit stream: wanted = 1; available = 0"
));
}
#[test]
fn page_offset_zero_width_shared_columns_keep_declared_entries() {
let buf = bit_writer_bytes(|writer| {
writer.write_bits(0, 32)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(0, 32)?; writer.write_bits(0, 16)?; writer.write_bits(32, 16)?; writer.write_bits(0, 16)?; writer.write_bits(0, 16)?; writer.write_bits(1, 16)?; writer.write_bits(32, 32)?;
writer.flush()
});
assert_eq!(
buf.len(),
40,
"36-byte header + 4-byte nshared_objects column"
);
let decoded = read_h_page_offset(&buf, 1).expect("zero-width columns are qpdf-valid");
assert_eq!(decoded.entries[0].nshared_objects, 32);
assert_eq!(decoded.entries[0].shared_identifiers, vec![0; 32]);
assert_eq!(decoded.entries[0].shared_numerators, vec![0; 32]);
}
#[test]
fn truncated_hint_uses_bit_stream_error_text() {
let err = read_h_page_offset(&[0xff], 1)
.err()
.expect("truncated hint must fail");
assert!(err.to_string().contains("overflow reading bit stream"));
}
fn non_linearized_pdf() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn show_bytes_reports_non_linearized_as_ok_line() {
let pdf = non_linearized_pdf();
let out = show_linearization_bytes(&pdf, "x.pdf").expect("not-linearized is Ok");
assert_eq!(out, "x.pdf is not linearized\n");
}
#[test]
fn show_bytes_first_object_not_a_dict_is_not_linearized() {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n42\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Catalog /Pages 3 0 R >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Kids [4 0 R] /Count 1 >>\nendobj\n");
let off4 = pdf.len();
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n{off4:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 2 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let out = show_linearization_bytes(&pdf, "intfirst.pdf").expect("not-linearized is Ok");
assert_eq!(out, "intfirst.pdf is not linearized\n");
}
#[test]
fn param_u64_rejects_fractional() {
let d = ObjectHandle::dictionary(vec![(b"/N".to_vec(), ObjectHandle::real(1.5))]);
assert!(matches!(
param_u64(&d, "N"),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn param_u64_rejects_real_literal_whole_number() {
let d = ObjectHandle::dictionary(vec![(
b"/N".to_vec(),
ObjectHandle::real_literal(5.0, b"5.0".to_vec()),
)]);
assert!(matches!(
param_u64(&d, "N"),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn param_u64_rejects_fractional_real_literal() {
let d = ObjectHandle::dictionary(vec![(
b"/N".to_vec(),
ObjectHandle::real_literal(1.5, b"1.5".to_vec()),
)]);
assert!(matches!(
param_u64(&d, "N"),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn parse_obj_header_basic() {
assert_eq!(
parse_obj_header(b"7 0 obj\n<<>>"),
Some(ObjectRef::new(7, 0))
);
assert_eq!(parse_obj_header(b"not an obj"), None);
}
#[test]
fn read_h_generic_decodes_four_fields() {
let buf = bit_writer_bytes(|writer| {
writer.write_bits(11, 32)?; writer.write_bits(222, 32)?; writer.write_bits(3, 32)?; writer.write_bits(4444, 32) });
let g = read_h_generic(&buf).expect("decode generic");
assert_eq!(g.first_object, 11);
assert_eq!(g.first_object_offset, 222);
assert_eq!(g.nobjects, 3);
assert_eq!(g.group_length, 4444);
}
#[test]
fn read_h_generic_truncated_errors() {
assert!(read_h_generic(&[0u8; 4]).is_err());
}
#[test]
fn error_display_and_from_conversions() {
let m = ShowLinearizationError::Malformed {
message: "boom".into(),
};
assert_eq!(format!("{m}"), "malformed linearization data: boom");
let io: ShowLinearizationError = std::io::Error::other("disk gone").into();
assert!(matches!(io, ShowLinearizationError::Io(_)));
assert!(format!("{io}").starts_with("I/O error: "));
let core: ShowLinearizationError = crate::Error::Missing("X").into();
assert!(matches!(core, ShowLinearizationError::Io(_)));
}
use crate::linearization::plan::LinearizationPlan;
use crate::linearization::renumber::RenumberMap;
use crate::linearization::writer::write_linearized;
use crate::writer::WriterOptions;
use crate::Pdf;
use std::io::Cursor;
fn tiny_source() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn linearized_bytes() -> Vec<u8> {
let raw = tiny_source();
let mut pdf = Pdf::open(Cursor::new(raw.clone())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = Pdf::open(Cursor::new(raw)).unwrap();
let mut doc =
write_linearized(&plan, &renumber, &mut pdf2, &WriterOptions::default()).unwrap();
doc.back_patch().unwrap();
doc.bytes
}
fn compat_linearized_bytes() -> Vec<u8> {
std::fs::read(
std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/linearized-one-page.pdf"),
)
.expect("linearized fixture")
}
fn replace_numeric_value(bytes: &mut [u8], key: &[u8], replacement: &[u8]) {
let key_pos = bytes
.windows(key.len())
.position(|window| window == key)
.expect("linearization numeric key");
let mut start = key_pos + key.len();
while bytes[start].is_ascii_whitespace() {
start += 1;
}
let end = start
+ bytes[start..]
.iter()
.position(|&byte| byte.is_ascii_whitespace())
.expect("/H[0] value");
assert!(replacement.len() <= end - start);
let mut padded = vec![b' '; end - start];
padded[..replacement.len()].copy_from_slice(replacement);
bytes[start..end].copy_from_slice(&padded);
}
fn replace_hint_offset(bytes: &mut [u8], replacement: &[u8]) {
replace_numeric_value(bytes, b"/H [", replacement);
}
#[test]
fn show_linearized_happy_path_produces_dump() {
let bytes = linearized_bytes();
let out = show_linearization_bytes(&bytes, "lin.pdf").expect("dump");
assert!(out.starts_with("lin.pdf: linearization data:\n\n"));
assert!(out.contains("\nPage Offsets Hint Table\n\n"));
assert!(out.contains("\nShared Objects Hint Table\n\n"));
assert!(out.contains("Page 0:\n"));
assert!(!out.contains("Page 1:\n"));
}
#[test]
fn show_continues_past_a_qpdf_soft_check_mismatch() {
let mut bytes = linearized_bytes();
let key_pos = bytes
.windows(3)
.position(|window| window == b"/O ")
.expect("/O key");
let start = key_pos + 3;
let end = start
+ bytes[start..]
.iter()
.position(|&byte| !byte.is_ascii_digit())
.expect("/O numeric value");
let width = end - start;
let mut padded = vec![b' '; width];
padded[0] = b'0';
bytes[start..end].copy_from_slice(&padded);
let check_result = super::super::check::check_linearization_bytes(&bytes);
assert!(
check_result.is_err(),
"tampered /O must still fail the standalone check"
);
let out = show_linearization_bytes(&bytes, "tampered.pdf")
.expect("show must still produce a dump despite the /O mismatch");
assert!(out.starts_with("tampered.pdf: linearization data:\n\n"));
assert!(out.contains("\nPage Offsets Hint Table\n\n"));
assert!(out.contains("\nShared Objects Hint Table\n\n"));
}
#[test]
fn show_loads_the_four_item_overflow_hint_stream() {
let bytes = std::fs::read(
std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/linearized-one-page.pdf"),
)
.expect("linearized fixture");
let bytes = crate::linearization::check::add_overflow_hint_items_for_test(bytes);
let out = show_linearization_bytes(&bytes, "overflow.pdf").expect("overflow dump");
assert!(out.starts_with("overflow.pdf: linearization data:\n\n"));
}
fn deflate_compress(data: &[u8]) -> Vec<u8> {
let mut sink = Buffer::new("test overflow hint compress", None);
{
let mut flate = crate::pipeline::flate::Flate::new(
"test overflow hint compress",
&mut sink,
crate::pipeline::flate::FlateAction::Deflate,
crate::pipeline::flate::DEFAULT_OUT_BUFFER_SIZE,
)
.expect("flate init");
flate.write(data).expect("flate write");
flate.finish().expect("flate finish");
}
sink.take_buffer().expect("compressed buffer")
}
fn split_overflow_pdf_bytes() -> Vec<u8> {
let po = PageOffsetHintTable {
header: PageOffsetHeader {
least_object_count: 1,
location_of_first_page: 100,
bits_object_count_delta: 8,
least_page_length: 10,
bits_page_length_delta: 8,
least_content_offset: 0,
bits_content_offset_delta: 8,
least_content_length: 10,
bits_content_length_delta: 8,
bits_shared_object_count: 8,
bits_shared_object_id: 8,
bits_numerator: 8,
denominator: 4,
},
entries: vec![PageOffsetEntry {
object_count_minus_least: 0,
page_length_minus_least: 0,
shared_object_count: 0,
shared_object_ids: vec![],
shared_object_numerators: vec![],
content_stream_offset: 0,
content_stream_length: 0,
}],
};
let so = SharedObjectHintTable {
header: SharedObjectHeader {
first_object_number: 5,
location: 200,
first_page_entries: 0,
section_entries: 2,
bits_group_object_count: 0,
least_length: 10,
bits_length_delta: 8,
},
objects: vec![
SharedObjectEntry {
length_minus_least: 5,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
SharedObjectEntry {
length_minus_least: 20,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
],
};
let encoded = encode_hint_stream(&po, &so, None).expect("encode split hint tables");
let split = encoded.shared_section_offset_in_uncompressed;
assert!(
split > 0 && split < encoded.uncompressed.len(),
"fixture must have non-empty page and shared sections either side of /S"
);
let (page_section, shared_section) = encoded.uncompressed.split_at(split);
let primary_compressed = deflate_compress(page_section);
let overflow_compressed = deflate_compress(shared_section);
const WIDTH: usize = 10;
fn push_placeholder(bytes: &mut Vec<u8>, slots: &mut Vec<(usize, usize)>) {
let start = bytes.len();
bytes.extend(std::iter::repeat_n(b'0', WIDTH));
slots.push((start, bytes.len()));
}
fn patch(bytes: &mut [u8], slot: (usize, usize), value: u64) {
let text = format!("{value:0width$}", width = WIDTH);
bytes[slot.0..slot.1].copy_from_slice(text.as_bytes());
}
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.4\n");
let mut slots = Vec::new(); bytes.extend_from_slice(b"1 0 obj\n<< /Linearized 1 /L ");
push_placeholder(&mut bytes, &mut slots); bytes.extend_from_slice(b" /H [");
push_placeholder(&mut bytes, &mut slots); bytes.push(b' ');
push_placeholder(&mut bytes, &mut slots); bytes.push(b' ');
push_placeholder(&mut bytes, &mut slots); bytes.push(b' ');
push_placeholder(&mut bytes, &mut slots); bytes.extend_from_slice(b"] /O 4 /E ");
push_placeholder(&mut bytes, &mut slots); bytes.extend_from_slice(b" /N 1 /T ");
push_placeholder(&mut bytes, &mut slots); bytes.extend_from_slice(b" /P 0 >>\nendobj\n");
let off2 = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Catalog /Pages 3 0 R >>\nendobj\n");
let off3 = bytes.len();
bytes.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Kids [4 0 R] /Count 1 >>\nendobj\n");
let off4 = bytes.len();
bytes.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let h0_offset = bytes.len();
bytes.extend_from_slice(
format!(
"5 0 obj\n<< /Length {} /Filter /FlateDecode /S {split} >>\nstream\n",
primary_compressed.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&primary_compressed);
bytes.extend_from_slice(b"\nendstream\nendobj");
let h0_length = (bytes.len() - h0_offset) as u64;
bytes.push(b'\n');
let off5 = bytes.len();
let h1_offset = bytes.len();
bytes.extend_from_slice(
format!(
"6 0 obj\n<< /Length {} /Filter /FlateDecode >>\nstream\n",
overflow_compressed.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&overflow_compressed);
bytes.extend_from_slice(b"\nendstream\nendobj");
let h1_length = (bytes.len() - h1_offset) as u64;
bytes.push(b'\n');
let xref_start = bytes.len();
let xref = format!(
"xref\n0 7\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n\
{:010} 00000 n \n{h0_offset:010} 00000 n \n{off5:010} 00000 n \n",
9, off2, off3, off4,
);
bytes.extend_from_slice(xref.as_bytes());
bytes.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 2 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let file_len = bytes.len() as u64;
patch(&mut bytes, slots[0], file_len); patch(&mut bytes, slots[1], h0_offset as u64);
patch(&mut bytes, slots[2], h0_length);
patch(&mut bytes, slots[3], h1_offset as u64);
patch(&mut bytes, slots[4], h1_length);
patch(&mut bytes, slots[5], 0); patch(&mut bytes, slots[6], 0);
bytes
}
#[test]
fn show_merges_a_genuine_two_stream_overflow_hint_table() {
let bytes = split_overflow_pdf_bytes();
let out = show_linearization_bytes(&bytes, "split.pdf")
.expect("genuinely split /H overflow stream must merge into one dump");
assert!(out.contains("\nShared Objects Hint Table\n\n"));
assert!(out.contains("Shared Object 0:\n"));
assert!(out.contains("Shared Object 1:\n"));
assert!(out.contains("group length: 15\n"));
assert!(out.contains("group length: 30\n"));
}
#[test]
fn show_reports_a_corrupted_overflow_hint_stream_as_malformed() {
let mut bytes = split_overflow_pdf_bytes();
let obj6 = bytes
.windows(b"6 0 obj".len())
.position(|window| window == b"6 0 obj")
.expect("overflow hint stream object header");
let stream_start = bytes[obj6..]
.windows(b"stream\n".len())
.position(|window| window == b"stream\n")
.map(|relative| obj6 + relative + b"stream\n".len())
.expect("overflow stream keyword");
bytes[stream_start + 1] ^= 0xFF;
let result = show_linearization_bytes_with_warnings(&bytes, "split-corrupt.pdf")
.expect("a corrupted overflow hint stream is a qpdf warning, not a hard error");
assert!(result.dump.is_empty());
assert_eq!(result.warnings.len(), 1, "warnings: {:?}", result.warnings);
}
#[test]
fn show_linearization_path_round_trips_via_tempfile() {
let bytes = linearized_bytes();
let dir = std::env::temp_dir();
let path = dir.join(format!("flpdf-show-test-{}.pdf", std::process::id()));
std::fs::write(&path, &bytes).unwrap();
let out = show_linearization_path(&path).expect("path dump");
let _ = std::fs::remove_file(&path);
assert!(out.contains(": linearization data:\n\n"));
assert!(out.contains(&*path.to_string_lossy()));
}
#[test]
fn show_linearization_path_missing_file_is_io_error() {
let path = std::path::Path::new("/nonexistent/flpdf/definitely/missing.pdf");
assert!(matches!(
show_linearization_path(path),
Err(ShowLinearizationError::Io(_))
));
}
#[test]
fn bad_l_value_is_not_linearized() {
let mut bytes = linearized_bytes();
let pos = bytes.windows(3).position(|w| w == b"/L ").expect("/L");
let dstart = pos + 3;
let dend = dstart
+ bytes[dstart..]
.iter()
.position(|&b| !b.is_ascii_digit())
.unwrap();
let last = dend - 1;
bytes[last] ^= 1;
let out = show_linearization_bytes(&bytes, "badL.pdf").expect("not-linearized is Ok");
assert_eq!(out, "badL.pdf is not linearized\n");
}
#[test]
fn t_position_mismatch_is_a_warning_with_dump_intact() {
let mut bytes = linearized_bytes();
let pos = bytes.windows(3).position(|w| w == b"/T ").expect("/T");
let dstart = pos + 3;
let dend = dstart
+ bytes[dstart..]
.iter()
.position(|&b| !b.is_ascii_digit())
.expect("/T numeric value");
let width = dend - dstart;
bytes[dstart..dend].copy_from_slice(&vec![b'0'; width]);
let result = show_linearization_bytes_with_warnings(&bytes, "badT.pdf")
.expect("a /T position mismatch is a warning, not a hard error");
assert!(result
.dump
.starts_with(b"badT.pdf: linearization data:\n\n"));
assert!(result
.dump
.windows(b"\nPage Offsets Hint Table\n\n".len())
.any(|window| window == b"\nPage Offsets Hint Table\n\n"));
assert_eq!(result.warnings.len(), 1);
assert!(
String::from_utf8_lossy(&result.warnings[0])
.contains("space before first xref item (/T) mismatch")
&& String::from_utf8_lossy(&result.warnings[0]).contains("file = 0"),
"unexpected warning: {:?}",
result.warnings
);
}
#[test]
fn hint_stream_s_offset_out_of_bounds_is_a_warning_with_no_dump() {
let mut bytes = linearized_bytes();
let s_pos = bytes.windows(3).position(|w| w == b"/S ").expect("hint /S");
let dstart = s_pos + 3;
let dend = dstart
+ bytes[dstart..]
.iter()
.position(|&b| !b.is_ascii_digit())
.expect("/S numeric value");
bytes[dstart..dend].copy_from_slice(b"99");
let result = show_linearization_bytes_with_warnings(&bytes, "badS.pdf")
.expect("an out-of-bounds /S is a qpdf warning, not a hard error");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[b"badS.pdf (linearization hint table, offset 568): /S (shared object) offset is out of bounds".to_vec()]
);
}
#[test]
fn compat_hint_stream_s_offset_uses_qpdf_source_offset() {
let mut bytes = compat_linearized_bytes();
replace_numeric_value(&mut bytes, b"/S ", b"99");
let result = show_linearization_bytes_with_warnings(&bytes, "compatS.pdf")
.expect("an out-of-bounds /S is a qpdf warning");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[b"compatS.pdf (linearization hint table, offset 660): /S (shared object) offset is out of bounds".to_vec()]
);
}
#[test]
fn hint_stream_header_failure_uses_qpdf_damage_context() {
let mut bytes = compat_linearized_bytes();
replace_hint_offset(&mut bytes, b"999");
let result = show_linearization_bytes_with_warnings(&bytes, "badH.pdf")
.expect("a bad hint-stream header is a qpdf warning");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[b"badH.pdf (linearization hint stream, offset 999): expected n n obj".to_vec()]
);
}
#[test]
fn non_stream_hint_object_uses_qpdf_dictionary_damage_context() {
let mut bytes = compat_linearized_bytes();
replace_hint_offset(&mut bytes, b"533");
let result = show_linearization_bytes_with_warnings(&bytes, "badHn.pdf")
.expect("a non-stream hint object is a qpdf warning");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[
b"badHn.pdf (linearization dictionary, offset 594): hint table is not a stream"
.to_vec()
]
);
}
#[test]
fn non_stream_hint_short_trailing_token_uses_qpdf_read_offset() {
let mut bytes = compat_linearized_bytes();
let s_pos = bytes.windows(3).position(|w| w == b"/S ").expect("hint /S");
let stream_pos = bytes[s_pos..]
.windows(7)
.position(|w| w == b"stream\n")
.map(|position| s_pos + position)
.expect("hint stream keyword");
bytes[stream_pos..stream_pos + 7].copy_from_slice(b"bad \n");
let result = show_linearization_bytes_with_warnings(&bytes, "short-trailing.pdf")
.expect("a non-endobj trailing token is a qpdf warning");
assert_eq!(
result.warnings,
[
b"short-trailing.pdf (linearization dictionary, offset 653): hint table is not a stream"
.to_vec()
]
);
}
#[test]
fn cached_non_stream_hint_short_trailing_token_uses_token_start() {
let mut bytes = compat_linearized_bytes();
let s_pos = bytes.windows(3).position(|w| w == b"/S ").expect("hint /S");
let stream_pos = bytes[s_pos..]
.windows(7)
.position(|w| w == b"stream\n")
.map(|position| s_pos + position)
.expect("hint stream keyword");
bytes[stream_pos..stream_pos + 7].copy_from_slice(b"bad \n");
let mut pdf = Pdf::open_mem_owned(bytes.clone()).expect("fixture should open");
let (_, first_offset) = pdf
.resolve_at_offset_with_description(
601,
ObjectRef::new(5, 0),
b"linearization hint stream",
)
.expect("first offset read should succeed");
assert_eq!(first_offset, Some(653));
let error = load_hint_stream_with_damage(&mut pdf, &bytes, 601, 118)
.expect_err("a cached non-stream hint object is damaged");
match error {
HintStreamLoadError::Damage(damage) => assert_eq!(damage.offset, 653),
HintStreamLoadError::Core(error) => {
panic!("unexpected core error: {error}")
} }
}
#[test]
fn uncached_non_stream_hint_short_trailing_token_uses_end_after_space() {
let mut bytes = compat_linearized_bytes();
replace_hint_offset(&mut bytes, b"908");
let result = show_linearization_bytes_with_warnings(&bytes, "uncached-trailing.pdf")
.expect("an uncached non-stream hint object is a qpdf warning");
assert_eq!(
result.warnings,
[
b"uncached-trailing.pdf (linearization dictionary, offset 932): hint table is not a stream"
.to_vec()
]
);
}
#[test]
fn missing_required_key_is_malformed() {
let mut bytes = linearized_bytes();
let pos = bytes.windows(3).position(|w| w == b"/N ").expect("/N");
bytes[pos + 1] = b'Z';
let result = show_linearization_bytes_with_warnings(&bytes, "noN.pdf")
.expect("missing /N is a qpdf warning");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[b"noN.pdf (linearization dictionary, offset 23): some keys in linearization dictionary are of the wrong type".to_vec()]
);
}
#[test]
fn h_three_items_matches_qpdf_full_warning_context() {
let mut bytes = linearized_bytes();
let h = bytes
.windows(b"/H [".len())
.position(|w| w == b"/H [")
.unwrap();
let end = h + bytes[h..].iter().position(|&byte| byte == b']').unwrap();
let original = &bytes[h..=end];
let replacement = b"/H [ 509 1 15]";
assert_eq!(replacement.len(), original.len());
bytes[h..=end].copy_from_slice(replacement);
let file = tempfile::NamedTempFile::new().expect("temporary H3 PDF");
std::fs::write(file.path(), &bytes).expect("write H3 PDF");
let version = match std::process::Command::new("qpdf").arg("--version").output() {
Ok(output) => String::from_utf8_lossy(&output.stdout).into_owned(),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
eprintln!("qpdf 11.9.0 unavailable; skipping external H3 oracle");
return;
}
Err(error) => panic!("failed to run qpdf --version: {error}"),
};
if !version.contains("11.9.0") {
eprintln!("qpdf 11.9.0 unavailable; found {version:?}; skipping external H3 oracle");
return;
}
let qpdf = std::process::Command::new("qpdf")
.arg("--show-linearization")
.arg(file.path())
.output()
.expect("qpdf 11.9.0 oracle");
assert_eq!(qpdf.status.code(), Some(3));
assert_eq!(qpdf.stdout, b"");
let expected_qpdf_stderr = format!(
"WARNING: {}: {} (linearization dictionary, offset 23): H has the wrong number of items\nqpdf: operation succeeded with warnings\n",
file.path().display(),
file.path().display()
);
let qpdf_stderr = String::from_utf8_lossy(&qpdf.stderr).replace("\r\n", "\n");
assert_eq!(qpdf_stderr.as_bytes(), expected_qpdf_stderr.as_bytes());
let result = show_linearization_bytes_with_warnings(&bytes, "h3.pdf")
.expect("qpdf catches malformed H as a warning");
assert!(result.dump.is_empty());
assert_eq!(
result.warnings,
[
b"h3.pdf (linearization dictionary, offset 23): H has the wrong number of items"
.to_vec()
]
);
}
#[test]
fn decode_failure_is_malformed() {
let mut bytes = linearized_bytes();
let s_pos = bytes.windows(3).position(|w| w == b"/S ").expect("hint /S");
let stream_kw = bytes[s_pos..]
.windows(7)
.position(|w| w == b"stream\n")
.map(|p| s_pos + p + 7)
.expect("stream keyword after hint dict");
bytes[stream_kw + 4] ^= 0xFF;
let result = show_linearization_bytes_with_warnings(&bytes, "badhint.pdf")
.expect("a corrupted hint stream is a qpdf warning, not a hard error");
assert!(result.dump.is_empty());
assert_eq!(result.warnings.len(), 1, "warnings: {:?}", result.warnings);
}
#[test]
fn show_consumer_production_uses_the_canonical_object_handle_route() {
let source = include_str!("show.rs");
let production = source
.split("#[cfg(test)]")
.next()
.expect("show.rs has a test module")
.lines()
.filter(|line| !line.trim_start().starts_with("//"))
.collect::<Vec<_>>()
.join("\n");
for forbidden in [
"resolve_borrowed(",
"decode_stream_data(",
"page_refs(",
"Object::",
] {
assert!(
!production.contains(forbidden),
"show.rs production must not use legacy {forbidden} route"
);
}
}
fn full_param_dict() -> ObjectHandle {
ObjectHandle::dictionary(vec![
(b"/O".to_vec(), ObjectHandle::integer(8)),
(b"/E".to_vec(), ObjectHandle::integer(1212)),
(b"/N".to_vec(), ObjectHandle::integer(2)),
(b"/T".to_vec(), ObjectHandle::integer(1885)),
(
b"/H".to_vec(),
ObjectHandle::array(vec![ObjectHandle::integer(601), ObjectHandle::integer(128)]),
),
])
}
#[test]
fn read_lin_parameters_happy() {
let d = full_param_dict();
d.replace_key(b"/P", ObjectHandle::integer(0)).unwrap();
let p = read_lin_parameters(&d, 2103).unwrap();
assert_eq!(p.file_size, 2103);
assert_eq!(p.first_page_object, 8);
assert_eq!(p.first_page_end, 1212);
assert_eq!(p.npages, 2);
assert_eq!(p.xref_zero_offset, 1885);
assert_eq!(p.first_page, 0);
assert_eq!(p.h_offset, 601);
assert_eq!(p.h_length, 128);
}
#[test]
fn read_lin_parameters_default_first_page_when_p_absent() {
let p = read_lin_parameters(&full_param_dict(), 2103).unwrap();
assert_eq!(p.first_page, 0, "/P absent defaults to 0");
}
#[test]
fn read_lin_parameters_p_wrong_type_is_malformed() {
let d = full_param_dict();
d.replace_key(b"/P", ObjectHandle::name(b"oops".to_vec()))
.unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h_too_short_is_malformed() {
let d = full_param_dict();
d.replace_key(b"/H", ObjectHandle::array(vec![ObjectHandle::integer(601)]))
.unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_rejects_non_integer_deeper_parameter() {
let d = full_param_dict();
d.replace_key(b"/N", ObjectHandle::real(2.0)).unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_rejects_three_item_hint_array() {
let d = full_param_dict();
d.replace_key(
b"/H",
ObjectHandle::array(vec![
ObjectHandle::integer(601),
ObjectHandle::integer(128),
ObjectHandle::integer(0),
]),
)
.unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_accepts_the_four_item_overflow_hint_array() {
let d = full_param_dict();
d.replace_key(
b"/H",
ObjectHandle::array(vec![
ObjectHandle::integer(601),
ObjectHandle::integer(128),
ObjectHandle::integer(1700),
ObjectHandle::integer(64),
]),
)
.unwrap();
let p = read_lin_parameters(&d, 2103).expect("qpdf accepts a four-item /H array");
assert_eq!(p.h_offset, 601);
assert_eq!(p.h_length, 128);
}
#[test]
fn read_lin_parameters_h_not_array_is_malformed() {
let d = full_param_dict();
d.replace_key(b"/H", ObjectHandle::integer(5)).unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h0_wrong_type_is_malformed() {
let d = full_param_dict();
d.replace_key(
b"/H",
ObjectHandle::array(vec![
ObjectHandle::name(b"x".to_vec()),
ObjectHandle::integer(128),
]),
)
.unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h1_wrong_type_is_malformed() {
let d = full_param_dict();
d.replace_key(
b"/H",
ObjectHandle::array(vec![
ObjectHandle::integer(601),
ObjectHandle::name(b"x".to_vec()),
]),
)
.unwrap();
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_hint_offsets_happy_and_outline() {
let d = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::integer(36)),
(b"/O".to_vec(), ObjectHandle::integer(72)),
]);
assert_eq!(read_hint_offsets(&d).unwrap(), (36, Some(72)));
let d2 = ObjectHandle::dictionary(vec![(b"/S".to_vec(), ObjectHandle::integer(36))]);
assert_eq!(read_hint_offsets(&d2).unwrap(), (36, None));
}
#[test]
fn read_hint_offsets_missing_s_is_malformed() {
let d = ObjectHandle::dictionary(Vec::new());
assert!(matches!(
read_hint_offsets(&d),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_hint_offsets_negative_outline_is_malformed() {
let d = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::integer(36)),
(b"/O".to_vec(), ObjectHandle::integer(-1)),
]);
assert!(matches!(
read_hint_offsets(&d),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn parse_obj_header_negative_branches() {
assert_eq!(parse_obj_header(b""), None); assert_eq!(parse_obj_header(b"7"), None); assert_eq!(parse_obj_header(b"7 "), None); assert_eq!(parse_obj_header(b"7 0"), None); assert_eq!(parse_obj_header(b"7 0 "), None); assert_eq!(parse_obj_header(b"7 0 xyz"), None); assert_eq!(parse_obj_header(b"7 x obj"), None); assert_eq!(parse_obj_header(b" 7 0 obj"), Some(ObjectRef::new(7, 0)));
}
#[test]
fn is_linearized_accepts_integer_and_real_one() {
let d = ObjectHandle::dictionary(vec![(b"/Linearized".to_vec(), ObjectHandle::integer(1))]);
assert!(is_linearized(&d, 100).unwrap());
let d2 = ObjectHandle::dictionary(vec![(b"/Linearized".to_vec(), ObjectHandle::real(1.0))]);
assert!(is_linearized(&d2, 100).unwrap());
}
#[test]
fn is_linearized_rejects_missing_or_wrong_linearized() {
assert!(!is_linearized(&ObjectHandle::dictionary(Vec::new()), 100).unwrap());
let d = ObjectHandle::dictionary(vec![(b"/Linearized".to_vec(), ObjectHandle::integer(0))]);
assert!(!is_linearized(&d, 100).unwrap());
}
#[test]
fn is_linearized_rejects_l_mismatch() {
let d = ObjectHandle::dictionary(vec![
(b"/Linearized".to_vec(), ObjectHandle::integer(1)),
(b"/L".to_vec(), ObjectHandle::integer(999)),
]);
assert!(!is_linearized(&d, 100).unwrap());
d.replace_key(b"/L", ObjectHandle::integer(100)).unwrap();
assert!(is_linearized(&d, 100).unwrap());
}
#[test]
fn show_bytes_dict_without_linearized_is_not_linearized() {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let out = show_linearization_bytes(&pdf, "plain.pdf").expect("not-linearized is Ok");
assert_eq!(out, "plain.pdf is not linearized\n");
}
}