use crate::parser::{parse_live_content_stream_object, ContentHandleResolver, SliceLiveInput};
use crate::tokenizer::{TokenType, Tokenizer, TokenizerStateError};
use crate::{
object_handle::{DocumentResolver, ObjectHandle},
Error, QpdfErrorCode, QpdfExc, Result,
};
use std::{cell::RefCell, rc::Rc};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ParseControl {
Continue,
Stop,
}
pub trait ObjectHandleParserCallbacks {
fn content_size(&mut self, _size: usize) -> Result<()> {
Ok(())
}
fn handle_object(
&mut self,
object: ObjectHandle,
offset: usize,
length: usize,
) -> Result<ParseControl>;
fn handle_eof(&mut self) -> Result<()>;
}
fn deliver_diagnostic(
context: Option<&Rc<dyn DocumentResolver>>,
source_description: &str,
object_description: &str,
offset: usize,
message: &[u8],
) -> Result<()> {
let warning = QpdfExc::new(
QpdfErrorCode::DamagedPdf,
source_description.as_bytes(),
object_description.as_bytes(),
i64::try_from(offset).unwrap_or(i64::MAX),
message,
);
if let Some(context) = context {
context.warn(warning)?;
Ok(())
} else {
Err(Error::QpdfExc(warning))
}
}
pub(crate) fn parse_content_stream_handles_with_recoverable_warnings<
C: ObjectHandleParserCallbacks,
>(
input: &[u8],
source_description: &str,
callbacks: &mut C,
) -> Result<()> {
parse_content_stream_handles_with_recoverable_warnings_and_status(
input,
source_description,
callbacks,
)
.map(|_| ())
}
pub(crate) fn parse_content_stream_handles_with_recoverable_warnings_and_status<
C: ObjectHandleParserCallbacks,
>(
input: &[u8],
source_description: &str,
callbacks: &mut C,
) -> Result<bool> {
let context: Rc<dyn DocumentResolver> = Rc::new(RecoverableWarningResolver::default());
parse_content_stream_handles_internal(input, Some(context), source_description, callbacks)
}
pub(crate) fn parse_content_stream_handles<C: ObjectHandleParserCallbacks>(
input: &[u8],
context: Option<Rc<dyn DocumentResolver>>,
source_description: &str,
callbacks: &mut C,
) -> Result<()> {
parse_content_stream_handles_internal(input, context, source_description, callbacks).map(|_| ())
}
fn parse_content_stream_handles_internal<C: ObjectHandleParserCallbacks>(
input: &[u8],
context: Option<Rc<dyn DocumentResolver>>,
source_description: &str,
callbacks: &mut C,
) -> Result<bool> {
callbacks.content_size(input.len())?;
let mut tokenizer = Tokenizer::new(input);
tokenizer.allow_eof();
let mut live_input = SliceLiveInput::new(input);
let mut stopped_on_container_eof = false;
while tokenizer.position() < input.len() {
let probe = tokenizer.read_token(true, 0)?;
let offset = probe.start;
tokenizer.set_position(offset)?;
live_input.seek_to(offset)?;
let (object, length, diagnostics) = {
let mut resolver = ContentHandleResolver::new(context.clone());
let parsed = parse_live_content_stream_object(&mut live_input, &mut resolver)?;
let length = live_input.position() - offset;
(parsed.value, length, parsed.diagnostics)
};
tokenizer.set_position(live_input.position())?;
for diagnostic in diagnostics {
if diagnostic.message == b"parse error while reading object" {
stopped_on_container_eof = true;
}
deliver_diagnostic(
context.as_ref(),
source_description,
"content",
diagnostic.relative_offset,
&diagnostic.message,
)?; }
if !object.is_initialized() {
break;
}
let is_id = object.as_operator().as_deref() == Some(b"ID");
if callbacks.handle_object(object, offset, length)? == ParseControl::Stop {
return Ok(false);
}
if is_id {
if tokenizer.consume_one_byte().is_err() {
deliver_diagnostic(
context.as_ref(),
source_description,
"stream data",
input.len(),
b"EOF found while reading inline image",
)?;
break;
}
let inline_offset = tokenizer.position();
tokenizer.expect_inline_image().map_err(|error| {
let message = match error {
TokenizerStateError::TokenWaiting => "tokenizer already has a token waiting",
TokenizerStateError::ImproperInlineImageState => {
"tokenizer is in an improper inline image state"
}
};
Error::parse(inline_offset, message)
})?;
let image = tokenizer.read_token(true, 0)?;
if image.token_type == TokenType::Bad {
let diagnostic = "EOF found while reading inline image";
deliver_diagnostic(
context.as_ref(),
source_description,
"stream data",
image.end,
diagnostic.as_bytes(),
)?; break;
}
let image_offset = image.start;
let image_length = image.end - image.start;
if callbacks.handle_object(
ObjectHandle::inline_image(image.value),
image_offset,
image_length,
)? == ParseControl::Stop
{
return Ok(false);
}
}
}
callbacks.handle_eof()?;
Ok(stopped_on_container_eof)
}
#[derive(Default)]
struct RecoverableWarningResolver {
warnings: RefCell<Vec<QpdfExc>>,
}
impl DocumentResolver for RecoverableWarningResolver {
fn resolve_indirect(
&self,
_object_ref: crate::ObjectRef,
_handle: &ObjectHandle,
) -> Result<()> {
Err(Error::Internal(
"indirect resolution requested from an in-memory content warning sink".to_owned(),
))
}
fn warn(&self, warning: QpdfExc) -> Result<()> {
self.warnings.borrow_mut().push(warning);
Ok(())
}
}
pub(crate) struct OperationCallbacks<F> {
operands: Vec<ObjectHandle>,
on_operation: F,
}
pub(crate) fn parse_content_operations_with_recoverable_warnings<F>(
input: &[u8],
on_operation: F,
) -> Result<()>
where
F: FnMut(&[ObjectHandle], &[u8]) -> Result<ParseControl>,
{
let mut callbacks = OperationCallbacks {
operands: Vec::new(),
on_operation,
};
parse_content_stream_handles_with_recoverable_warnings(input, "", &mut callbacks)
}
impl<F> ObjectHandleParserCallbacks for OperationCallbacks<F>
where
F: FnMut(&[ObjectHandle], &[u8]) -> Result<ParseControl>,
{
fn handle_object(
&mut self,
object: ObjectHandle,
_offset: usize,
_length: usize,
) -> Result<ParseControl> {
if let Some(operator) = object.as_operator() {
let control = (self.on_operation)(&self.operands, &operator)?;
self.operands.clear();
Ok(control)
} else if object.as_inline_image().is_some() {
Ok(ParseControl::Continue)
} else {
self.operands.push(object);
Ok(ParseControl::Continue)
}
}
fn handle_eof(&mut self) -> Result<()> {
Ok(())
}
}
pub fn parse_content_operations<F>(input: &[u8], on_operation: F) -> Result<()>
where
F: FnMut(&[ObjectHandle], &[u8]) -> Result<ParseControl>,
{
let mut callbacks = OperationCallbacks {
operands: Vec::new(),
on_operation,
};
parse_content_stream_handles(input, None, "", &mut callbacks)
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Default)]
struct RecordingResolver {
warnings: RefCell<Vec<Vec<u8>>>,
}
impl DocumentResolver for RecordingResolver {
fn resolve_indirect(
&self,
_object_ref: crate::ObjectRef,
_handle: &ObjectHandle,
) -> Result<()> {
Err(Error::Internal("unexpected indirect resolution".to_owned()))
}
fn warn(&self, warning: QpdfExc) -> Result<()> {
self.warnings
.borrow_mut()
.push(warning.what_bytes().to_vec());
Ok(())
}
}
#[derive(Default)]
struct RecordingCallbacks {
objects: usize,
eof: bool,
}
impl ObjectHandleParserCallbacks for RecordingCallbacks {
fn handle_object(
&mut self,
_object: ObjectHandle,
_offset: usize,
_length: usize,
) -> Result<ParseControl> {
self.objects += 1;
Ok(ParseControl::Continue)
}
fn handle_eof(&mut self) -> Result<()> {
self.eof = true;
Ok(())
}
}
#[test]
fn recoverable_warning_resolver_rejects_indirect_resolution() {
let resolver = RecoverableWarningResolver::default();
let object_ref = crate::ObjectRef::new(9, 0);
let handle = ObjectHandle::new_indirect_unresolved(object_ref, -1);
let error = resolver
.resolve_indirect(object_ref, &handle)
.expect_err("an in-memory warning sink cannot resolve indirect objects");
assert!(matches!(
error,
Error::Internal(message)
if message == "indirect resolution requested from an in-memory content warning sink"
));
}
#[test]
fn recording_warning_resolver_rejects_indirect_resolution() {
let resolver = RecordingResolver::default();
let error = resolver
.resolve_indirect(crate::ObjectRef::new(7, 0), &ObjectHandle::null())
.expect_err("the test warning resolver must reject indirect resolution");
assert!(matches!(
error,
Error::Internal(message) if message == "unexpected indirect resolution"
));
}
#[test]
fn container_eof_warns_and_finishes_content_parsing_like_qpdf() {
for input in [b"/F1 12 Tf [".as_slice(), b"/F1 12 Tf << /A 1".as_slice()] {
let resolver = Rc::new(RecordingResolver::default());
let context: Rc<dyn DocumentResolver> = resolver.clone();
let mut callbacks = RecordingCallbacks::default();
parse_content_stream_handles(
input,
Some(context),
"page object 14 0 stream 14 0",
&mut callbacks,
)
.expect("content EOF is a warning, not a hard parser error");
assert_eq!(callbacks.objects, 3, "qpdf keeps the complete prefix");
assert!(
callbacks.eof,
"qpdf invokes handleEOF after the truncated object"
);
let warnings = resolver.warnings.borrow();
assert_eq!(warnings.len(), 1, "qpdf emits one container EOF warning");
let warning = String::from_utf8_lossy(&warnings[0]);
let expected = format!(
"page object 14 0 stream 14 0 (content, offset {}): parse error while reading object",
input.len()
);
assert!(
warning.contains(&expected),
"warning must use qpdf's content description: {warning}"
);
}
}
#[test]
fn nested_container_eof_propagates_to_the_outer_content_parse() {
for input in [
b"<< /A [".as_slice(),
b"<< 1 [".as_slice(),
b"[[".as_slice(),
] {
let resolver = Rc::new(RecordingResolver::default());
let context: Rc<dyn DocumentResolver> = resolver.clone();
let mut callbacks = RecordingCallbacks::default();
parse_content_stream_handles(input, Some(context), "nested", &mut callbacks)
.expect("nested content EOF is a warning, not a hard parser error");
assert_eq!(
callbacks.objects, 0,
"the incomplete outer object is discarded"
);
assert!(callbacks.eof, "qpdf completes the scan after the warning");
let warnings = resolver.warnings.borrow();
assert_eq!(
warnings.len(),
1,
"qpdf emits one nested container EOF warning"
);
assert!(String::from_utf8_lossy(&warnings[0]).contains(&format!(
"nested (content, offset {}): parse error while reading object",
input.len()
)));
}
}
}