use std::collections::VecDeque;
use crate::object_handle::{DocumentResolver, ObjectHandle, ObjectValue, NO_PARSED_OFFSET};
use crate::tokenizer::{is_delimiter, is_ws, Token, TokenType, Tokenizer};
use crate::{Error, ObjectRef, QpdfErrorCode, QpdfExc, Result};
use std::rc::{Rc, Weak};
pub(crate) trait HandleResolver {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle;
fn indirect_handle_at(&mut self, object_ref: ObjectRef, offset: i64) -> ObjectHandle {
let _ = offset;
self.indirect_handle(object_ref)
}
fn direct_handle(&mut self, value: ObjectValue) -> ObjectHandle {
ObjectHandle::from_value(value)
}
fn direct_handle_at(&mut self, value: ObjectValue, offset: i64) -> ObjectHandle {
let handle = self.direct_handle(value);
if let Some(description) = self.description_template() {
handle.set_shared_description(description, offset);
} else {
handle.set_parsed_offset_if_unset(offset);
}
handle
}
fn description_template(&self) -> Option<Rc<Vec<u8>>> {
None
}
fn contextless_warning_object_description(&self) -> Option<Vec<u8>> {
None
}
fn begin_parse(&self) -> Result<()> {
Ok(())
}
fn end_parse(&self) {}
}
pub(crate) trait StringDecrypter {
fn decrypt_string(&mut self, bytes: &mut Vec<u8>) -> Result<()>;
}
pub(crate) trait LiveInput {
fn tell(&mut self) -> Result<u64>;
fn seek(&mut self, offset: u64) -> Result<()>;
fn read_byte(&mut self) -> Result<Option<u8>>;
fn unread_byte(&mut self) -> Result<()>;
fn set_last_offset(&mut self, _offset: u64) {}
}
pub(crate) struct SliceLiveInput<'a> {
bytes: &'a [u8],
position: usize,
}
impl<'a> SliceLiveInput<'a> {
pub(crate) fn new(bytes: &'a [u8]) -> Self {
Self { bytes, position: 0 }
}
pub(crate) fn position(&self) -> usize {
self.position
}
pub(crate) fn seek_to(&mut self, position: usize) -> Result<()> {
self.seek(position as u64)
}
}
impl LiveInput for SliceLiveInput<'_> {
fn tell(&mut self) -> Result<u64> {
Ok(self.position as u64)
}
fn seek(&mut self, offset: u64) -> Result<()> {
#[cfg(target_pointer_width = "64")]
let position = offset as usize;
#[cfg(not(target_pointer_width = "64"))]
let position = usize::try_from(offset)
.map_err(|_| Error::Internal("slice live-input offset does not fit usize".into()))?;
if position > self.bytes.len() {
return Err(Error::parse(position, "seek past end of parser input"));
}
self.position = position;
Ok(())
}
fn read_byte(&mut self) -> Result<Option<u8>> {
let byte = self.bytes.get(self.position).copied();
if byte.is_some() {
self.position += 1;
}
Ok(byte)
}
fn unread_byte(&mut self) -> Result<()> {
self.position = self
.position
.checked_sub(1)
.ok_or_else(|| Error::Internal("live tokenizer unread before input start".into()))?;
Ok(())
}
}
#[derive(Default)]
struct DetachedHandles {
description_template: Option<Rc<Vec<u8>>>,
warning_object_description: Option<Vec<u8>>,
}
impl HandleResolver for DetachedHandles {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle {
ObjectHandle::new_indirect_unresolved(object_ref, NO_PARSED_OFFSET)
}
fn description_template(&self) -> Option<Rc<Vec<u8>>> {
self.description_template.as_ref().map(Rc::clone)
}
fn contextless_warning_object_description(&self) -> Option<Vec<u8>> {
self.warning_object_description.clone()
}
}
pub(crate) struct LiveTokenSource<'input, I: LiveInput> {
input: &'input mut I,
tokenizer: Tokenizer<'static>,
last_offset: usize,
}
#[derive(Clone, Debug)]
enum LiveToken {
Integer {
value: i64,
start: usize,
end: usize,
},
Owned(Token),
}
impl LiveToken {
fn token_type(&self) -> TokenType {
match self {
Self::Integer { .. } => TokenType::Integer,
Self::Owned(token) => token.token_type,
}
}
fn start(&self) -> usize {
match self {
Self::Integer { start, .. } => *start,
Self::Owned(token) => token.start,
}
}
fn end(&self) -> usize {
match self {
Self::Integer { end, .. } => *end,
Self::Owned(token) => token.end,
}
}
fn is_word_value(&self, value: &[u8]) -> bool {
matches!(
self,
Self::Owned(token) if token.is_word_value(value)
)
}
}
impl<'input, I: LiveInput> LiveTokenSource<'input, I> {
pub(crate) fn new(input: &'input mut I) -> Self {
let mut tokenizer = Tokenizer::push();
tokenizer.allow_eof();
Self {
input,
tokenizer,
last_offset: 0,
}
}
pub(crate) fn tell(&mut self) -> Result<u64> {
self.input.tell()
}
pub(crate) fn last_offset(&self) -> usize {
self.last_offset
}
fn seek(&mut self, offset: u64) -> Result<()> {
self.input.seek(offset)
}
pub(crate) fn next_token(&mut self) -> Result<Token> {
loop {
match self.input.read_byte()? {
Some(byte) => self.tokenizer.present_character(byte).map_err(|error| {
Error::Internal(format!("live tokenizer state error: {error:?}"))
})?,
None => {
self.tokenizer.present_eof().map_err(|error| {
Error::Internal(format!("live tokenizer state error: {error:?}"))
})?
}
}
let Some(pushed) = self.tokenizer.get_token() else {
continue;
};
let (start, end) = self.set_token_offsets(pushed.token.raw.len(), pushed.unread)?;
let mut token = pushed.token;
token.start = start;
token.error_offset = start;
token.end = end;
self.last_offset = start;
return Ok(token);
}
}
fn next_live_token(&mut self) -> Result<LiveToken> {
loop {
match self.input.read_byte()? {
Some(byte) => self.tokenizer.present_character(byte).map_err(|error| {
Error::Internal(format!("live tokenizer state error: {error:?}"))
})?,
None => self.tokenizer.present_eof().map_err(|error| {
Error::Internal(format!("live tokenizer state error: {error:?}"))
})?,
}
if let Some(pushed) = self.tokenizer.get_integer() {
let (start, end) = self.set_token_offsets(pushed.raw_len, pushed.unread)?;
self.last_offset = start;
return Ok(LiveToken::Integer {
value: pushed.value?,
start,
end,
});
}
let Some(pushed) = self.tokenizer.get_token() else {
continue;
};
let (start, end) = self.set_token_offsets(pushed.token.raw.len(), pushed.unread)?;
let mut token = pushed.token;
token.start = start;
token.error_offset = start;
token.end = end;
self.last_offset = start;
return Ok(LiveToken::Owned(token));
}
}
fn set_token_offsets(&mut self, raw_len: usize, unread: Option<u8>) -> Result<(usize, usize)> {
if unread.is_some() {
self.input.unread_byte()?;
}
let end = self.input.tell()?;
let start = end.saturating_sub(raw_len as u64);
let start = usize::try_from(start).unwrap_or(usize::MAX);
let end = usize::try_from(end).unwrap_or(usize::MAX);
self.input.set_last_offset(start as u64);
Ok((start, end))
}
}
#[derive(Debug)]
pub(crate) struct LiveParsedObject {
pub(crate) value: ObjectHandle,
pub(crate) parsed_offset: i64,
pub(crate) last_offset: usize,
pub(crate) next_offset: usize,
pub(crate) empty: Option<u64>,
pub(crate) diagnostics: Vec<ParserDiagnostic>,
}
pub(crate) fn parse_live_file_object<I: LiveInput>(
input: &mut I,
resolver: &mut dyn HandleResolver,
) -> Result<LiveParsedObject> {
parse_live_file_object_with_context(input, resolver, true, None)
}
pub(crate) fn parse_live_file_object_with_decrypter<I: LiveInput>(
input: &mut I,
resolver: &mut dyn HandleResolver,
decrypter: Option<&mut dyn StringDecrypter>,
) -> Result<LiveParsedObject> {
parse_live_file_object_with_context(input, resolver, true, decrypter)
}
pub(crate) fn parse_explicit_object_handle(input: &[u8]) -> Result<ObjectHandle> {
parse_explicit_object_handle_with_description(input, "")
}
pub(crate) fn parse_explicit_object_handle_with_description(
input: &[u8],
object_description: &str,
) -> Result<ObjectHandle> {
let mut input_source = SliceLiveInput::new(input);
let mut detached_handles = DetachedHandles {
description_template: Some(Rc::new(
format!("parsed object, {object_description} at offset $PO").into_bytes(),
)),
warning_object_description: Some(object_description.as_bytes().to_vec()),
};
let parsed =
parse_live_file_object_with_context(&mut input_source, &mut detached_handles, false, None)?;
if let Some(error) = trailing_data_error(input, parsed.next_offset, parsed.last_offset) {
return Err(error);
}
Ok(parsed.value)
}
pub(crate) fn parse_object_handle_with_context(
input: &[u8],
resolver: &mut dyn HandleResolver,
) -> Result<LiveParsedObject> {
let mut input_source = SliceLiveInput::new(input);
parse_live_file_object_with_context(&mut input_source, resolver, true, None)
}
fn is_c_whitespace(byte: u8) -> bool {
matches!(byte, b' ' | b'\t' | b'\n' | b'\x0b' | b'\x0c' | b'\r')
}
pub(crate) fn trailing_data_error(
input: &[u8],
next_offset: usize,
last_offset: usize,
) -> Option<Error> {
input
.get(next_offset..)
.filter(|trailing| trailing.iter().any(|byte| !is_c_whitespace(*byte)))
.map(|_| {
Error::parse(
last_offset,
"trailing data found parsing object from string",
)
})
}
fn parse_live_file_object_with_context<I: LiveInput>(
input: &mut I,
resolver: &mut dyn HandleResolver,
has_context: bool,
decrypter: Option<&mut dyn StringDecrypter>,
) -> Result<LiveParsedObject> {
parse_live_object_with_context(input, resolver, has_context, decrypter, false)
}
pub(crate) fn parse_live_content_stream_object<I: LiveInput>(
input: &mut I,
resolver: &mut dyn HandleResolver,
) -> Result<LiveParsedObject> {
parse_live_object_with_context(input, resolver, true, None, true)
}
fn parse_live_object_with_context<I: LiveInput>(
input: &mut I,
resolver: &mut dyn HandleResolver,
has_context: bool,
decrypter: Option<&mut dyn StringDecrypter>,
content_stream: bool,
) -> Result<LiveParsedObject> {
let mut tokens = LiveTokenSource::new(input);
let mut parser = LiveFileParser {
tokens: &mut tokens,
resolver,
buffered: VecDeque::new(),
diagnostics: Vec::new(),
good_count: 0,
bad_count: 0,
give_up: false,
has_context,
decrypter,
content_stream,
};
parser.parse()
}
struct LiveFileParser<'tokens, 'input, 'decrypter, I: LiveInput> {
tokens: &'tokens mut LiveTokenSource<'input, I>,
resolver: &'tokens mut dyn HandleResolver,
buffered: VecDeque<LiveToken>,
diagnostics: Vec<ParserDiagnostic>,
good_count: usize,
bad_count: usize,
give_up: bool,
has_context: bool,
decrypter: Option<&'decrypter mut dyn StringDecrypter>,
content_stream: bool,
}
enum LiveFrame {
Array {
values: Vec<ObjectHandle>,
start: usize,
},
Dictionary {
values: std::collections::BTreeMap<Vec<u8>, ObjectHandle>,
orphan_values: Vec<ObjectHandle>,
pending_key: Option<Vec<u8>>,
contents: Option<(Vec<u8>, i64)>,
start: usize,
frame_offset: usize,
},
}
impl<I: LiveInput> LiveFileParser<'_, '_, '_, I> {
fn parse(&mut self) -> Result<LiveParsedObject> {
self.resolver.begin_parse()?;
let result = self.parse_body();
self.resolver.end_parse();
result
}
fn parse_body(&mut self) -> Result<LiveParsedObject> {
let start = self.tokens.tell()?;
let start_offset = i64::try_from(start).unwrap_or(i64::MAX);
let token = self.next_token()?;
if self.content_stream && token.token_type() == TokenType::Eof {
return Ok(LiveParsedObject {
value: ObjectHandle::uninitialized(),
parsed_offset: NO_PARSED_OFFSET,
last_offset: self.tokens.last_offset(),
next_offset: token.start(),
empty: None,
diagnostics: std::mem::take(&mut self.diagnostics),
});
}
if !self.content_stream && token.is_word_value(b"endobj") {
self.tokens.seek(token.start() as u64)?;
return Ok(LiveParsedObject {
value: ObjectHandle::null(),
parsed_offset: NO_PARSED_OFFSET,
last_offset: self.tokens.last_offset(),
next_offset: token.start(),
empty: Some(token.start() as u64),
diagnostics: std::mem::take(&mut self.diagnostics),
});
}
let value = match token.token_type() {
TokenType::ArrayOpen | TokenType::DictOpen => {
let mut frames = Vec::new();
self.push_frame(&mut frames, token)?;
self.parse_remainder(&mut frames)?
}
_ => self.parse_scalar_token(token, start_offset, true)?,
};
let parsed_offset = value.get_parsed_offset();
let next_offset = usize::try_from(self.tokens.tell()?).unwrap_or(usize::MAX);
Ok(LiveParsedObject {
value,
parsed_offset,
last_offset: self.tokens.last_offset(),
next_offset,
empty: None,
diagnostics: std::mem::take(&mut self.diagnostics),
})
}
fn parse_remainder(&mut self, frames: &mut Vec<LiveFrame>) -> Result<ObjectHandle> {
loop {
let token = self.next_token()?;
self.good_count += 1;
match token.token_type() {
TokenType::ArrayOpen | TokenType::DictOpen => {
if !self.push_frame(frames, token)? {
return Ok(ObjectHandle::null());
}
}
TokenType::ArrayClose if matches!(frames.last(), Some(LiveFrame::Array { .. })) => {
let frame = frames.pop().expect("array frame is present");
let value = self.finish_array(frame);
if frames.is_empty() {
return Ok(value);
}
self.add_to_top_frame(frames, value)?;
}
TokenType::DictClose
if matches!(frames.last(), Some(LiveFrame::Dictionary { .. })) =>
{
let frame = frames.pop().expect("dictionary frame is present");
let value = self.finish_dictionary(frame)?;
if frames.is_empty() {
return Ok(value);
}
self.add_to_top_frame(frames, value)?;
}
TokenType::Eof => {
self.warn(token.start(), "parse error while reading object")?;
if self.content_stream {
return Ok(ObjectHandle::uninitialized());
}
self.warn(token.start(), "unexpected EOF")?;
return Ok(ObjectHandle::null());
}
TokenType::Name => {
if let Some(LiveFrame::Dictionary { pending_key, .. }) = frames.last_mut() {
if pending_key.is_none() {
let LiveToken::Owned(ref token) = token else {
unreachable!("integer tokens cannot be dictionary names");
};
*pending_key = Some(token.value.clone());
continue;
}
}
let start = token.start();
let value = self.parse_scalar_token(token, start as i64, false)?;
self.add_to_top_frame(frames, value)?;
}
_ => {
self.capture_raw_signature_contents(frames, &token);
let start = token.start();
let value = self.parse_scalar_token(token, start as i64, false)?;
if self.give_up {
return Ok(ObjectHandle::null());
}
self.add_to_top_frame(frames, value)?;
}
}
if self.give_up {
return Ok(ObjectHandle::null());
}
}
}
fn push_frame(&mut self, frames: &mut Vec<LiveFrame>, token: LiveToken) -> Result<bool> {
if frames.len() >= MAX_PARSE_DEPTH {
let warning = "ignoring excessively deeply nested data structure";
self.warn(token.start(), warning)?;
self.give_up = true;
return Ok(false);
}
match token.token_type() {
TokenType::ArrayOpen => frames.push(LiveFrame::Array {
values: Vec::new(),
start: token.start(),
}),
TokenType::DictOpen => frames.push(LiveFrame::Dictionary {
values: std::collections::BTreeMap::new(),
orphan_values: Vec::new(),
pending_key: None,
contents: None,
start: token.start(),
frame_offset: token.end(),
}),
_ => unreachable!("only container tokens create live parser frames"), }
Ok(true)
}
fn add_to_top_frame(&mut self, frames: &mut [LiveFrame], value: ObjectHandle) -> Result<()> {
let frame = frames.last_mut().expect("live parser has an open frame");
self.add_to_frame(frame, value)
}
fn capture_raw_signature_contents(&self, frames: &mut [LiveFrame], token: &LiveToken) {
let LiveToken::Owned(token) = token else {
return;
};
if self.decrypter.is_none() || token.token_type != TokenType::String {
return;
}
let Some(LiveFrame::Dictionary {
pending_key,
contents,
..
}) = frames.last_mut()
else {
return;
};
if pending_key.as_deref() == Some(b"/Contents") {
*contents = Some((token.value.clone(), token.start as i64));
}
}
fn add_to_frame(&mut self, frame: &mut LiveFrame, value: ObjectHandle) -> Result<()> {
match frame {
LiveFrame::Array { values, .. } => values.push(value),
LiveFrame::Dictionary {
values,
orphan_values,
pending_key,
frame_offset,
..
} => {
if let Some(key) = pending_key.take() {
Self::insert_dictionary_value(values, key, value, *frame_offset, self)?;
} else {
orphan_values.push(value);
}
}
}
Ok(())
}
fn finish_array(&mut self, frame: LiveFrame) -> ObjectHandle {
let LiveFrame::Array { values, start } = frame else {
unreachable!("array close can only complete an array frame"); };
self.direct(ObjectValue::Array(values), start)
}
fn finish_dictionary(&mut self, frame: LiveFrame) -> Result<ObjectHandle> {
let LiveFrame::Dictionary {
mut values,
orphan_values,
pending_key,
contents,
start,
frame_offset,
} = frame
else {
unreachable!("dictionary frame required"); };
if let Some(key) = pending_key {
self.warn(
frame_offset,
"dictionary ended prematurely; using null as value for last key",
)?;
values.insert(key, ObjectHandle::null());
}
let orphan_names: std::collections::BTreeSet<Vec<u8>> = orphan_values
.iter()
.filter_map(ObjectHandle::as_name)
.map(|name| {
let mut key = Vec::with_capacity(name.len() + 1);
key.push(b'/');
key.extend(name);
key
})
.collect();
let mut fake = 1;
for value in orphan_values {
let key = loop {
let candidate = format!("/QPDFFake{fake}").into_bytes();
fake += 1;
if !values.contains_key(&candidate) && !orphan_names.contains(&candidate) {
break candidate;
}
};
let mut message =
b"expected dictionary key but found non-name object; inserting key ".to_vec();
message.extend_from_slice(key.as_slice());
self.warn(frame_offset, message)?;
values.insert(key, value);
}
let is_signature = values
.get(b"/Type".as_slice())
.and_then(ObjectHandle::as_name)
.as_deref()
== Some(b"Sig".as_slice());
let has_byte_range = values.contains_key(b"/ByteRange".as_slice());
let has_string_contents = values
.get(b"/Contents".as_slice())
.and_then(ObjectHandle::as_string)
.is_some();
if is_signature && has_byte_range && has_string_contents {
if let Some((raw_contents, offset)) = contents {
let contents = self.direct_at(ObjectValue::String(raw_contents), offset);
values.insert(b"/Contents".to_vec(), contents);
}
}
Ok(self.direct(ObjectValue::Dictionary(values), start))
}
fn parse_scalar_token(
&mut self,
token: LiveToken,
scalar_offset: i64,
top_level: bool,
) -> Result<ObjectHandle> {
match token {
LiveToken::Integer { value, start, .. } => {
self.integer_or_ref(value, start, scalar_offset, top_level)
}
LiveToken::Owned(token) => self.parse_owned_scalar_token(token, scalar_offset),
}
}
fn parse_owned_scalar_token(
&mut self,
token: Token,
scalar_offset: i64,
) -> Result<ObjectHandle> {
match token.token_type {
TokenType::Name => {
Ok(self.direct_at(ObjectValue::Name(token.value[1..].to_vec()), scalar_offset))
}
TokenType::String => {
let mut value = token.value;
if let Some(decrypter) = self.decrypter.as_deref_mut() {
decrypter.decrypt_string(&mut value)?;
}
Ok(self.direct_at(ObjectValue::String(value), scalar_offset))
}
TokenType::Bool => {
Ok(self.direct_at(ObjectValue::Boolean(token.value == b"true"), scalar_offset))
}
TokenType::Null => Ok(ObjectHandle::null()),
TokenType::Integer => {
unreachable!("live integer tokens use the compact path") }
TokenType::Real => self.real(token, scalar_offset),
TokenType::Word => {
if self.content_stream {
return Ok(self.direct_at(ObjectValue::Operator(token.value), scalar_offset));
}
self.warn(
token.start,
"unknown token while reading object; treating as string",
)?;
self.too_many_bad_tokens(token.start)?;
Ok(self.direct_at(ObjectValue::String(token.value), scalar_offset))
}
TokenType::Bad => {
self.too_many_bad_tokens(token.start)?;
Ok(ObjectHandle::null())
}
TokenType::BraceOpen | TokenType::BraceClose => {
self.warn(token.start, "treating unexpected brace token as null")?;
self.too_many_bad_tokens(token.start)?;
Ok(ObjectHandle::null())
}
TokenType::ArrayClose => {
self.warn(token.start, "treating unexpected array close token as null")?;
self.too_many_bad_tokens(token.start)?;
Ok(ObjectHandle::null())
}
TokenType::DictClose => {
self.warn(token.start, "unexpected dictionary close token")?;
self.too_many_bad_tokens(token.start)?;
Ok(ObjectHandle::null())
}
TokenType::Eof => {
self.warn(token.start, "unexpected EOF")?;
Ok(ObjectHandle::null())
}
TokenType::Space | TokenType::Comment | TokenType::InlineImage => {
self.warn(
token.start,
"treating unknown token type as null while reading object",
)?;
self.too_many_bad_tokens(token.start)?;
Ok(ObjectHandle::null())
} TokenType::DictOpen | TokenType::ArrayOpen => unreachable!("frame loop"), }
}
fn insert_dictionary_value(
values: &mut std::collections::BTreeMap<Vec<u8>, ObjectHandle>,
key: Vec<u8>,
value: ObjectHandle,
offset: usize,
parser: &mut Self,
) -> Result<()> {
if values.insert(key.clone(), value).is_some() {
let mut message = b"dictionary has duplicated key ".to_vec();
message.extend_from_slice(key.as_slice());
message.extend_from_slice(b"; last occurrence overrides earlier ones");
parser.warn(offset, message)?;
}
Ok(())
}
fn integer_or_ref(
&mut self,
first: i64,
first_start: usize,
offset: i64,
top_level: bool,
) -> Result<ObjectHandle> {
if top_level || self.content_stream {
return Ok(self.direct_at(ObjectValue::Integer(first), offset));
}
let second_token = self.next_token()?;
let (second, second_start) = match second_token {
LiveToken::Integer { value, start, .. } => (value, start),
token => {
self.unread_token(token);
return Ok(self.direct_at(ObjectValue::Integer(first), offset));
}
};
let third = self.next_token()?;
if third.is_word_value(b"R") {
if !self.has_context {
return Err(Error::Internal(
"QPDFParser::parse called without context on an object with indirect references"
.into(),
));
}
self.good_count += 2;
let number = qpdf_int(first, first_start)?;
let generation = qpdf_int(second, second_start)?;
if number >= 1 && (0..65535).contains(&generation) {
return Ok(self
.resolver
.indirect_handle_at(ObjectRef::new(number as u32, generation as u16), offset));
}
return Ok(ObjectHandle::null());
}
self.unread_token(third);
self.unread_token(second_token);
Ok(self.direct_at(ObjectValue::Integer(first), offset))
}
fn real(&mut self, token: Token, offset: i64) -> Result<ObjectHandle> {
let value = match classify_real(token)? {
RealClassification::Canonical(value) => ObjectValue::Real(value),
RealClassification::Literal { value, literal } => {
ObjectValue::RealLiteral { value, literal }
}
};
Ok(self.direct_at(value, offset))
}
fn direct(&mut self, value: ObjectValue, offset: usize) -> ObjectHandle {
self.direct_at(value, i64::try_from(offset).unwrap_or(i64::MAX))
}
fn direct_at(&mut self, value: ObjectValue, offset: i64) -> ObjectHandle {
self.resolver.direct_handle_at(value, offset)
}
fn next_token(&mut self) -> Result<LiveToken> {
let mut token = if let Some(token) = self.buffered.pop_front() {
token
} else {
self.tokens.next_live_token()?
};
if let LiveToken::Owned(token) = &mut token {
if let Some(message) = token.error_message.take() {
self.warn(token.start, message)?;
}
}
Ok(token)
}
fn unread_token(&mut self, token: LiveToken) {
self.buffered.push_front(token);
}
fn too_many_bad_tokens(&mut self, offset: usize) -> Result<()> {
if self.good_count <= 4 {
self.bad_count += 1;
if self.bad_count > 5 {
self.warn(offset, "too many errors; giving up on reading object")?;
self.give_up = true;
}
} else {
self.bad_count = 1;
}
self.good_count = 0;
Ok(())
}
fn warn(&mut self, offset: usize, message: impl AsRef<[u8]>) -> Result<()> {
let message = message.as_ref().to_vec();
if !self.has_context {
return Err(Error::QpdfExc(QpdfExc::new(
QpdfErrorCode::DamagedPdf,
b"parsed object",
self.resolver
.contextless_warning_object_description()
.unwrap_or_default(),
i64::try_from(offset).unwrap_or(i64::MAX),
message,
)));
}
self.diagnostics.push(ParserDiagnostic {
relative_offset: offset,
message,
});
Ok(())
}
}
#[cfg(test)]
mod live_input_tests {
use super::{
parse_integer_token, parse_live_file_object, parse_live_file_object_with_decrypter,
HandleResolver, LiveFileParser, LiveFrame, LiveInput, LiveParsedObject, LiveTokenSource,
OffsetHandleResolver, SliceLiveInput, StringDecrypter, MAX_PARSE_DEPTH,
};
use crate::object_handle::{DocumentResolver, ObjectHandle, ObjectValue};
use crate::tokenizer::{Token, TokenType};
use crate::{Error, ObjectRef, QpdfExc, Result};
use std::cell::RefCell;
use std::collections::VecDeque;
use std::rc::{Rc, Weak};
struct CountingInput {
bytes: &'static [u8],
position: usize,
reads: Vec<usize>,
}
impl CountingInput {
fn new(bytes: &'static [u8]) -> Self {
Self {
bytes,
position: 0,
reads: vec![0; bytes.len()],
}
}
}
impl LiveInput for CountingInput {
fn tell(&mut self) -> Result<u64> {
Ok(self.position as u64)
}
fn seek(&mut self, offset: u64) -> Result<()> {
self.position = usize::try_from(offset).expect("test offsets fit usize");
Ok(())
}
fn read_byte(&mut self) -> Result<Option<u8>> {
let Some(&byte) = self.bytes.get(self.position) else {
return Ok(None);
};
self.reads[self.position] += 1;
self.position += 1;
Ok(Some(byte))
}
fn unread_byte(&mut self) -> Result<()> {
self.position = self
.position
.checked_sub(1)
.expect("only unread a byte just read");
Ok(())
}
}
struct NullResolver;
impl HandleResolver for NullResolver {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle {
ObjectHandle::new_indirect_unresolved(object_ref, -1)
}
}
struct GuardSpyResolver {
events: RefCell<Vec<&'static str>>,
reject_entry: bool,
}
impl HandleResolver for GuardSpyResolver {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle {
ObjectHandle::new_indirect_unresolved(object_ref, -1)
}
fn begin_parse(&self) -> Result<()> {
self.events.borrow_mut().push("begin");
if self.reject_entry {
return Err(Error::Internal("test: re-entrant parse rejected".into()));
}
Ok(())
}
fn end_parse(&self) {
self.events.borrow_mut().push("end");
}
}
struct ContextualResolver {
resolver: Weak<dyn DocumentResolver>,
}
impl HandleResolver for ContextualResolver {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle {
ObjectHandle::new_indirect_unresolved(object_ref, -1)
}
fn direct_handle(&mut self, value: ObjectValue) -> ObjectHandle {
ObjectHandle::from_value_with_resolver(value, self.resolver.clone())
}
}
struct WarningSink {
warnings: RefCell<Vec<String>>,
}
impl DocumentResolver for WarningSink {
fn resolve_indirect(&self, _object_ref: ObjectRef, _handle: &ObjectHandle) -> Result<()> {
Ok(())
}
fn warn(&self, warning: QpdfExc) -> Result<()> {
self.warnings
.borrow_mut()
.push(String::from_utf8_lossy(warning.what_bytes()).into_owned());
Ok(())
}
}
fn contextual_resolver() -> (ContextualResolver, Rc<WarningSink>) {
let sink = Rc::new(WarningSink {
warnings: RefCell::new(Vec::new()),
});
let erased: Rc<dyn DocumentResolver> = sink.clone();
(
ContextualResolver {
resolver: Rc::downgrade(&erased),
},
sink,
)
}
#[test]
fn detached_resolver_has_no_pdf_identity() {
let resolver = WarningSink {
warnings: RefCell::new(Vec::new()),
};
assert_eq!(resolver.pdf_unique_id(), None);
}
#[test]
fn detached_and_offset_handle_resolvers_preserve_reference_identity() {
let mut detached_resolver = super::DetachedHandles {
description_template: Some(Rc::new(b"parsed object, at offset $PO".to_vec())),
warning_object_description: None,
};
let detached = detached_resolver.indirect_handle(ObjectRef::new(7, 2));
assert_eq!(detached.object_ref(), Some(ObjectRef::new(7, 2)));
let mut base = NullResolver;
assert_eq!(
HandleResolver::contextless_warning_object_description(&base),
None
);
let mut rebasing = OffsetHandleResolver {
resolver: &mut base,
base_offset: 100,
top_level_offset: Some(500),
};
let handle = rebasing.indirect_handle_at(ObjectRef::new(8, 0), 0);
assert_eq!(handle.object_ref(), Some(ObjectRef::new(8, 0)));
}
struct RecordingDecrypter {
calls: Vec<Vec<u8>>,
fail: bool,
}
impl StringDecrypter for RecordingDecrypter {
fn decrypt_string(&mut self, bytes: &mut Vec<u8>) -> Result<()> {
self.calls.push(bytes.clone());
if self.fail {
return Err(Error::Internal("decrypter failure".into()));
}
bytes.extend_from_slice(b"-plain");
Ok(())
}
}
fn parse_with_null_resolver(bytes: &'static [u8]) -> LiveParsedObject {
let mut input = CountingInput::new(bytes);
let mut resolver = NullResolver;
parse_live_file_object(&mut input, &mut resolver).expect("live file object")
}
#[test]
fn live_file_parser_decrypter_decrypts_each_literal_string_but_not_words() {
let mut input =
CountingInput::new(b"<< /Top (top) /Items [(array)] /Nested << /Value (dict) >> >>");
let mut resolver = NullResolver;
let mut decrypter = RecordingDecrypter {
calls: Vec::new(),
fail: false,
};
let parsed =
parse_live_file_object_with_decrypter(&mut input, &mut resolver, Some(&mut decrypter))
.expect("decrypted dictionary");
let values = parsed.value.as_dictionary().expect("dictionary");
assert_eq!(
values
.get(b"/Top".as_slice())
.and_then(ObjectHandle::as_string),
Some(b"top-plain".to_vec())
);
assert_eq!(
values
.get(b"/Items".as_slice())
.and_then(ObjectHandle::as_array)
.and_then(|items| items.first().cloned())
.and_then(|item| item.as_string()),
Some(b"array-plain".to_vec())
);
assert_eq!(
values
.get(b"/Nested".as_slice())
.and_then(ObjectHandle::as_dictionary)
.and_then(|nested| nested.get(b"/Value".as_slice()).cloned())
.and_then(|value| value.as_string()),
Some(b"dict-plain".to_vec())
);
assert_eq!(
decrypter.calls,
vec![b"top".to_vec(), b"array".to_vec(), b"dict".to_vec()]
);
let mut word_input = CountingInput::new(b"unknown-word");
let word = parse_live_file_object_with_decrypter(
&mut word_input,
&mut resolver,
Some(&mut decrypter),
)
.expect("unknown words recover as strings");
assert_eq!(word.value.as_string(), Some(b"unknown-word".to_vec()));
assert_eq!(
decrypter.calls.len(),
3,
"words must not enter StringDecrypter"
);
}
#[test]
fn live_file_parser_decrypter_propagates_failures() {
let mut input = CountingInput::new(b"(ciphertext)");
let mut resolver = NullResolver;
let mut decrypter = RecordingDecrypter {
calls: Vec::new(),
fail: true,
};
let error =
parse_live_file_object_with_decrypter(&mut input, &mut resolver, Some(&mut decrypter))
.expect_err("decrypter errors must reach the file-object caller");
assert!(matches!(error, Error::Internal(message) if message == "decrypter failure"));
assert_eq!(decrypter.calls, vec![b"ciphertext".to_vec()]);
}
#[test]
fn parse_short_circuits_before_the_body_when_the_guard_rejects_entry() {
let mut input = CountingInput::new(b"42");
let mut resolver = GuardSpyResolver {
events: RefCell::new(Vec::new()),
reject_entry: true,
};
let error = parse_live_file_object(&mut input, &mut resolver)
.expect_err("a rejected guard entry must fail the parse");
assert!(
matches!(&error, Error::Internal(message) if message == "test: re-entrant parse rejected")
);
assert_eq!(*resolver.events.borrow(), vec!["begin"]);
assert_eq!(
input.reads.iter().sum::<usize>(),
0,
"the body must never read from the input once entry is rejected"
);
}
#[test]
fn the_rebasing_adapter_forwards_the_parse_guard() {
let resolver = GuardSpyResolver {
events: RefCell::new(Vec::new()),
reject_entry: false,
};
let mut resolver = resolver;
super::parse_qpdf_direct_object_handle_with_diagnostics(b"42", 0, None, &mut resolver)
.expect("the object parses");
assert_eq!(*resolver.events.borrow(), vec!["begin", "end"]);
}
#[test]
fn parse_restores_the_guard_even_when_the_body_fails() {
let mut input = CountingInput::new(b"[1 0 R (ciphertext)]");
let mut resolver = GuardSpyResolver {
events: RefCell::new(Vec::new()),
reject_entry: false,
};
let mut decrypter = RecordingDecrypter {
calls: Vec::new(),
fail: true,
};
let error =
parse_live_file_object_with_decrypter(&mut input, &mut resolver, Some(&mut decrypter))
.expect_err("a failing decrypter must fail the parse");
assert!(matches!(&error, Error::Internal(message) if message == "decrypter failure"));
assert_eq!(*resolver.events.borrow(), vec!["begin", "end"]);
}
#[test]
fn live_file_parser_decrypter_restores_signature_contents_only_with_byte_range() {
let mut signature_input = CountingInput::new(
b"<< /Type /Sig /ByteRange [0 10 20 30] /Contents (cipher) /Reason (reason) >>",
);
let (mut resolver, warnings) = contextual_resolver();
let indirect = resolver.indirect_handle(ObjectRef::new(9, 0));
warnings
.resolve_indirect(ObjectRef::new(9, 0), &indirect)
.expect("test warning sink resolver");
let mut decrypter = RecordingDecrypter {
calls: Vec::new(),
fail: false,
};
let signature = parse_live_file_object_with_decrypter(
&mut signature_input,
&mut resolver,
Some(&mut decrypter),
)
.expect("signature dictionary");
let signature_values = signature.value.as_dictionary().expect("dictionary");
let contents = signature_values
.get(b"/Contents".as_slice())
.expect("signature contents");
assert_eq!(contents.as_string(), Some(b"cipher".to_vec()));
assert_eq!(contents.get_parsed_offset(), 48);
contents
.object_warning("signature contents warning")
.expect("restored signature contents keeps the parser context");
assert_eq!(
warnings.warnings.borrow().as_slice(),
["signature contents warning"]
);
assert_eq!(
signature_values
.get(b"/Reason".as_slice())
.and_then(ObjectHandle::as_string),
Some(b"reason-plain".to_vec())
);
assert_eq!(
decrypter.calls,
vec![b"cipher".to_vec(), b"reason".to_vec()]
);
let mut non_signature_input = CountingInput::new(b"<< /Type /Sig /Contents (cipher) >>");
let non_signature = parse_live_file_object_with_decrypter(
&mut non_signature_input,
&mut resolver,
Some(&mut decrypter),
)
.expect("dictionary without byte range");
assert_eq!(
non_signature
.value
.as_dictionary()
.and_then(|values| values.get(b"/Contents".as_slice()).cloned())
.and_then(|contents| contents.as_string()),
Some(b"cipher-plain".to_vec())
);
}
#[test]
fn live_token_source_unreads_only_the_delimiter_between_completed_tokens() {
let mut input = CountingInput::new(b"12 /A");
let mut tokens = LiveTokenSource::new(&mut input);
let first = tokens.next_token().expect("first token");
assert_eq!(first.token_type, TokenType::Integer);
assert_eq!(first.value, b"12");
assert_eq!(first.start, 0);
assert_eq!(tokens.tell().unwrap(), 2);
let second = tokens.next_token().expect("second token");
assert_eq!(second.token_type, TokenType::Name);
assert_eq!(second.value, b"/A");
assert_eq!(second.start, 3);
assert_eq!(tokens.tell().unwrap(), 5);
drop(tokens);
assert_eq!(input.reads, vec![1, 1, 2, 1, 1]);
}
#[test]
fn live_token_source_keeps_integer_tokens_in_qpdf_sized_representation() {
let mut input = CountingInput::new(b"12 34 R");
let mut tokens = LiveTokenSource::new(&mut input);
let first = tokens.next_live_token().expect("first integer");
assert_eq!(first.end(), 2);
assert!(matches!(
first,
super::LiveToken::Integer {
value: 12,
start: 0,
end: 2,
}
));
assert!(matches!(
tokens.next_live_token().expect("second integer"),
super::LiveToken::Integer {
value: 34,
start: 3,
end: 5,
}
));
assert!(matches!(
tokens.next_live_token().expect("reference marker"),
super::LiveToken::Owned(token)
if token.token_type == TokenType::Word && token.value == b"R"
));
}
#[test]
fn live_token_source_settles_input_bookkeeping_before_integer_overflow() {
let mut input = CountingInput::new(b"99999999999999999999 /A");
let mut tokens = LiveTokenSource::new(&mut input);
let error = tokens
.next_live_token()
.expect_err("overflowing integer conversion");
assert!(
matches!(&error, Error::System(message) if message
== "overflow/underflow converting 99999999999999999999 to 64-bit integer"),
"{error:?}"
);
assert_eq!(tokens.tell().unwrap(), 20);
assert_eq!(tokens.last_offset(), 0);
assert!(matches!(
tokens.next_live_token().expect("token after the failure"),
super::LiveToken::Owned(token)
if token.token_type == TokenType::Name && token.value == b"/A"
));
}
#[test]
fn live_token_source_keeps_repeated_integer_candidates_allocation_free() {
let mut input = CountingInput::new(b"1 2 3 4 5");
let mut tokens = LiveTokenSource::new(&mut input);
for expected in [1, 2, 3, 4, 5] {
assert!(matches!(
tokens.next_live_token().expect("integer"),
super::LiveToken::Integer { value, .. } if value == expected
));
}
}
#[test]
fn owned_live_token_source_reports_a_ready_token_state_error() {
let mut input = CountingInput::new(b"1");
let mut tokens = LiveTokenSource::new(&mut input);
tokens
.tokenizer
.present_eof()
.expect("EOF should make the push tokenizer ready");
assert!(matches!(
tokens.next_token(),
Err(Error::Internal(message)) if message == "live tokenizer state error: TokenWaiting"
));
}
#[test]
fn live_file_object_parser_consumes_one_object_without_replaying_its_prefix() {
let mut input = CountingInput::new(b" \n[12 /A] tail");
let mut resolver = NullResolver;
let parsed = parse_live_file_object(&mut input, &mut resolver).expect("array object");
assert!(parsed.empty.is_none());
assert_eq!(parsed.parsed_offset, 2);
assert!(matches!(
parsed.value.into_direct_value(),
Some((ObjectValue::Array(values), 2))
if matches!(values.as_slice(), [first, second]
if first.as_integer() == Some(12) && second.as_name() == Some(b"A".to_vec()))
));
assert_eq!(input.position, 9);
assert_eq!(input.reads, vec![1, 1, 1, 1, 1, 2, 1, 1, 2, 0, 0, 0, 0, 0]);
}
#[test]
fn live_file_parser_uses_qpdfs_top_level_and_nested_offsets() {
let mut scalar_input = CountingInput::new(b" /Top");
let mut resolver = NullResolver;
let scalar = parse_live_file_object(&mut scalar_input, &mut resolver).expect("name");
assert_eq!(scalar.parsed_offset, 0, "leading whitespace is included");
let mut nested_input = CountingInput::new(b" \n[/Nested]");
let nested = parse_live_file_object(&mut nested_input, &mut resolver).expect("array");
assert_eq!(
nested.parsed_offset, 2,
"the array owns its opening delimiter"
);
assert_eq!(
nested
.value
.as_array()
.expect("array value")
.first()
.expect("name item")
.get_parsed_offset(),
3,
"nested scalar offsets start at their own token"
);
}
#[test]
fn live_file_parser_stops_after_qpdfs_sixth_bad_token() {
let mut input = CountingInput::new(b"[ } } } } } } 1 ]");
let mut resolver = NullResolver;
let parsed = parse_live_file_object(&mut input, &mut resolver).expect("recovered null");
assert!(parsed.value.is_null());
assert_eq!(
parsed
.diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_slice())
.collect::<Vec<_>>(),
vec![
b"treating unexpected brace token as null".as_slice(),
b"treating unexpected brace token as null".as_slice(),
b"treating unexpected brace token as null".as_slice(),
b"treating unexpected brace token as null".as_slice(),
b"treating unexpected brace token as null".as_slice(),
b"treating unexpected brace token as null".as_slice(),
b"too many errors; giving up on reading object".as_slice(),
]
);
assert_eq!(input.position, 13, "tokens after the give-up remain unread");
}
#[test]
fn live_file_parser_recovers_the_501st_nested_container_as_null() {
let input = vec![b'['; MAX_PARSE_DEPTH + 1];
let leaked: &'static [u8] = Box::leak(input.into_boxed_slice());
let mut input = CountingInput::new(leaked);
let mut resolver = NullResolver;
let parsed = parse_live_file_object(&mut input, &mut resolver).expect("recovered null");
assert!(parsed.value.is_null());
assert_eq!(
parsed
.diagnostics
.last()
.map(|diagnostic| diagnostic.message.as_slice()),
Some(b"ignoring excessively deeply nested data structure".as_slice())
);
}
#[test]
fn live_file_parser_accepts_qpdfs_500_container_limit_on_a_small_stack() {
let mut bytes = vec![b'['; MAX_PARSE_DEPTH];
bytes.extend(std::iter::repeat_n(b']', MAX_PARSE_DEPTH));
let leaked: &'static [u8] = Box::leak(bytes.into_boxed_slice());
let outcome = std::thread::Builder::new()
.stack_size(256 * 1024)
.spawn(move || {
let mut input = CountingInput::new(leaked);
let mut resolver = NullResolver;
let parsed = std::mem::ManuallyDrop::new(
parse_live_file_object(&mut input, &mut resolver)
.expect("500 nested containers must parse"),
);
parsed.value.is_null()
})
.expect("spawn small-stack parser thread")
.join()
.expect("live parser must not overflow the caller stack");
assert!(!outcome, "a valid 500-level array must not recover to null");
}
#[test]
fn live_file_parser_drops_qpdfs_500_container_limit_on_a_normal_stack() {
let mut bytes = vec![b'['; MAX_PARSE_DEPTH];
bytes.extend(std::iter::repeat_n(b']', MAX_PARSE_DEPTH));
let leaked: &'static [u8] = Box::leak(bytes.into_boxed_slice());
let mut input = CountingInput::new(leaked);
let mut resolver = NullResolver;
let parsed = parse_live_file_object(&mut input, &mut resolver)
.expect("500 nested containers must parse");
assert!(
!parsed.value.is_null(),
"a valid 500-level array must not recover to null"
);
}
#[test]
fn objstm_member_uses_the_live_file_recovery_and_decoded_stream_offsets() {
let mut input = CountingInput::new(b"<< 12 >> next-member");
let mut resolver = NullResolver;
let parsed =
parse_live_file_object(&mut input, &mut resolver).expect("recovered ObjStm member");
let object = parsed.value;
let diagnostics = parsed.diagnostics;
assert_eq!(
object
.try_get_key(b"/QPDFFake1")
.expect("fake key")
.as_integer(),
Some(12)
);
assert_eq!(
diagnostics
.iter()
.map(|diagnostic| (diagnostic.relative_offset, diagnostic.message.as_slice()))
.collect::<Vec<_>>(),
vec![(
2,
b"expected dictionary key but found non-name object; inserting key /QPDFFake1"
.as_slice()
)]
);
}
#[test]
fn live_parser_returns_handle_children() {
let mut input = CountingInput::new(b"<< /Child 4 >>");
let mut resolver = NullResolver;
let parsed = parse_live_file_object(&mut input, &mut resolver)
.expect("live object parser returns a handle");
let child = parsed
.value
.try_get_key(b"/Child")
.expect("dictionary child");
assert_eq!(child.as_integer(), Some(4));
}
#[test]
fn live_file_parser_exercises_document_context_recovery_tokens() {
let word = parse_with_null_resolver(b"bare-word");
assert_eq!(word.value.as_string(), Some(b"bare-word".to_vec()));
assert_eq!(
word.diagnostics[0].message.as_slice(),
b"unknown token while reading object; treating as string"
);
let array_close = parse_with_null_resolver(b"]");
assert!(array_close.value.is_null());
assert_eq!(
array_close.diagnostics[0].message.as_slice(),
b"treating unexpected array close token as null"
);
let dictionary_close = parse_with_null_resolver(b">>");
assert!(dictionary_close.value.is_null());
assert_eq!(
dictionary_close.diagnostics[0].message.as_slice(),
b"unexpected dictionary close token"
);
let eof = parse_with_null_resolver(b"");
assert!(eof.value.is_null());
assert_eq!(eof.diagnostics[0].message.as_slice(), b"unexpected EOF");
let array_eof = parse_with_null_resolver(b"[");
assert!(array_eof.value.is_null());
assert_eq!(
array_eof
.diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_slice())
.collect::<Vec<_>>(),
vec![
b"parse error while reading object".as_slice(),
b"unexpected EOF".as_slice()
]
);
let dictionary_eof = parse_with_null_resolver(b"<<");
assert!(dictionary_eof.value.is_null());
assert_eq!(
dictionary_eof
.diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_slice())
.collect::<Vec<_>>(),
vec![
b"parse error while reading object".as_slice(),
b"unexpected EOF".as_slice()
]
);
}
#[test]
fn live_file_parser_exercises_dictionary_recovery_and_reference_edges() {
let missing_value = parse_with_null_resolver(b"<< /Last >>");
let missing_value_entries = missing_value.value.as_dictionary().expect("dictionary");
assert!(missing_value_entries
.get(b"/Last".as_slice())
.is_some_and(ObjectHandle::is_null));
assert_eq!(
missing_value.diagnostics[0].message.as_slice(),
b"dictionary ended prematurely; using null as value for last key"
);
let duplicate = parse_with_null_resolver(b"<< /K 1 /K 2 >>");
let duplicate_entries = duplicate.value.as_dictionary().expect("dictionary");
assert_eq!(
duplicate_entries
.get(b"/K".as_slice())
.and_then(ObjectHandle::as_integer),
Some(2)
);
assert_eq!(
duplicate.diagnostics[0].message.as_slice(),
b"dictionary has duplicated key /K; last occurrence overrides earlier ones"
);
let collision = parse_with_null_resolver(b"<< /QPDFFake1 1 2 >>");
let collision_entries = collision.value.as_dictionary().expect("dictionary");
assert_eq!(
collision_entries
.get(b"/QPDFFake2".as_slice())
.and_then(ObjectHandle::as_integer),
Some(2)
);
assert_eq!(
collision.diagnostics[0].message.as_slice(),
b"expected dictionary key but found non-name object; inserting key /QPDFFake2"
);
let invalid_reference = parse_with_null_resolver(b"[ 0 0 R ]");
assert!(invalid_reference
.value
.as_array()
.is_some_and(|items| items.len() == 1 && items[0].is_null()));
let mut input = CountingInput::new(b"[ 2147483648 0 R ]");
let mut resolver = NullResolver;
let error = parse_live_file_object(&mut input, &mut resolver)
.expect_err("qpdf rejects indirect object numbers outside signed int");
assert!(matches!(
error,
Error::Parse { offset: 2, message }
if message == "integer out of range converting 2147483648 from a 8-byte signed type to a 4-byte signed type"
));
let mut input = CountingInput::new(b"<< /Columns 9900000000000000000 /Predictor 12 >>");
let mut resolver = NullResolver;
let error = parse_live_file_object(&mut input, &mut resolver)
.expect_err("qpdf preserves an oversized integer conversion failure");
assert!(matches!(
error,
Error::System(message)
if message == "overflow/underflow converting 9900000000000000000 to 64-bit integer"
));
let nested_reference = parse_with_null_resolver(b"[ 1 0 R ]");
let nested_reference_items = nested_reference.value.as_array().expect("array");
assert_eq!(
nested_reference_items
.first()
.and_then(ObjectHandle::object_ref),
Some(ObjectRef::new(1, 0))
);
}
#[test]
fn integer_token_conversion_matches_qpdf_runtime_overflow_boundary() {
let overflow = Token::new(TokenType::Integer, b"99999999999999999999".to_vec());
assert!(matches!(
parse_integer_token(&overflow),
Err(Error::System(message))
if message == "overflow/underflow converting 99999999999999999999 to 64-bit integer"
));
let invalid = Token::new(TokenType::Integer, b"not-an-integer".to_vec());
assert!(matches!(
parse_integer_token(&invalid),
Err(Error::Parse { message, .. }) if message == "invalid integer"
));
}
#[test]
fn live_dictionary_recovery_reserves_orphan_name_fake_keys() {
let mut input = CountingInput::new(b"");
let mut resolver = NullResolver;
let mut tokens = LiveTokenSource::new(&mut input);
let mut parser = LiveFileParser {
tokens: &mut tokens,
resolver: &mut resolver,
buffered: VecDeque::new(),
diagnostics: Vec::new(),
good_count: 0,
bad_count: 0,
give_up: false,
has_context: true,
decrypter: None,
content_stream: false,
};
let frame = LiveFrame::Dictionary {
values: std::collections::BTreeMap::from([(
b"/QPDFFake1".to_vec(),
ObjectHandle::integer(1),
)]),
orphan_values: vec![
ObjectHandle::name(b"QPDFFake1".to_vec()),
ObjectHandle::integer(2),
],
pending_key: None,
contents: None,
start: 0,
frame_offset: 2,
};
let parsed = parser
.finish_dictionary(frame)
.expect("dictionary recovery");
let values = parsed.as_dictionary().expect("dictionary");
assert_eq!(
values
.get(b"/QPDFFake2".as_slice())
.and_then(ObjectHandle::as_name),
Some(b"QPDFFake1".to_vec())
);
assert_eq!(
values
.get(b"/QPDFFake3".as_slice())
.and_then(ObjectHandle::as_integer),
Some(2)
);
assert_eq!(parser.diagnostics.len(), 2);
}
#[test]
fn live_file_parser_reports_a_replayed_tokenizer_error_once() {
let parsed = parse_with_null_resolver(b"[1 0 /A#zB]");
assert!(parsed.value.as_array().is_some());
assert_eq!(
parsed
.diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_slice())
.collect::<Vec<_>>(),
vec![b"name with stray # will not work with PDF >= 1.2".as_slice()]
);
}
#[test]
fn live_file_parser_resets_the_bad_token_streak_after_good_tokens() {
let parsed = parse_with_null_resolver(b"[ /A /B /C /D /E } ]");
assert!(parsed.value.as_array().is_some());
assert_eq!(
parsed
.diagnostics
.iter()
.map(|diagnostic| diagnostic.message.as_slice())
.collect::<Vec<_>>(),
vec![b"treating unexpected brace token as null".as_slice()]
);
}
#[test]
fn live_file_parser_recovers_the_501st_dictionary_as_null() {
let mut bytes = Vec::new();
for _ in 0..=MAX_PARSE_DEPTH {
bytes.extend_from_slice(b"<<");
}
let leaked: &'static [u8] = Box::leak(bytes.into_boxed_slice());
let parsed = parse_with_null_resolver(leaked);
assert!(parsed.value.is_null());
assert_eq!(
parsed
.diagnostics
.last()
.map(|diagnostic| diagnostic.message.as_slice()),
Some(b"ignoring excessively deeply nested data structure".as_slice())
);
}
#[test]
fn slice_live_input_and_objstm_empty_body_keep_live_parser_coordinates() {
let mut input = SliceLiveInput::new(b"x");
input.seek(1).expect("seek within input");
assert_eq!(input.read_byte().expect("read"), None);
assert!(matches!(
input.seek(2),
Err(crate::Error::Parse { offset: 2, .. })
));
input.seek(0).expect("rewind");
assert!(matches!(
input.unread_byte(),
Err(crate::Error::Internal(_))
));
let mut live_input = CountingInput::new(b"endobj");
let mut resolver = NullResolver;
let empty = parse_live_file_object(&mut live_input, &mut resolver).expect("empty body");
assert_eq!(empty.empty, Some(0));
assert_eq!(live_input.position, 0, "endobj remains unread");
let mut empty_input = CountingInput::new(b"endobj");
let mut empty_resolver = NullResolver;
let parsed =
parse_live_file_object(&mut empty_input, &mut empty_resolver).expect("ObjStm empty");
assert!(parsed.value.is_null());
let mut diagnostics = parsed.diagnostics;
if let Some(empty_offset) = parsed.empty {
diagnostics.push(super::ParserDiagnostic {
relative_offset: usize::try_from(empty_offset).unwrap_or(usize::MAX),
message: b"empty object treated as null".to_vec(),
});
}
assert_eq!(
diagnostics
.iter()
.map(|diagnostic| (diagnostic.relative_offset, diagnostic.message.as_slice()))
.collect::<Vec<_>>(),
vec![(0, b"empty object treated as null".as_slice())]
);
}
#[test]
fn handle_parser_preserves_empty_objects_and_wrapper_delegations() {
let mut resolver = NullResolver;
let (value, parsed_offset, diagnostics) =
super::parse_qpdf_direct_object_handle_with_diagnostics(
b" \nendobj\n",
0,
None,
&mut resolver,
)
.expect("empty handle object");
assert!(matches!(value, ObjectValue::Null));
assert_eq!(parsed_offset, super::NO_PARSED_OFFSET);
assert_eq!(
diagnostics,
vec![super::ParserDiagnostic {
relative_offset: 2,
message: b"empty object treated as null".to_vec(),
}]
);
let mut rebasing = super::OffsetHandleResolver {
resolver: &mut resolver,
base_offset: 17,
top_level_offset: None,
};
let direct = HandleResolver::direct_handle(&mut rebasing, ObjectValue::Integer(42));
assert_eq!(direct.as_integer(), Some(42));
assert_eq!(HandleResolver::description_template(&rebasing), None);
}
}
pub(crate) const MAX_PARSE_DEPTH: usize = 500;
#[derive(Debug, PartialEq, Eq)]
pub(crate) struct ParserDiagnostic {
pub(crate) relative_offset: usize,
pub(crate) message: Vec<u8>,
}
pub(crate) fn parse_qpdf_direct_object_handle_with_diagnostics(
input: &[u8],
base_offset: i64,
top_level_offset: Option<i64>,
resolver: &mut dyn HandleResolver,
) -> Result<(ObjectValue, i64, Vec<ParserDiagnostic>)> {
let mut input_source = SliceLiveInput::new(input);
let mut rebasing_resolver = OffsetHandleResolver {
resolver,
base_offset,
top_level_offset,
};
let parsed = parse_live_file_object(&mut input_source, &mut rebasing_resolver)?;
if let Some(empty_offset) = parsed.empty {
return Ok((
ObjectValue::Null,
NO_PARSED_OFFSET,
vec![ParserDiagnostic {
relative_offset: usize::try_from(empty_offset).unwrap_or(usize::MAX),
message: b"empty object treated as null".to_vec(),
}],
));
}
let value = parsed
.value
.into_direct_value()
.expect("the live parser returns a direct top-level value");
Ok((value.0, value.1, parsed.diagnostics))
}
#[derive(Debug)]
pub(crate) struct ParsedFileObjectHandle {
pub(crate) value: ObjectHandle,
pub(crate) next_offset: usize,
pub(crate) empty_offset: Option<usize>,
pub(crate) diagnostics: Vec<ParserDiagnostic>,
}
pub(crate) fn parse_qpdf_file_object_handle_with_diagnostics(
input: &[u8],
base_offset: i64,
top_level_offset: Option<i64>,
resolver: &mut dyn HandleResolver,
) -> Result<ParsedFileObjectHandle> {
let mut input_source = SliceLiveInput::new(input);
let mut rebasing_resolver = OffsetHandleResolver {
resolver,
base_offset,
top_level_offset,
};
let parsed = parse_live_file_object(&mut input_source, &mut rebasing_resolver)?;
Ok(ParsedFileObjectHandle {
value: parsed.value,
next_offset: input_source.position(),
empty_offset: parsed
.empty
.map(|offset| usize::try_from(offset).unwrap_or(usize::MAX)),
diagnostics: parsed.diagnostics,
})
}
struct OffsetHandleResolver<'a> {
resolver: &'a mut dyn HandleResolver,
base_offset: i64,
top_level_offset: Option<i64>,
}
impl HandleResolver for OffsetHandleResolver<'_> {
fn indirect_handle(&mut self, object_ref: ObjectRef) -> ObjectHandle {
self.resolver.indirect_handle(object_ref)
}
fn indirect_handle_at(&mut self, object_ref: ObjectRef, offset: i64) -> ObjectHandle {
let offset = if self.top_level_offset.is_some() && offset == 0 {
self.top_level_offset.unwrap_or(offset)
} else {
self.base_offset.saturating_add(offset)
};
self.resolver.indirect_handle_at(object_ref, offset)
}
fn direct_handle(&mut self, value: ObjectValue) -> ObjectHandle {
self.resolver.direct_handle(value)
}
fn direct_handle_at(&mut self, value: ObjectValue, offset: i64) -> ObjectHandle {
let offset = if self.top_level_offset.is_some() && offset == 0 {
self.top_level_offset.unwrap_or(offset)
} else {
self.base_offset.saturating_add(offset)
};
self.resolver.direct_handle_at(value, offset)
}
fn description_template(&self) -> Option<Rc<Vec<u8>>> {
self.resolver.description_template()
}
fn begin_parse(&self) -> Result<()> {
self.resolver.begin_parse()
}
fn end_parse(&self) {
self.resolver.end_parse();
}
}
pub(crate) struct ContentHandleResolver {
resolver: Option<Weak<dyn DocumentResolver>>,
}
impl ContentHandleResolver {
pub(crate) fn new(context: Option<Rc<dyn DocumentResolver>>) -> Self {
Self {
resolver: context.as_ref().map(Rc::downgrade),
}
}
}
impl HandleResolver for ContentHandleResolver {
fn indirect_handle(&mut self, _object_ref: ObjectRef) -> ObjectHandle {
unreachable!(
"content-stream mode never buffers an integer as a reference candidate (QPDFParser.cc:313-320)"
)
}
fn direct_handle(&mut self, value: ObjectValue) -> ObjectHandle {
match &self.resolver {
Some(resolver) => {
ObjectHandle::from_parsed_value_with_resolver(value, resolver.clone())
}
None => ObjectHandle::from_value(value),
}
}
}
enum RealClassification {
Canonical(f64),
Literal { value: f64, literal: Vec<u8> },
}
fn classify_real(token: Token) -> Result<RealClassification> {
let text = std::str::from_utf8(&token.value)
.map_err(|_| Error::parse(token.start, "real is not utf-8"))?;
let value = text
.parse::<f64>()
.map_err(|_| Error::parse(token.start, "invalid real"))?;
if value.to_string().as_bytes() == token.raw {
Ok(RealClassification::Canonical(value))
} else {
Ok(RealClassification::Literal {
value,
literal: token.raw,
})
}
}
#[cfg(test)]
fn parse_integer_token(token: &Token) -> Result<i64> {
let text = std::str::from_utf8(&token.value)
.map_err(|_| Error::parse(token.start, "invalid integer"))?;
match text.parse::<i64>() {
Ok(value) => Ok(value),
Err(error)
if matches!(
error.kind(),
std::num::IntErrorKind::PosOverflow | std::num::IntErrorKind::NegOverflow
) =>
{
Err(Error::System(format!(
"overflow/underflow converting {text} to 64-bit integer"
)))
}
Err(_) => Err(Error::parse(token.start, "invalid integer")),
}
}
fn qpdf_int(value: i64, offset: usize) -> Result<i32> {
i32::try_from(value).map_err(|_| {
Error::parse(
offset,
format!(
"integer out of range converting {value} from a 8-byte signed type to a 4-byte signed type"
),
)
})
}
pub(crate) fn keyword_token_end(input: &[u8], pos: usize, keyword: &[u8]) -> Option<usize> {
let end = pos.checked_add(keyword.len())?;
if input.get(pos..end)? != keyword {
return None;
}
match input.get(end) {
None => Some(end),
Some(&byte) if is_ws(byte) || is_delimiter(byte) => Some(end),
Some(_) => None,
}
}