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: Vec<u8> },
}
#[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",
}
}
}
#[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: i32, generation: i32 },
Trailer,
}
impl JsonObjectSelector {
#[allow(clippy::should_implement_trait)]
pub fn parse(s: &str) -> Result<Self, String> {
if s == "trailer" {
return Ok(JsonObjectSelector::Trailer);
}
let number = parse_qpdf_selector_integer(s)?;
let generation = if let Some(comma) = s.find(',') {
if comma + 1 == s.len() {
0
} else {
parse_qpdf_selector_integer(&s[comma + 1..])?
}
} else {
0
};
Ok(JsonObjectSelector::Object { number, generation })
}
#[allow(clippy::should_implement_trait)]
pub fn from_str(s: &str) -> Option<Self> {
Self::parse(s).ok()
}
}
fn parse_qpdf_selector_integer(value: &str) -> Result<i32, String> {
match crate::qutil::qpdf_string_to_int_checked(value) {
crate::qutil::QpdfIntParse::Value(value) => Ok(value),
crate::qutil::QpdfIntParse::NoDigits => Ok(0),
crate::qutil::QpdfIntParse::Overflow(message) => Err(message),
}
}
use crate::json::Json;
use crate::object_handle::{ObjectHandle, ObjectJsonError};
use crate::pipeline::PipelineError;
use std::io::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,
QpdfExc(crate::QpdfExc),
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::QpdfExc(error) => std::fmt::Display::fmt(error, f),
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 {
match err {
crate::Error::QpdfExc(error) => ConvertError::QpdfExc(error),
error => ConvertError::PdfError(error.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("{0}")]
ObjectSelector(String),
#[error("{operation} {path}: {message}")]
SideFileIo {
operation: &'static str,
path: String,
raw_path: Vec<u8>,
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: &[u8],
source: std::io::Error,
) -> JsonOutputError {
let raw_path = path.to_vec();
let message = crate::qutil::strerror_text(&source);
JsonOutputError::SideFileIo {
operation,
path: String::from_utf8_lossy(&raw_path).into_owned(),
raw_path,
message,
source,
}
}
impl From<JsonOutputError> for crate::Error {
fn from(error: JsonOutputError) -> Self {
match error {
JsonOutputError::Convert(ConvertError::QpdfExc(error)) => crate::Error::QpdfExc(error),
JsonOutputError::Convert(error) => crate::Error::System(error.to_string()),
JsonOutputError::Pipeline(error) => crate::Error::from(error),
JsonOutputError::ObjectSelector(message) => crate::Error::System(message),
JsonOutputError::SideFileIo {
operation,
raw_path,
message,
..
} => {
let mut raw_message = operation.as_bytes().to_vec();
raw_message.push(b' ');
raw_message.extend_from_slice(&raw_path);
raw_message.extend_from_slice(b": ");
raw_message.extend_from_slice(message.as_bytes());
crate::Error::SystemBytes(raw_message)
}
JsonOutputError::UnsupportedVersion => {
crate::Error::System("QPDF::writeJSON: only version 2 is supported".to_owned())
}
}
}
}
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, 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 qpdf_exception_json_error_round_trip_retains_raw_what_bytes() {
let original = crate::QpdfExc::new(
crate::QpdfErrorCode::Object,
b"",
b"",
0,
b"raw qpdf error \xff",
);
let convert_error = ConvertError::from(crate::Error::QpdfExc(original.clone()));
let output_error: crate::Error = JsonOutputError::Convert(convert_error).into();
assert_eq!(output_error.raw_message(), Some(original.what_bytes()));
}
#[test]
fn side_file_error_conversion_retains_raw_path_bytes() {
let error = super::side_file_io_error(
"open",
b"side-\xff-7",
std::io::Error::other("instrumented side-file failure"),
);
assert_eq!(
error.to_string(),
"open side-�-7: instrumented side-file failure"
);
let error: crate::Error = error.into();
assert_eq!(
error.raw_message(),
Some(b"open side-\xff-7: instrumented side-file failure".as_slice())
);
}
#[test]
fn json_output_error_conversion_preserves_all_error_categories() {
let converted: crate::Error =
JsonOutputError::Convert(ConvertError::JsonError("invalid output".to_owned())).into();
assert!(matches!(
converted,
crate::Error::System(message) if message == "JSON error: invalid output"
));
let piped: crate::Error =
JsonOutputError::Pipeline(PipelineError::runtime("pipeline")).into();
assert!(matches!(
piped,
crate::Error::System(message) if message == "pipeline"
));
let selector: crate::Error =
JsonOutputError::ObjectSelector("selector overflow".to_owned()).into();
assert!(matches!(
selector,
crate::Error::System(message) if message == "selector overflow"
));
let unsupported: crate::Error = JsonOutputError::UnsupportedVersion.into();
assert!(matches!(
unsupported,
crate::Error::System(message)
if message == "QPDF::writeJSON: only version 2 is supported"
));
}
#[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();
let stream = pdf.get_object_handle(crate::ObjectRef::new(4, 0));
assert_eq!(
stream
.get_raw_stream_data()
.expect("raw stream payload")
.as_slice(),
b"hello"
);
let scalar = pdf.get_object_handle(crate::ObjectRef::new(1, 0));
scalar.try_dereference().expect("resolve non-stream object");
assert!(scalar.as_stream_dict().is_none());
}
#[test]
fn stream_decode_levels_cover_raw_specialized_unsupported_and_corrupt_paths() {
let plain = stream(b"plain".to_vec(), None);
assert_eq!(
plain.get_raw_stream_data().expect("raw payload").as_slice(),
b"plain"
);
assert_eq!(
plain
.get_stream_data(crate::writer::DecodeLevel::Generalized)
.expect("plain decoded payload")
.as_slice(),
b"plain"
);
let unknown = stream(b"raw".to_vec(), Some(b"UnknownDecode"));
assert!(matches!(
unknown.get_stream_data(crate::writer::DecodeLevel::All),
Err(crate::Error::QpdfExc(error))
if error.get_error_code() == crate::QpdfErrorCode::Unsupported
&& error.get_message_detail() == b"getStreamData called on unfilterable stream"
));
let specialized = stream(b"raw".to_vec(), Some(b"RunLengthDecode"));
assert!(matches!(
specialized.get_stream_data(crate::writer::DecodeLevel::Generalized),
Err(crate::Error::QpdfExc(error))
if error.get_error_code() == crate::QpdfErrorCode::Unsupported
&& error.get_message_detail() == b"getStreamData called on unfilterable stream"
));
assert!(!specialized
.get_stream_data(crate::writer::DecodeLevel::Specialized)
.expect("specialized filter is selected at specialized level")
.is_empty());
let corrupt = stream(b"not-flate".to_vec(), Some(b"FlateDecode"));
assert!(matches!(
corrupt.get_stream_data(crate::writer::DecodeLevel::All),
Err(crate::Error::System(message))
if message == "stream inflate: inflate: data: incorrect header check"
));
}
#[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_eq!(
JsonObjectSelector::from_str("1,2,3"),
Some(JsonObjectSelector::Object {
number: 1,
generation: 2
})
);
assert_eq!(
JsonObjectSelector::from_str("1,"),
Some(JsonObjectSelector::Object {
number: 1,
generation: 0
})
);
assert_eq!(
JsonObjectSelector::from_str("-1"),
Some(JsonObjectSelector::Object {
number: -1,
generation: 0
})
);
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")
));
}
}