pub(crate) fn qpdf_resolve_top_level_object<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
) -> Result<ObjectHandle, ConvertError> {
Ok(pdf.resolve_qpdf_json_handle(start)?)
}
pub fn qpdf_raw_stream_payload<R: Read + Seek>(
pdf: &mut Pdf<R>,
object_ref: ObjectRef,
decode_level: DecodeLevel,
) -> Result<Option<Vec<u8>>, ConvertError> {
let stream = qpdf_resolve_top_level_object(pdf, object_ref)?;
if stream.as_stream_dict().is_none() {
return Ok(None);
}
Ok(Some(
stream_payload_with_decode_status(&stream, decode_level)?
.bytes
.into_owned(),
))
}
pub fn pdf_object_to_json(handle: &ObjectHandle) -> Result<Json, ConvertError> {
pdf_object_to_json_with_version(handle, QPDF_JSON_VERSION)
}
pub(crate) fn pdf_object_to_json_with_version(
handle: &ObjectHandle,
version: i32,
) -> Result<Json, ConvertError> {
handle
.get_json(version, false)
.map_err(convert_object_json_error)
}
fn convert_object_json_error(error: ObjectJsonError) -> ConvertError {
match error {
ObjectJsonError::NonFiniteFloat => ConvertError::NonFiniteFloat,
ObjectJsonError::Json(message) => ConvertError::JsonError(message),
ObjectJsonError::Pipeline(error) => ConvertError::PdfError(error.to_string()),
ObjectJsonError::Pdf(message) => ConvertError::PdfError(message),
other => ConvertError::PdfError(other.to_string()),
}
}
pub(crate) fn pdf_dest_to_json_with_version(
handle: &ObjectHandle,
version: i32,
) -> Result<Json, ConvertError> {
handle
.get_json(version, true)
.map_err(convert_object_json_error)
}
#[derive(Debug, Clone, Default)]
pub enum StreamDataMode {
#[default]
None,
Inline,
File { prefix: String },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DecodeLevel {
None,
#[default]
Generalized,
Specialized,
All,
}
impl DecodeLevel {
pub fn as_qpdf_str(&self) -> &'static str {
match self {
DecodeLevel::None => "none",
DecodeLevel::Generalized => "generalized",
DecodeLevel::Specialized => "specialized",
DecodeLevel::All => "all",
}
}
}
pub fn stream_payload_for_decode_level(
stream: &ObjectHandle,
decode_level: DecodeLevel,
) -> crate::Result<Cow<'_, [u8]>> {
Ok(stream_payload_with_decode_status(stream, decode_level)?.bytes)
}
pub(crate) struct StreamPayload<'a> {
pub(crate) bytes: Cow<'a, [u8]>,
}
pub(crate) fn stream_payload_with_decode_status(
stream: &ObjectHandle,
decode_level: DecodeLevel,
) -> crate::Result<StreamPayload<'_>> {
let raw_data = stream.get_raw_stream_data()?;
if matches!(decode_level, DecodeLevel::None) {
return Ok(StreamPayload {
bytes: Cow::Owned(raw_data.as_ref().clone()),
});
}
let stream_dict = stream
.as_stream_dict()
.expect("get_raw_stream_data succeeded, so stream must have a stream dict");
let Some(capabilities) = crate::filters::stream_filter_capabilities(&stream_dict) else {
return Ok(StreamPayload {
bytes: Cow::Owned(raw_data.as_ref().clone()),
});
};
let can_filter = if decode_level == DecodeLevel::Generalized {
!capabilities.specialized_compression && !capabilities.lossy_compression
} else if decode_level == DecodeLevel::Specialized {
!capabilities.lossy_compression
} else {
true
};
if !can_filter {
return Ok(StreamPayload {
bytes: Cow::Owned(raw_data.as_ref().clone()),
});
}
match crate::filters::decode_stream_data(&stream_dict, raw_data.as_ref()) {
Ok(decoded) => Ok(StreamPayload {
bytes: Cow::Owned(decoded),
}),
Err(_) => Ok(StreamPayload {
bytes: Cow::Owned(raw_data.as_ref().clone()),
}),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum JsonKey {
Acroform,
Attachments,
Encrypt,
Outlines,
Pagelabels,
Pages,
Qpdf,
Objects,
Objectinfo,
}
impl JsonKey {
pub const ALL_NAMES: &'static [&'static str] = &[
"acroform",
"attachments",
"encrypt",
"objectinfo",
"objects",
"outlines",
"pagelabels",
"pages",
"qpdf",
];
#[allow(clippy::should_implement_trait)]
pub fn from_str(s: &str) -> Option<Self> {
match s {
"acroform" => Some(JsonKey::Acroform),
"attachments" => Some(JsonKey::Attachments),
"encrypt" => Some(JsonKey::Encrypt),
"outlines" => Some(JsonKey::Outlines),
"pagelabels" => Some(JsonKey::Pagelabels),
"pages" => Some(JsonKey::Pages),
"qpdf" => Some(JsonKey::Qpdf),
"objects" => Some(JsonKey::Objects),
"objectinfo" => Some(JsonKey::Objectinfo),
_ => None,
}
}
pub(crate) fn output_key_name(self) -> &'static str {
match self {
JsonKey::Acroform => "acroform",
JsonKey::Attachments => "attachments",
JsonKey::Encrypt => "encrypt",
JsonKey::Outlines => "outlines",
JsonKey::Pagelabels => "pagelabels",
JsonKey::Pages => "pages",
JsonKey::Qpdf => "qpdf",
JsonKey::Objects => "objects",
JsonKey::Objectinfo => "objectinfo",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum JsonObjectSelector {
Object { number: u32, generation: u16 },
Trailer,
}
impl JsonObjectSelector {
#[allow(clippy::should_implement_trait)]
pub fn from_str(s: &str) -> Option<Self> {
if s == "trailer" {
return Some(JsonObjectSelector::Trailer);
}
if s.is_empty() {
return None;
}
let reference_parts: Vec<&str> = s.split_whitespace().collect();
if reference_parts.len() == 3 && reference_parts[2] == "R" {
let number = reference_parts[0].parse::<u32>().ok()?;
let generation = reference_parts[1].parse::<u16>().ok()?;
return Some(JsonObjectSelector::Object { number, generation });
}
let parts: Vec<&str> = s.splitn(3, ',').collect();
if parts.len() > 2 {
return None;
}
let num_str = parts[0];
if num_str.is_empty() || !num_str.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
let number: u32 = num_str.parse().ok()?;
let generation: u16 = if parts.len() == 2 {
let gen_str = parts[1];
if gen_str.is_empty() || !gen_str.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
gen_str.parse().ok()?
} else {
0
};
Some(JsonObjectSelector::Object { number, generation })
}
}
use crate::json::Json;
use crate::object_handle::{ObjectHandle, ObjectJsonError};
use crate::object_ref::ObjectRef;
use crate::pipeline::PipelineError;
use crate::Pdf;
use std::borrow::Cow;
use std::io::{Read, Seek, Write};
pub(crate) use crate::pdf_string::decode_pdf_text_string;
pub(crate) const QPDF_JSON_VERSION: i32 = 2;
#[derive(Debug, Clone, PartialEq)]
pub enum ConvertError {
NonFiniteFloat,
PdfError(String),
JsonError(String),
}
impl std::fmt::Display for ConvertError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ConvertError::NonFiniteFloat => {
write!(f, "non-finite float cannot be serialized as JSON")
}
ConvertError::PdfError(msg) => write!(f, "PDF error: {msg}"),
ConvertError::JsonError(msg) => write!(f, "JSON error: {msg}"),
}
}
}
impl std::error::Error for ConvertError {}
impl From<crate::Error> for ConvertError {
fn from(err: crate::Error) -> Self {
ConvertError::PdfError(err.to_string())
}
}
impl From<ObjectJsonError> for JsonOutputError {
fn from(error: ObjectJsonError) -> Self {
match error {
ObjectJsonError::Pipeline(error) => Self::Pipeline(error),
ObjectJsonError::NonFiniteFloat => Self::Convert(ConvertError::NonFiniteFloat),
ObjectJsonError::Json(message) => Self::Convert(ConvertError::JsonError(message)),
ObjectJsonError::Pdf(message) => Self::Convert(ConvertError::PdfError(message)),
other => Self::Convert(ConvertError::PdfError(other.to_string())),
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum JsonOutputError {
#[error(transparent)]
Convert(#[from] ConvertError),
#[error(transparent)]
Pipeline(#[from] PipelineError),
#[error("{operation} {path}: {message}")]
SideFileIo {
operation: &'static str,
path: String,
message: String,
#[source]
source: std::io::Error,
},
#[error("QPDF::writeJSON: only version 2 is supported")]
UnsupportedVersion,
}
pub enum JsonOutput<'a> {
Stdout(&'a mut dyn Write),
File(&'a mut dyn Write),
}
pub(crate) fn side_file_io_error(
operation: &'static str,
path: &str,
source: std::io::Error,
) -> JsonOutputError {
let rendered = source.to_string();
let message = source
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered)
.to_owned();
JsonOutputError::SideFileIo {
operation,
path: path.to_owned(),
message,
source,
}
}
pub(crate) fn json_array(values: impl IntoIterator<Item = Json>) -> Result<Json, ConvertError> {
let array = Json::make_array();
for value in values {
array
.add_array_element(value)
.map_err(|error| ConvertError::JsonError(error.to_string()))?;
}
Ok(array)
}
pub(crate) fn json_dictionary<K: AsRef<[u8]>>(
pairs: impl IntoIterator<Item = (K, Json)>,
) -> Result<Json, ConvertError> {
let dictionary = Json::make_dictionary();
for (key, value) in pairs {
dictionary
.add_dictionary_member(key, value)
.map_err(|error| ConvertError::JsonError(error.to_string()))?;
}
Ok(dictionary)
}
#[cfg(test)]
mod tests {
use super::{
convert_object_json_error, pdf_object_to_json, qpdf_raw_stream_payload,
stream_payload_for_decode_level, ConvertError, DecodeLevel, JsonObjectSelector,
JsonOutputError,
};
use crate::object_handle::{ObjectHandle, ObjectJsonError};
use crate::pipeline::PipelineError;
use crate::Pdf;
use std::io::Cursor;
use std::rc::Rc;
fn stream(data: Vec<u8>, filter: Option<&[u8]>) -> ObjectHandle {
let mut entries = vec![(
b"/Length".to_vec(),
ObjectHandle::integer(data.len() as i64),
)];
if let Some(filter) = filter {
entries.push((b"/Filter".to_vec(), ObjectHandle::name(filter.to_vec())));
}
ObjectHandle::stream(ObjectHandle::dictionary(entries), Rc::new(data))
}
fn stream_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = b"%PDF-1.7\n".to_vec();
let objects = [
b"<< /Type /Catalog /Pages 2 0 R >>".as_slice(),
b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".as_slice(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 10 10] /Contents 4 0 R >>".as_slice(),
b"<< /Length 5 >>\nstream\nhello\nendstream".as_slice(),
];
let mut offsets = Vec::new();
for (index, body) in objects.iter().enumerate() {
offsets.push(bytes.len());
bytes.extend_from_slice(format!("{} 0 obj\n", index + 1).as_bytes());
bytes.extend_from_slice(body);
bytes.extend_from_slice(b"\nendobj\n");
}
let xref = bytes.len();
bytes.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
for offset in offsets {
bytes.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
bytes.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
Pdf::open(Cursor::new(bytes)).expect("stream fixture opens")
}
#[test]
fn conversion_errors_keep_their_public_text_and_categories() {
assert_eq!(
ConvertError::NonFiniteFloat.to_string(),
"non-finite float cannot be serialized as JSON"
);
assert_eq!(
ConvertError::PdfError("broken PDF".to_owned()).to_string(),
"PDF error: broken PDF"
);
assert_eq!(
ConvertError::JsonError("bad JSON".to_owned()).to_string(),
"JSON error: bad JSON"
);
assert!(matches!(
JsonOutputError::from(ObjectJsonError::Pipeline(PipelineError::logic("pipeline"))),
JsonOutputError::Pipeline(_)
));
assert!(matches!(
JsonOutputError::from(ObjectJsonError::NonFiniteFloat),
JsonOutputError::Convert(ConvertError::NonFiniteFloat)
));
assert!(matches!(
JsonOutputError::from(ObjectJsonError::Json("json".to_owned())),
JsonOutputError::Convert(ConvertError::JsonError(message)) if message == "json"
));
assert!(matches!(
JsonOutputError::from(ObjectJsonError::Pdf("pdf".to_owned())),
JsonOutputError::Convert(ConvertError::PdfError(message)) if message == "pdf"
));
assert!(matches!(
JsonOutputError::from(ObjectJsonError::UnsupportedVersion(3)),
JsonOutputError::Convert(ConvertError::PdfError(message))
if message.contains("only version 1 or 2")
));
}
#[test]
fn standalone_json_and_raw_stream_routes_use_canonical_handles() {
let scalar = ObjectHandle::integer(7);
assert_eq!(
pdf_object_to_json(&scalar)
.expect("scalar JSON")
.unparse()
.expect("scalar JSON bytes"),
b"7"
);
assert!(matches!(
pdf_object_to_json(&ObjectHandle::real(f64::NAN)),
Err(ConvertError::NonFiniteFloat)
));
let mut pdf = stream_pdf();
assert_eq!(
qpdf_raw_stream_payload(&mut pdf, crate::ObjectRef::new(4, 0), DecodeLevel::None)
.expect("raw stream payload")
.expect("stream object"),
b"hello"
);
assert_eq!(
qpdf_raw_stream_payload(&mut pdf, crate::ObjectRef::new(1, 0), DecodeLevel::All)
.expect("non-stream payload lookup"),
None
);
}
#[test]
fn stream_decode_levels_cover_raw_specialized_unsupported_and_corrupt_paths() {
let plain = stream(b"plain".to_vec(), None);
assert_eq!(
stream_payload_for_decode_level(&plain, DecodeLevel::None)
.expect("raw payload")
.as_ref(),
b"plain"
);
assert_eq!(
stream_payload_for_decode_level(&plain, DecodeLevel::Generalized)
.expect("plain decoded payload")
.as_ref(),
b"plain"
);
let unknown = stream(b"raw".to_vec(), Some(b"UnknownDecode"));
assert_eq!(
stream_payload_for_decode_level(&unknown, DecodeLevel::All)
.expect("unknown filter raw fallback")
.as_ref(),
b"raw"
);
let specialized = stream(b"raw".to_vec(), Some(b"RunLengthDecode"));
assert_eq!(
stream_payload_for_decode_level(&specialized, DecodeLevel::Generalized)
.expect("specialized filter remains raw")
.as_ref(),
b"raw"
);
assert!(
!stream_payload_for_decode_level(&specialized, DecodeLevel::Specialized)
.expect("specialized filter is selected at specialized level")
.is_empty()
);
let corrupt = stream(b"not-flate".to_vec(), Some(b"FlateDecode"));
assert_eq!(
stream_payload_for_decode_level(&corrupt, DecodeLevel::All)
.expect("corrupt filter raw fallback")
.as_ref(),
b"not-flate"
);
}
#[test]
fn selectors_and_object_error_conversion_cover_all_public_boundaries() {
assert_eq!(DecodeLevel::None.as_qpdf_str(), "none");
assert_eq!(DecodeLevel::Generalized.as_qpdf_str(), "generalized");
assert_eq!(DecodeLevel::Specialized.as_qpdf_str(), "specialized");
assert_eq!(DecodeLevel::All.as_qpdf_str(), "all");
assert_eq!(
JsonObjectSelector::from_str("trailer"),
Some(JsonObjectSelector::Trailer)
);
assert_eq!(
JsonObjectSelector::from_str("12,3"),
Some(JsonObjectSelector::Object {
number: 12,
generation: 3
})
);
assert!(JsonObjectSelector::from_str("").is_none());
assert!(JsonObjectSelector::from_str("1,2,3").is_none());
assert!(JsonObjectSelector::from_str("1,").is_none());
assert!(matches!(
convert_object_json_error(ObjectJsonError::NonFiniteFloat),
ConvertError::NonFiniteFloat
));
assert!(matches!(
convert_object_json_error(ObjectJsonError::Json("json".to_owned())),
ConvertError::JsonError(message) if message == "json"
));
assert!(matches!(
convert_object_json_error(ObjectJsonError::Pipeline(PipelineError::logic("pipeline"))),
ConvertError::PdfError(message) if message.contains("pipeline")
));
assert!(matches!(
convert_object_json_error(ObjectJsonError::Pdf("pdf".to_owned())),
ConvertError::PdfError(message) if message == "pdf"
));
assert!(matches!(
convert_object_json_error(ObjectJsonError::UnsupportedVersion(4)),
ConvertError::PdfError(message) if message.contains("only version 1 or 2")
));
}
}