use crate::parser::ContentHandleParser;
use crate::tokenizer::{TokenType, Tokenizer, TokenizerStateError};
use crate::{
object_handle::{format_qpdf_exception_what, DocumentResolver, ObjectHandle},
Error, 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: &str,
) -> Result<()> {
let message = format_qpdf_exception_what(
source_description,
object_description,
offset as i64,
message,
);
if let Some(context) = context {
context.warn(message.into_bytes())?;
Ok(())
} else {
Err(Error::System(message))
}
}
pub(crate) fn parse_content_stream_handles_with_recoverable_warnings<
C: ObjectHandleParserCallbacks,
>(
input: &[u8],
source_description: &str,
callbacks: &mut C,
) -> Result<()> {
let context: Rc<dyn DocumentResolver> = Rc::new(RecoverableWarningResolver::default());
parse_content_stream_handles(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<()> {
callbacks.content_size(input.len())?;
let mut tokenizer = Tokenizer::new(input);
tokenizer.allow_eof();
while tokenizer.position() < input.len() {
let probe = tokenizer.read_token(true, 0)?;
let offset = probe.start;
tokenizer.set_position(offset)?;
let (object, length, diagnostics) = {
let mut parser = ContentHandleParser::with_tokenizer(&mut tokenizer, context.clone());
let object = match parser.parse_content_object()? {
Some(object) => object,
None => break,
};
let length = parser.position() - offset;
let diagnostics = parser.take_diagnostics();
(object, length, diagnostics)
};
for diagnostic in diagnostics {
deliver_diagnostic(
context.as_ref(),
source_description,
"content",
diagnostic.relative_offset,
&diagnostic.message,
)?; }
let is_id = object.as_operator().as_deref() == Some(b"ID");
if callbacks.handle_object(object, offset, length)? == ParseControl::Stop {
return Ok(());
}
if is_id {
if tokenizer.consume_one_byte().is_err() {
deliver_diagnostic(
context.as_ref(),
source_description,
"stream data",
input.len(),
"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,
)?; 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(());
}
}
}
callbacks.handle_eof()
}
#[derive(Default)]
struct RecoverableWarningResolver {
warnings: RefCell<Vec<Vec<u8>>>,
}
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, message: Vec<u8>) -> Result<()> {
self.warnings.borrow_mut().push(message);
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::*;
#[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"
));
}
}