use crate::json::Json;
use crate::json_inspect::{
side_file_io_error, ConvertError, DecodeLevel, JsonObjectSelector, JsonOutputError,
StreamDataMode,
};
use crate::object_handle::{ObjectHandle, QpdfStreamJsonData};
use crate::pipeline::buffer::Buffer;
use crate::pipeline::stdio_file::StdioBuffer;
use crate::pipeline::{Pipeline, PlStdioFile};
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::Pdf;
use std::fs::File;
use std::io::{Read, Seek, Write};
use std::path::PathBuf;
const SUPPORTED_JSON_VERSION: i32 = 2;
pub(crate) fn parse_object_selectors(
raw_selectors: &[String],
) -> Result<Vec<JsonObjectSelector>, JsonOutputError> {
raw_selectors
.iter()
.map(|selector| {
JsonObjectSelector::parse(selector).map_err(JsonOutputError::ObjectSelector)
})
.collect()
}
pub(crate) fn write_json_v1_objects_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut dyn Pipeline,
first: &mut bool,
wanted_objects: &[String],
) -> Result<(), JsonOutputError> {
Json::write_dictionary_key(out, first, b"objects", 1)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 1)?;
let wanted_objects = parse_object_selectors(wanted_objects)?;
for handle in pdf.get_all_objects().map_err(ConvertError::from)? {
let object_gen = object_map_identity(&handle);
if !object_selected(&wanted_objects, object_gen, false) {
continue;
}
let key = format!("{} {} R", object_gen.get_obj(), object_gen.get_gen());
Json::write_dictionary_key(out, &mut object_first, key.as_bytes(), 2)?;
handle.write_json(1, out, true, 2)?;
}
if trailer_selected(&wanted_objects, false) {
Json::write_dictionary_key(out, &mut object_first, b"trailer", 2)?;
pdf.trailer().write_json(1, out, true, 2)?; } Json::write_dictionary_close(out, object_first, 1)?;
Ok(())
}
pub(crate) fn write_json_v1_objectinfo_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut dyn Pipeline,
first: &mut bool,
wanted_objects: &[String],
) -> Result<(), JsonOutputError> {
Json::write_dictionary_key(out, first, b"objectinfo", 1)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 1)?;
let wanted_objects = parse_object_selectors(wanted_objects)?;
for handle in pdf.get_all_objects().map_err(ConvertError::from)? {
let object_gen = object_map_identity(&handle);
if !object_selected(&wanted_objects, object_gen, false) {
continue;
}
let resolved = handle.clone();
resolved.try_dereference().map_err(ConvertError::from)?;
let (is_stream, filter, length) = if let Some(stream_dict) = resolved.as_stream_dict() {
if stream_dict
.try_is_dictionary()
.map_err(ConvertError::from)?
{
let filter = stream_dict
.try_get_key(b"/Filter")
.map_err(ConvertError::from)?;
let length = stream_dict
.try_get_key(b"/Length")
.map_err(ConvertError::from)?;
(true, filter, length)
} else {
(false, ObjectHandle::null(), ObjectHandle::null()) }
} else {
(false, ObjectHandle::null(), ObjectHandle::null())
};
let key = format!("{} {} R", object_gen.get_obj(), object_gen.get_gen());
Json::write_dictionary_key(out, &mut object_first, key.as_bytes(), 2)?;
let mut details_first = true;
Json::write_dictionary_open(out, &mut details_first, 2)?;
Json::write_dictionary_key(out, &mut details_first, b"stream", 3)?;
let mut stream_first = true;
Json::write_dictionary_open(out, &mut stream_first, 3)?;
Json::write_dictionary_key(out, &mut stream_first, b"filter", 4)?;
filter.write_json(1, out, true, 4)?;
Json::write_dictionary_item(
out,
&mut stream_first,
b"is",
&Json::make_bool(is_stream),
4,
)?; Json::write_dictionary_key(out, &mut stream_first, b"length", 4)?;
length.write_json(1, out, true, 4)?;
Json::write_dictionary_close(out, stream_first, 3)?;
Json::write_dictionary_close(out, details_first, 2)?;
}
Json::write_dictionary_close(out, object_first, 1)?;
Ok(())
}
pub(crate) fn format_json_side_file_path(prefix: &[u8], object_gen: QpdfObjGen) -> Vec<u8> {
let mut path = prefix.to_vec();
path.push(b'-');
path.extend_from_slice(object_gen.get_obj().to_string().as_bytes());
path
}
fn object_map_identity(handle: &ObjectHandle) -> QpdfObjGen {
handle
.qpdf_obj_gen()
.expect("qpdf object-map entries are indirect handles")
}
pub fn write_json<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: i32,
out: &mut dyn Pipeline,
decode_level: DecodeLevel,
stream_mode: &StreamDataMode,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
let mut first_key = true;
write_json_key(
pdf,
version,
out,
true,
&mut first_key,
decode_level,
stream_mode,
wanted_objects,
)
}
#[allow(clippy::too_many_arguments)]
pub fn write_json_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: i32,
out: &mut dyn Pipeline,
complete: bool,
first_key: &mut bool,
decode_level: DecodeLevel,
stream_mode: &StreamDataMode,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
if version != SUPPORTED_JSON_VERSION {
return Err(JsonOutputError::UnsupportedVersion);
}
if complete {
Json::write_dictionary_open(out, first_key, 0)?;
}
Json::write_dictionary_key(out, first_key, b"qpdf", 1)?;
let mut qpdf_first = true;
Json::write_array_open(out, &mut qpdf_first, 1)?;
Json::write_next(out, &mut qpdf_first, 2)?;
let mut metadata_first = true;
Json::write_dictionary_open(out, &mut metadata_first, 2)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"jsonversion",
&Json::make_int(i64::from(version)),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"pdfversion",
&Json::make_string(pdf.version()),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"pushedinheritedpageresources",
&Json::make_bool(pdf.ever_pushed_inherited_attributes_to_pages()),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"calledgetallpages",
&Json::make_bool(pdf.ever_called_get_all_pages()),
3,
)?;
Json::write_dictionary_key(out, &mut metadata_first, b"maxobjectid", 3)?;
let max_object_id = pdf.get_object_count().map_err(ConvertError::from)?;
Json::make_int(i64::from(max_object_id)).write(out, 3)?;
Json::write_dictionary_close(out, metadata_first, 2)?;
Json::write_next(out, &mut qpdf_first, 2)?;
let mut objects_first = true;
Json::write_dictionary_open(out, &mut objects_first, 2)?;
let objects = pdf.get_all_objects().map_err(ConvertError::from)?;
for handle in objects {
let object_gen = object_map_identity(&handle);
if !object_selected(wanted_objects, object_gen, true) {
continue;
}
let result = match stream_mode {
StreamDataMode::None => write_non_file_mode_object_entry(
&handle,
decode_level,
QpdfStreamJsonData::None,
out,
&mut objects_first,
),
StreamDataMode::Inline => write_non_file_mode_object_entry(
&handle,
decode_level,
QpdfStreamJsonData::Inline,
out,
&mut objects_first,
),
StreamDataMode::File { prefix } => {
write_file_mode_object_entry(&handle, decode_level, prefix, out, &mut objects_first)
}
};
result?;
}
if trailer_selected(wanted_objects, true) {
let trailer = pdf.trailer();
Json::write_dictionary_key(out, &mut objects_first, b"trailer", 3)?;
let mut trailer_first = true;
Json::write_dictionary_open(out, &mut trailer_first, 3)?;
Json::write_dictionary_key(out, &mut trailer_first, b"value", 4)?;
trailer.write_json(SUPPORTED_JSON_VERSION, out, true, 4)?;
Json::write_dictionary_close(out, trailer_first, 3)?;
}
Json::write_dictionary_close(out, false, 2)?;
Json::write_array_close(out, qpdf_first, 1)?;
if complete {
Json::write_dictionary_close(out, false, 0)?;
out.write(b"\n")?;
out.finish()?;
}
Ok(())
}
fn object_selected(
selectors: &[JsonObjectSelector],
object_gen: QpdfObjGen,
zero_object_is_all: bool,
) -> bool {
selectors.is_empty()
|| selectors.iter().any(|selector| {
matches!(
selector,
JsonObjectSelector::Object { number, generation }
if zero_object_is_all && *number == 0
|| i64::from(*number) == i64::from(object_gen.get_obj())
&& i64::from(*generation) == i64::from(object_gen.get_gen())
)
})
}
fn trailer_selected(selectors: &[JsonObjectSelector], zero_object_is_all: bool) -> bool {
selectors.is_empty()
|| selectors.iter().any(|selector| {
matches!(selector, JsonObjectSelector::Trailer)
|| (zero_object_is_all
&& matches!(selector, JsonObjectSelector::Object { number: 0, .. }))
})
}
fn stream_decode_level(level: DecodeLevel) -> crate::writer::DecodeLevel {
match level {
DecodeLevel::None => crate::writer::DecodeLevel::None,
DecodeLevel::Generalized => crate::writer::DecodeLevel::Generalized,
DecodeLevel::Specialized => crate::writer::DecodeLevel::Specialized,
DecodeLevel::All => crate::writer::DecodeLevel::All,
}
}
fn write_non_file_mode_object_entry(
handle: &ObjectHandle,
decode_level: DecodeLevel,
stream_mode: QpdfStreamJsonData,
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
let object_gen = object_map_identity(handle);
let handle = handle.clone();
handle.try_dereference().map_err(ConvertError::from)?;
if handle.type_code().map_err(ConvertError::from)? == 10 {
let mut stream_value = Buffer::new("stream JSON", None);
handle.write_stream_json(
SUPPORTED_JSON_VERSION,
&mut stream_value,
stream_mode,
stream_decode_level(decode_level),
None,
"",
false,
4,
)?;
stream_value.finish()?;
let stream_value = stream_value.take_buffer()?;
Json::write_qpdf_object_key(out, objects_first, object_gen, 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"stream", 4)?;
out.write(&stream_value)?;
Json::write_dictionary_close(out, object_first, 3)?;
return Ok(());
}
write_non_stream_value_entry(&handle, object_gen, out, objects_first)?;
Ok(())
}
fn write_file_mode_object_entry(
handle: &ObjectHandle,
decode_level: DecodeLevel,
prefix: &[u8],
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
let object_gen = object_map_identity(handle);
let handle = handle.clone();
handle.try_dereference().map_err(ConvertError::from)?;
if handle.type_code().map_err(ConvertError::from)? == 10 {
Json::write_qpdf_object_key(out, objects_first, object_gen, 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"stream", 4)?;
let side_path = format_json_side_file_path(prefix, object_gen);
let side_path_fs = path_from_bytes(&side_path);
let mut side_file = File::create(&side_path_fs)
.map_err(|source| side_file_io_error("open", &side_path, source))?;
write_json_stream_file(&handle, decode_level, &side_path, &mut side_file, out)?;
Json::write_dictionary_close(out, object_first, 3)?;
return Ok(());
}
write_non_stream_value_entry(&handle, object_gen, out, objects_first)?;
Ok(())
}
fn write_non_stream_value_entry(
handle: &ObjectHandle,
object_gen: QpdfObjGen,
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
Json::write_qpdf_object_key(out, objects_first, object_gen, 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"value", 4)?;
handle.write_json(SUPPORTED_JSON_VERSION, out, true, 4)?;
Json::write_dictionary_close(out, object_first, 3)?;
Ok(())
}
pub(crate) fn write_json_stream_file(
handle: &ObjectHandle,
decode_level: DecodeLevel,
side_path: &[u8],
side_file: &mut dyn Write,
out: &mut dyn Pipeline,
) -> Result<(), JsonOutputError> {
let mut buffered = StdioBuffer::new(side_file);
let mut terminal = PlStdioFile::new("stream data", &mut buffered);
handle.write_stream_json(
SUPPORTED_JSON_VERSION,
out,
QpdfStreamJsonData::File,
stream_decode_level(decode_level),
Some(&mut terminal),
side_path,
false,
4,
)?;
terminal.finish()?;
Ok(())
}
fn path_from_bytes(bytes: &[u8]) -> PathBuf {
#[cfg(unix)]
{
use std::ffi::OsString;
use std::os::unix::ffi::OsStringExt;
PathBuf::from(OsString::from_vec(bytes.to_vec()))
}
#[cfg(not(unix))]
{
PathBuf::from(String::from_utf8_lossy(bytes).into_owned())
}
}