use super::embedded_file_stream::EmbeddedFileStream;
use super::shared::{ensure_indirect_handle_belongs_to_pdf, format_pdf_date, NAME_KEYS};
use crate::object_handle::canonical_dictionary_key;
use crate::pdf_string::{new_unicode_string, utf8_value};
use crate::{Error, ObjectHandle, ObjectRef, Pdf, Result};
use std::collections::BTreeMap;
use std::io::{Read, Seek};
use std::path::Path;
pub struct FileSpec<'a, R: Read + Seek + 'static> {
filespec: ObjectHandle,
pdf: &'a mut Pdf<R>,
}
impl<'a, R: Read + Seek> FileSpec<'a, R> {
pub fn create_file_spec(
pdf: &mut Pdf<R>,
filename: impl AsRef<[u8]>,
embedded_file: ObjectHandle,
) -> Result<ObjectHandle> {
let name = new_unicode_string(filename.as_ref());
let embedded_file = if embedded_file.object_ref().is_some() {
if !pdf.is_canonical_object_handle(&embedded_file) {
return Err(Error::Unsupported(
"embedded-file handle belongs to another Pdf".to_string(),
));
}
embedded_file
} else {
pdf.make_indirect_object_handle(embedded_file)?
};
let ef = ObjectHandle::dictionary(vec![
(b"/F".to_vec(), embedded_file.clone()),
(b"/UF".to_vec(), embedded_file),
]);
let filespec = ObjectHandle::dictionary(vec![
(b"/Type".to_vec(), ObjectHandle::name(b"Filespec".to_vec())),
(b"/UF".to_vec(), ObjectHandle::string(name.clone())),
(b"/F".to_vec(), ObjectHandle::string(name)),
(b"/EF".to_vec(), ef),
]);
pdf.make_indirect_object_handle(filespec)
}
pub fn create_file_spec_from_path<P: AsRef<Path>>(
pdf: &mut Pdf<R>,
filename: impl AsRef<[u8]>,
path: P,
) -> Result<ObjectHandle> {
let embedded_file = EmbeddedFileStream::create_ef_stream_from_path(pdf, path)?;
Self::create_file_spec(pdf, filename, embedded_file)
}
pub fn new(filespec: ObjectHandle, pdf: &'a mut Pdf<R>) -> Result<Self> {
ensure_indirect_handle_belongs_to_pdf(&filespec, pdf, "Filespec")?;
let resolved = pdf.resolve_handle(&filespec)?;
if resolved.try_as_dictionary()?.is_none() {
resolved.warn_if_possible("Embedded file object is not a dictionary")?;
} else if !resolved.try_is_dictionary_of_type(b"Filespec", b"")? {
resolved.warn_if_possible("Embedded file object's type is not /Filespec")?;
}
Ok(Self { filespec, pdf })
}
fn filespec_handle(&mut self) -> Result<ObjectHandle> {
let (filespec, terminal_ref) = self.pdf.resolve_handle_ref(&self.filespec)?;
Ok(match terminal_ref {
Some(object_ref) => {
let filespec = self.pdf.get_object_handle(object_ref);
self.pdf.resolve(&filespec)?;
filespec
}
None => filespec,
})
}
fn filespec_value(&mut self, key: &[u8]) -> Result<ObjectHandle> {
let filespec = self.filespec_handle()?;
if filespec.is_null() && filespec.context().is_none() {
return Ok(ObjectHandle::null());
}
filespec.try_get_key(key)
}
fn resolved_string_value_handle(&mut self, value: ObjectHandle) -> Result<Option<Vec<u8>>> {
let value = self.pdf.resolve_handle(&value)?;
Ok(value.as_string())
}
fn filespec_dict(&mut self) -> Result<Option<ObjectHandle>> {
let filespec = self.filespec_handle()?;
Ok(filespec.as_dictionary().map(|_| filespec))
}
pub fn set_description(&mut self, description: impl AsRef<[u8]>) -> Result<&mut Self> {
let Some(dict) = self.filespec_dict()? else {
return Ok(self);
};
self.pdf.mark_object_handle_dirty(&dict)?;
dict.replace_key(
b"/Desc",
ObjectHandle::string(new_unicode_string(description.as_ref())),
)?; Ok(self)
}
pub fn set_filename(
&mut self,
unicode_name: impl AsRef<[u8]>,
compatibility_name: Option<&[u8]>,
) -> Result<&mut Self> {
let Some(dict) = self.filespec_dict()? else {
return Ok(self);
};
self.pdf.mark_object_handle_dirty(&dict)?;
let unicode_name = new_unicode_string(unicode_name.as_ref());
dict.replace_key(b"/UF", ObjectHandle::string(unicode_name.clone()))?;
let compatibility_name = compatibility_name
.map(ToOwned::to_owned)
.filter(|name| !name.is_empty());
dict.replace_key(
b"/F",
ObjectHandle::string(compatibility_name.unwrap_or(unicode_name)),
)?; Ok(self)
}
pub fn filename(&mut self) -> Result<Option<Vec<u8>>> {
let value = self.filespec_value(b"/F")?;
self.resolved_string_value_handle(value)
}
pub fn uf(&mut self) -> Result<Option<Vec<u8>>> {
let value = self.filespec_value(b"/UF")?;
self.resolved_string_value_handle(value)
}
pub fn description(&mut self) -> Result<Option<Vec<u8>>> {
let value = self.filespec_value(b"/Desc")?;
self.resolved_string_value_handle(value)
}
pub fn af_relationship(&mut self) -> Result<Option<Vec<u8>>> {
let value = self.filespec_value(b"/AFRelationship")?;
Ok(self.pdf.resolve_handle(&value)?.as_name())
}
pub fn get_description(&mut self) -> Result<Vec<u8>> {
let value = self.filespec_value(b"/Desc")?;
Ok(self
.resolved_string_value_handle(value)?
.map(|value| utf8_value(&value))
.unwrap_or_default())
}
pub fn get_filename(&mut self) -> Result<Vec<u8>> {
for key in NAME_KEYS {
let key = canonical_dictionary_key(key.as_bytes());
let value = self.filespec_value(&key)?;
if let Some(value) = self.resolved_string_value_handle(value)? {
return Ok(utf8_value(&value));
}
}
Ok(Vec::new())
}
pub fn get_filenames(&mut self) -> Result<BTreeMap<String, Vec<u8>>> {
let mut filenames = BTreeMap::new();
for name_key in NAME_KEYS {
let key = canonical_dictionary_key(name_key.as_bytes());
let value = self.filespec_value(&key)?;
if let Some(value) = self.resolved_string_value_handle(value)? {
filenames.insert(format!("/{name_key}"), utf8_value(&value));
}
}
Ok(filenames)
}
pub fn get_embedded_file_stream(&mut self, key: &str) -> Result<ObjectHandle> {
let ef = self.get_embedded_file_streams()?;
let ef = self.pdf.resolve_handle(&ef)?;
let Some(entries) = ef.try_as_dictionary()? else {
return Ok(ObjectHandle::null());
};
if !key.is_empty() {
let key = canonical_dictionary_key(key.as_bytes());
return ef.try_get_key(&key);
}
for key in NAME_KEYS {
let key = canonical_dictionary_key(key.as_bytes());
let Some(candidate) = entries.get(&key).cloned() else {
continue;
};
let terminal = self.pdf.resolve_handle(&candidate)?;
if terminal.as_stream_dict().is_some() {
return Ok(candidate);
}
}
Ok(ObjectHandle::null())
}
pub fn get_embedded_file_streams(&mut self) -> Result<ObjectHandle> {
self.filespec_value(b"/EF")
}
pub(crate) fn get_embedded_file_stream_entries(
&mut self,
) -> Result<Vec<(Vec<u8>, ObjectHandle)>> {
let ef = self.get_embedded_file_streams()?;
if ef.is_null() && ef.context().is_none() {
return Ok(Vec::new());
}
let keys = ef.try_get_keys()?;
let _end_keys = ef.try_get_keys()?;
keys.into_iter()
.map(|key| Ok((key.clone(), ef.try_get_key(&key)?)))
.collect()
}
pub fn embedded_file(&mut self) -> Result<Option<EmbeddedFileStream<'_, R>>> {
let candidate = self.get_embedded_file_stream("")?;
let (stream, terminal_ref) = self.pdf.resolve_handle_ref(&candidate)?;
let Some(stream) = stream.as_stream_dict().map(|_| stream) else {
return Ok(None);
};
let stream = terminal_ref
.map(|object_ref| self.pdf.get_object_handle(object_ref))
.unwrap_or(stream);
Ok(Some(EmbeddedFileStream::new(stream, self.pdf)?))
}
}
#[derive(Debug, Clone, Default)]
pub struct FileParamDates {
pub creation: Option<(u16, u8, u8, u8, u8, u8)>,
pub modification: Option<(u16, u8, u8, u8, u8, u8)>,
}
pub struct FileSpecBuilder {
filename: Vec<u8>,
uf_filename: Option<String>,
payload: Vec<u8>,
mimetype: Option<Vec<u8>>,
description: Option<Vec<u8>>,
af_relationship: Option<Vec<u8>>,
dates: FileParamDates,
}
impl FileSpecBuilder {
pub fn new(filename: impl AsRef<[u8]>, payload: impl Into<Vec<u8>>) -> Self {
Self {
filename: filename.as_ref().to_vec(),
uf_filename: None,
payload: payload.into(),
mimetype: None,
description: None,
af_relationship: None,
dates: FileParamDates::default(),
}
}
pub fn uf_filename(mut self, filename: impl AsRef<str>) -> Self {
self.uf_filename = Some(filename.as_ref().to_string());
self
}
pub fn mimetype(mut self, mime: impl AsRef<[u8]>) -> Self {
self.mimetype = Some(mime.as_ref().to_vec());
self
}
pub fn description(mut self, desc: impl AsRef<[u8]>) -> Self {
self.description = Some(desc.as_ref().to_vec());
self
}
pub fn af_relationship(mut self, rel: impl AsRef<[u8]>) -> Self {
self.af_relationship = Some(rel.as_ref().to_vec());
self
}
pub fn dates(mut self, dates: FileParamDates) -> Self {
self.dates = dates;
self
}
pub fn build<R: Read + Seek>(self, pdf: &mut Pdf<R>) -> Result<ObjectRef> {
let uf_filename = match self.uf_filename {
Some(filename) => filename,
None => std::str::from_utf8(&self.filename)
.map_err(|_| {
Error::Unsupported(
"FileSpecBuilder: filename is not valid UTF-8; cannot encode /UF"
.to_string(),
)
})?
.to_string(),
};
let stream_handle = EmbeddedFileStream::create_ef_stream(pdf, &self.payload)?;
let filespec_handle = FileSpec::create_file_spec(pdf, &uf_filename, stream_handle)?;
let filespec_ref = filespec_handle
.object_ref()
.expect("create_file_spec must create an indirect Filespec");
{
let mut filespec = FileSpec::new(pdf.get_object_handle(filespec_ref), pdf)?;
filespec.set_filename(&uf_filename, Some(self.filename.as_slice()))?;
if let Some(description) = self.description {
filespec.set_description(description)?;
}
let mut embedded_file = filespec
.embedded_file()?
.expect("FileSpec::create must create an /EmbeddedFile stream");
if let Some(mimetype) = self.mimetype {
embedded_file.set_subtype(mimetype)?;
}
if let Some((y, mo, d, h, mi, s)) = self.dates.creation {
embedded_file.set_creation_date(format_pdf_date(y, mo, d, h, mi, s))?;
}
if let Some((y, mo, d, h, mi, s)) = self.dates.modification {
embedded_file.set_mod_date(format_pdf_date(y, mo, d, h, mi, s))?;
}
}
if let Some(relationship) = self.af_relationship {
pdf.mark_object_handle_dirty(&filespec_handle)?;
filespec_handle.replace_key(b"/AFRelationship", ObjectHandle::name(relationship))?;
}
Ok(filespec_ref)
}
}