#![forbid(unsafe_code)]
mod arg_parser;
use clap::{
ArgGroup, Args as ClapArgs, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum,
};
use flpdf::fix_qdf;
use flpdf::job::{
copy_duplicate_page_annotations, AttachmentAddOptions, CheckError, FlattenAnnotationsMode,
ImageOptimizationOptions, JobExitCode, JsonJobError, JsonJobOptions, JsonJobOutput,
JsonStreamData, PageSpecInput, PageSpecJobOutput, QPDFJob, RemoveUnreferencedResources,
SplitPageOptions,
};
use flpdf::pipeline::{FlateAction, Pipeline, PipelineHandle, PlFlate, PlStdioFile};
use flpdf::qutil::same_file as qpdf_same_file;
use flpdf::writer::DecodeLevel as StreamDecodeLevel;
use flpdf::{
json_inspect::{DecodeLevel, JsonKey, JsonObjectSelector},
normalize_content_stream, pages, parse_pdf_version, CompressStreams, CopyEncryptionSource,
EncryptMethod, EncryptParams, Error, NewlineBeforeEndstream, ObjectHandle, ObjectKeyAlg,
ObjectRef, ObjectStreamMode, PasswordMode, PasswordWriteNotice, Pdf, PdfOpenOptions,
PdfVersion, PdfWriter, PermissionsConfig, PrintPermission, QPDFLogger, R2PermissionsConfig,
StreamDataMode, UsageError, WriterConfiguration,
};
use flpdf::{
pages::tree_rebuild::{rebuild_page_tree, RebuildResult},
qutil::parse_numrange,
PageRange,
};
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
use std::fs::{File, OpenOptions};
use std::io::{BufReader, Cursor, Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
type CliResult<T> = Result<T, Box<dyn std::error::Error>>;
struct CliInputSpec {
path: PathBuf,
password: Option<Vec<u8>>,
range: PageRange,
}
impl CliInputSpec {
fn new(path: impl Into<PathBuf>, password: Option<Vec<u8>>, range: PageRange) -> Self {
Self {
path: path.into(),
password,
range,
}
}
}
struct PipelineWriter {
pipeline: PipelineHandle,
}
impl Write for PipelineWriter {
fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
self.pipeline.write(data).map_err(std::io::Error::other)?;
Ok(data.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl PipelineWriter {
fn finish_pipeline(&mut self) -> CliResult<()> {
self.pipeline
.finish()
.map_err(|error| Box::new(error) as Box<dyn std::error::Error>)
}
}
#[derive(Debug, Clone)]
struct WriterOptions {
object_streams: ObjectStreamMode,
compress_streams: Option<CompressStreams>,
content_normalization: bool,
content_normalization_set: bool,
qdf: bool,
preserve_unreferenced_objects: bool,
newline_before_endstream: NewlineBeforeEndstream,
stream_data: Option<StreamDataMode>,
decode_level: StreamDecodeLevel,
decode_level_set: bool,
recompress_flate: bool,
compression_level: Option<i32>,
progress: bool,
verbose: bool,
static_id: bool,
deterministic_id: bool,
static_aes_iv: bool,
no_original_object_ids: bool,
input_version_floor: Option<PdfVersion>,
min_version: Option<String>,
min_extension_level: Option<i64>,
force_version: Option<String>,
force_extension_level: Option<i64>,
encrypt: Option<EncryptParams>,
copy_encryption: Option<CopyEncryptionSource>,
preserve_encryption: bool,
password_mode: PasswordMode,
allow_weak_crypto: bool,
}
#[derive(Debug, Clone, Default)]
struct PageLabelOptions {
set: Option<Vec<Vec<u8>>>,
remove: bool,
}
#[derive(Debug, Clone, Copy, Default)]
struct ImageTransformOptions {
externalize_inline_images: bool,
optimize_images: bool,
image_options: ImageOptimizationOptions,
}
impl ImageTransformOptions {
fn new(
externalize_inline_images: bool,
optimize_images: bool,
image_options: ImageOptimizationOptions,
) -> Self {
Self {
externalize_inline_images,
optimize_images,
image_options,
}
}
}
#[derive(Debug, Clone, Copy)]
struct InspectionTransformOptions {
image: ImageTransformOptions,
generate_appearances: bool,
flatten_annotations: Option<CliFlattenMode>,
flatten_rotation: bool,
}
impl InspectionTransformOptions {
fn new(
image: ImageTransformOptions,
generate_appearances: bool,
flatten_annotations: Option<CliFlattenMode>,
) -> Self {
Self {
image,
generate_appearances,
flatten_annotations,
flatten_rotation: false,
}
}
fn is_empty(self) -> bool {
!self.generate_appearances
&& self.flatten_annotations.is_none()
&& !self.flatten_rotation
&& !self.image.externalize_inline_images
&& !self.image.optimize_images
}
}
fn page_label_options(set: Option<&[OsString]>, remove: bool) -> PageLabelOptions {
PageLabelOptions {
set: set.map(|specs| {
specs
.iter()
.map(|spec| arg_parser::os_bytes(spec.as_os_str()))
.collect()
}),
remove,
}
}
impl Default for WriterOptions {
fn default() -> Self {
Self {
object_streams: ObjectStreamMode::Preserve,
compress_streams: None,
content_normalization: false,
content_normalization_set: false,
qdf: false,
preserve_unreferenced_objects: false,
newline_before_endstream: NewlineBeforeEndstream::Never,
stream_data: None,
decode_level: StreamDecodeLevel::None,
decode_level_set: false,
recompress_flate: false,
compression_level: None,
progress: false,
verbose: false,
static_id: false,
deterministic_id: false,
static_aes_iv: false,
no_original_object_ids: false,
input_version_floor: None,
min_version: None,
min_extension_level: None,
force_version: None,
force_extension_level: None,
encrypt: None,
copy_encryption: None,
preserve_encryption: true,
password_mode: PasswordMode::default(),
allow_weak_crypto: false,
}
}
}
#[derive(Debug, Clone, Default)]
struct CliVersionOptions {
min: Option<(String, i64)>,
force: Option<(String, i64)>,
}
fn parse_cli_version_options(
min: Option<&str>,
force: Option<&str>,
) -> CliResult<CliVersionOptions> {
let parse = |name: &str, value: Option<&str>| -> CliResult<Option<(String, i64)>> {
value
.map(|value| {
flpdf::parse_pdf_version_spec(value)
.ok_or_else(|| format!("invalid {name} value: {value:?}").into())
})
.transpose()
};
Ok(CliVersionOptions {
min: parse("--min-version", min)?,
force: parse("--force-version", force)?,
})
}
fn apply_cli_version_options(options: &mut WriterOptions, versions: &CliVersionOptions) {
if let Some((version, extension_level)) = &versions.min {
options.min_version = Some(version.clone());
options.min_extension_level = Some(*extension_level);
}
if let Some((version, extension_level)) = &versions.force {
options.force_version = Some(version.clone());
options.force_extension_level = Some(*extension_level);
}
}
fn update_input_version_floor<R: Read + Seek>(
floor: &mut Option<PdfVersion>,
pdf: &mut Pdf<R>,
) -> CliResult<()> {
if let Some(source_version) = parse_pdf_version(pdf.version()) {
let candidate = PdfVersion::new(
source_version.major(),
source_version.minor(),
pdf.adobe_extension_level()?.unwrap_or(0),
);
if floor.is_none_or(|current| current < candidate) {
*floor = Some(candidate);
}
}
Ok(())
}
fn apply_cli_decode_level(options: &mut WriterOptions, decode_level: Option<CliDecodeLevel>) {
if let Some(level) = decode_level {
options.decode_level = level.into();
options.decode_level_set = true;
}
}
fn top_level_writer_options(
args: &Cli,
normalize_content: bool,
compression_level: Option<i32>,
version_options: &CliVersionOptions,
) -> WriterOptions {
let mut options = WriterOptions {
static_id: args.static_id,
deterministic_id: args.deterministic_id,
static_aes_iv: args.static_aes_iv,
no_original_object_ids: args.no_original_object_ids,
preserve_unreferenced_objects: args.preserve_unreferenced,
progress: args.progress,
verbose: args.verbose,
recompress_flate: args.recompress_flate,
compression_level,
object_streams: args.object_streams.into(),
stream_data: args.stream_data.map(Into::into),
content_normalization: normalize_content,
content_normalization_set: args.normalize_content.is_some(),
qdf: args.qdf,
newline_before_endstream: args.newline_before_endstream.into(),
password_mode: args.password.password_mode.into(),
allow_weak_crypto: args.password.allow_weak_crypto,
..WriterOptions::default()
};
apply_cli_decode_level(&mut options, args.decode_level);
apply_cli_version_options(&mut options, version_options);
if let Some(ref cs) = args.compress_streams {
match cs.as_str() {
"y" => options.compress_streams = Some(CompressStreams::Yes),
"n" => options.compress_streams = Some(CompressStreams::No),
other => {
emit_logger_error(format!(
"flpdf: --compress-streams must be y or n, got: {:?}\n",
other
));
std::process::exit(2);
}
}
}
apply_encryption_options(
&mut options,
EncryptionCliOptions {
encrypt: args.raw_encrypt.as_deref(),
encrypt_segments: args.raw_encrypt_segments.as_deref(),
parsed_encrypt_segments: args.parsed_encrypt_segments.as_deref(),
copy_encryption: args.copy_encryption.as_deref(),
encryption_file_password: args.raw_encryption_file_password.as_deref(),
password_args: &args.password,
suppress_warnings: args.no_warn,
last_mode: args.last_encryption_mode,
},
);
if args.decrypt {
options.preserve_encryption = false;
}
options
}
fn parse_compression_level(value: Option<&str>) -> CliResult<Option<i32>> {
value.map(qpdf_selector_integer).transpose()
}
fn parse_image_uint(value: Option<&str>) -> CliResult<Option<u32>> {
let Some(value) = value else {
return Ok(None);
};
if value.is_empty() {
return Ok(Some(0));
}
let parsed = QPDFJob::parse_collate(value)?
.into_iter()
.next()
.unwrap_or(0);
Ok(Some(parsed as u32))
}
fn image_optimization_options(
keep_inline_images: bool,
oi_min_width: Option<&str>,
oi_min_height: Option<&str>,
oi_min_area: Option<&str>,
ii_min_bytes: Option<&str>,
) -> CliResult<ImageOptimizationOptions> {
let mut options = ImageOptimizationOptions::default();
if let Some(value) = parse_image_uint(oi_min_width)? {
options.min_width = value;
}
if let Some(value) = parse_image_uint(oi_min_height)? {
options.min_height = value;
}
if let Some(value) = parse_image_uint(oi_min_area)? {
options.min_area = value;
}
if let Some(value) = parse_image_uint(ii_min_bytes)? {
options.inline_min_bytes = value as usize;
}
options.keep_inline_images = keep_inline_images;
Ok(options)
}
fn apply_inspection_transformations<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
apply_top_level_inspection_transformations(job, pdf, options, verbose, false, false)
}
fn apply_transformations_for_cli<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
) -> CliResult<()> {
match job.apply_transformations(pdf) {
Ok(()) => Ok(()),
Err(error) if is_bad_password_error(&error) => {
job.report_job_error(&error)?;
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
Err(error) => Err(Box::new(error)),
}
}
fn apply_top_level_inspection_transformations<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
options: InspectionTransformOptions,
verbose: bool,
remove_restrictions: bool,
coalesce_contents: bool,
) -> CliResult<()> {
configure_top_level_inspection_transformations(
job,
options,
verbose,
remove_restrictions,
coalesce_contents,
);
apply_transformations_for_cli(job, pdf)?;
Ok(())
}
fn configure_top_level_inspection_transformations(
job: &mut QPDFJob,
options: InspectionTransformOptions,
verbose: bool,
remove_restrictions: bool,
coalesce_contents: bool,
) {
if options.is_empty() && !remove_restrictions && !coalesce_contents {
return;
}
job.set_verbose(verbose);
{
let mut configuration = job.config();
if remove_restrictions {
configuration.remove_restrictions();
}
if coalesce_contents {
configuration.coalesce_contents();
}
if options.generate_appearances {
configuration.generate_appearances();
}
if let Some(mode) = options.flatten_annotations {
configuration.flatten_annotations(mode.into());
}
if options.flatten_rotation {
configuration.flatten_rotation();
}
if options.image.externalize_inline_images {
configuration.externalize_inline_images(options.image.image_options.inline_min_bytes);
}
if options.image.optimize_images {
configuration.optimize_images(options.image.image_options);
}
}
}
fn writer_configuration(
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<WriterConfiguration> {
let mut configuration = writer_configuration_unnormalized(options, linearize, linearize_pass1)?;
normalize_and_check_writer_configuration(&mut configuration, options)?;
Ok(configuration)
}
fn writer_configuration_unnormalized(
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<WriterConfiguration> {
let mut configuration = WriterConfiguration::default();
configuration.set_object_stream_mode(options.object_streams);
if let Some(mode) = options.stream_data {
configuration.set_stream_data_mode(mode);
}
if let Some(mode) = options.compress_streams {
configuration.set_compress_streams(matches!(mode, CompressStreams::Yes));
}
if options.decode_level_set {
configuration.set_decode_level(options.decode_level);
}
configuration.set_recompress_flate(options.recompress_flate);
if let Some(level) = options.compression_level {
configuration.set_compression_level(level);
}
configuration.set_qdf_mode(options.qdf && !linearize);
configuration.set_linearization(linearize);
if let Some(path) = linearize_pass1 {
configuration.set_linearization_pass1_filename(path.to_path_buf());
}
if options.content_normalization_set {
configuration.set_content_normalization(options.content_normalization);
}
configuration.set_preserve_unreferenced_objects(options.preserve_unreferenced_objects);
configuration.set_newline_before_endstream(matches!(
options.newline_before_endstream,
NewlineBeforeEndstream::Yes
));
configuration.set_static_id(options.static_id);
configuration.set_deterministic_id(options.deterministic_id);
configuration.set_static_aes_iv(options.static_aes_iv);
configuration.set_suppress_original_object_ids(options.no_original_object_ids);
configuration.set_preserve_encryption(options.preserve_encryption);
if let Some(version) = options.input_version_floor {
let (version, extension_level) = version.get_version();
configuration.set_minimum_pdf_version(version, extension_level);
}
if let Some(version) = options.min_version.as_deref() {
configuration.set_minimum_pdf_version(version, options.min_extension_level.unwrap_or(0));
}
if let Some(version) = options.force_version.as_deref() {
configuration.force_pdf_version(version, options.force_extension_level.unwrap_or(0));
}
if let Some(params) = options.encrypt.clone() {
configuration.set_encryption_parameters(params);
}
if let Some(source) = options.copy_encryption.clone() {
configuration.copy_encryption_parameters(source);
}
Ok(configuration)
}
fn normalize_and_check_writer_configuration(
configuration: &mut WriterConfiguration,
options: &WriterOptions,
) -> CliResult<()> {
let notices = configuration.normalize_encryption_passwords(options.password_mode)?;
let prefix = progname();
emit_password_write_notices(&cli_logger(), &prefix, notices, options.verbose)?;
if !options.allow_weak_crypto
&& options
.encrypt
.as_ref()
.is_some_and(EncryptParams::is_weak_rc4)
{
emit_logger_error(format!(
"{}: refusing to write a file with RC4, a weak cryptographic algorithm\n\
Please use 256-bit keys for better security.\n\
Pass --allow-weak-crypto to enable writing insecure files.\n\
See also https://qpdf.readthedocs.io/en/stable/weak-crypto.html\n",
progname()
));
return Err("refusing to write a file with weak crypto".into());
}
Ok(())
}
fn emit_password_write_notices(
logger: &QPDFLogger,
prefix: &str,
notices: impl IntoIterator<Item = PasswordWriteNotice>,
verbose: bool,
) -> CliResult<()> {
for notice in notices {
match notice {
PasswordWriteNotice::Info if verbose => {
logger.info(format!(
"{prefix}: automatically converting Unicode password to single-byte encoding as required for 40-bit or 128-bit encryption\n"
))?;
}
PasswordWriteNotice::Warning => {
logger.error(format!(
"{prefix}: WARNING: supplied password looks like a Unicode password with characters not allowed in passwords for 40-bit and 128-bit encryption; most readers will not be able to open this file with the supplied password. (Use --password-mode=bytes to suppress this warning and use the password anyway.)\n"
))?;
}
PasswordWriteNotice::None | PasswordWriteNotice::Info => {}
}
}
Ok(())
}
fn configure_pdf_writer<R: Read + Seek + 'static>(
writer: &mut PdfWriter<'_, R>,
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<()> {
writer_configuration(options, linearize, linearize_pass1)?.apply_to(writer);
Ok(())
}
fn configure_cli_progress<R: Read + Seek + 'static>(
writer: &mut PdfWriter<'_, R>,
output: &Path,
enabled: bool,
) -> CliResult<()> {
if !enabled {
return Ok(());
}
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_output_file(output.to_path_buf())?;
job.set_progress(true);
job.configure_writer_progress(writer);
Ok(())
}
fn write_with_pdf_writer<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
output: &Path,
standard_output: &mut Option<PipelineWriter>,
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<()> {
let mut writer = PdfWriter::new(pdf);
configure_pdf_writer(&mut writer, options, linearize, linearize_pass1)?;
configure_cli_progress(&mut writer, output, options.progress)?;
if let Some(sink) = standard_output.take() {
writer.set_output_writer(sink)?;
} else {
writer.set_output_file(output)?;
}
writer.write()?;
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExitCode {
Ok = 0,
Errors = 2,
Warnings = 3,
}
impl ExitCode {
pub fn as_i32(self) -> i32 {
self as i32
}
}
#[derive(Debug)]
pub struct CliExitError {
pub code: ExitCode,
pub message: String,
}
impl std::fmt::Display for CliExitError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.message)
}
}
impl std::error::Error for CliExitError {}
#[derive(Debug)]
struct CliPathError {
path: Vec<u8>,
operation: Option<&'static str>,
message: String,
source: Box<dyn std::error::Error>,
}
impl std::fmt::Display for CliPathError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(operation) = self.operation {
write!(formatter, "{operation} ")?;
}
write!(
formatter,
"{}: {}",
String::from_utf8_lossy(&self.path),
self.message
)
}
}
impl std::error::Error for CliPathError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(self.source.as_ref())
}
}
#[derive(Debug, Parser)]
#[command(name = "flpdf")]
#[command(about = "Pure Rust qpdf-style PDF tool")]
#[command(args_conflicts_with_subcommands = true)]
#[command(group(
ArgGroup::new("attachment_op")
.multiple(false)
.args([
"add_attachment",
"remove_attachment",
"copy_attachments_from",
])
))]
struct Cli {
#[command(subcommand)]
command: Option<Commands>,
#[arg(long, conflicts_with = "output", overrides_with = "check")]
check: bool,
#[arg(long)]
no_warn: bool,
#[arg(long = "warning-exit-0")]
warning_exit_zero: bool,
#[arg(
long = "check-linearization",
overrides_with = "check_linearization",
conflicts_with_all = [
"job_json_file",
"json",
"json_input",
"update_from_json",
"json_output",
"json_key",
"json_object",
"json_stream_data",
"json_stream_prefix",
"split_pages",
"overlay",
"underlay",
"copy_encryption",
"encryption_file_password",
]
)]
check_linearization: bool,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(
long,
require_equals = true,
conflicts_with = "output",
overrides_with = "show_object"
)]
show_object: Option<String>,
#[arg(long = "raw-stream-data", requires = "show_object")]
raw_stream_data: bool,
#[arg(long = "filtered-stream-data", requires = "show_object")]
filtered_stream_data: bool,
#[arg(long, conflicts_with = "output", overrides_with = "show_npages")]
show_npages: bool,
#[arg(long, conflicts_with = "output", overrides_with = "show_pages")]
show_pages: bool,
#[arg(long = "with-images")]
with_images: bool,
#[arg(long, conflicts_with = "output", overrides_with = "show_xref")]
show_xref: bool,
#[arg(long, conflicts_with = "output", overrides_with = "show_linearization")]
show_linearization: bool,
#[arg(
long = "show-encryption",
conflicts_with = "output",
overrides_with = "show_encryption"
)]
show_encryption: bool,
#[arg(
long = "is-encrypted",
conflicts_with_all = ["requires_password", "output"]
)]
is_encrypted: bool,
#[arg(
long = "requires-password",
conflicts_with_all = ["is_encrypted", "output"]
)]
requires_password: bool,
#[arg(long = "show-encryption-key")]
show_encryption_key: bool,
#[arg(
long = "job-json-file",
action = clap::ArgAction::Append,
value_name = "PATH",
require_equals = true
)]
job_json_file: Vec<PathBuf>,
#[arg(long, num_args = 0..=1, default_missing_value = "2",
require_equals = true,
value_name = "VERSION", value_parser = ["1", "2", "latest"],
conflicts_with_all = [
"check", "static_aes_iv",
"show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"is_encrypted", "requires_password",
"recompress_flate", "compression_level",
"linearize_pass1", "remove_restrictions",
"copy_encryption",
"list_attachments", "show_attachment",
"no_original_object_ids",
"preserve_unreferenced",
],
help = "Generate JSON v2 output (qpdf --json compatible)")]
json: Option<String>,
#[arg(
long = "json-input",
conflicts_with_all = [
"show_object",
"show_linearization", "list_attachments", "show_attachment",
"remove_attachment", "add_attachment", "copy_attachments_from",
],
help = "Treat INPUT as qpdf JSON v2 (qpdf --json-input)"
)]
json_input: bool,
#[arg(
long = "update-from-json",
value_name = "QPDF-JSON",
require_equals = true,
conflicts_with_all = [
"show_object",
"show_linearization", "list_attachments", "show_attachment",
"remove_attachment", "add_attachment", "copy_attachments_from",
],
help = "Apply a qpdf JSON update before processing (qpdf --update-from-json)"
)]
update_from_json: Option<PathBuf>,
#[arg(
long = "json-output",
num_args = 0..=1,
default_missing_value = "2",
require_equals = true,
value_name = "VERSION",
value_parser = ["1", "2", "latest"],
conflicts_with_all = [
"check", "static_aes_iv",
"show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"is_encrypted", "requires_password",
"recompress_flate", "compression_level",
"linearize_pass1", "remove_restrictions",
"copy_encryption",
"list_attachments", "show_attachment",
"no_original_object_ids",
"preserve_unreferenced",
],
help = "Generate qpdf JSON output; VERSION defaults to 2 and the output file is positional"
)]
json_output: Option<String>,
#[arg(long = "test-json-schema")]
test_json_schema: bool,
#[arg(
long = "json-key",
value_name = "KEY",
require_equals = true,
help = "This option is repeatable. If given, only the specified \
top-level keys will be included in the JSON output. \
Otherwise, all keys will be included."
)]
json_key: Vec<String>,
#[arg(
long = "json-object",
value_name = "SELECTOR",
require_equals = true,
help = "This option is repeatable. If given, only specified objects \
will be shown in the \"qpdf\" key of the JSON output. \
Otherwise, all objects will be shown. Format: trailer, N, \
or N,G."
)]
json_object: Vec<String>,
#[arg(
long = "json-stream-data",
value_name = "MODE",
require_equals = true,
overrides_with = "json_stream_data",
help = "When used with --json, this option controls whether streams \
in json output should be omitted, written inline \
(base64-encoded), or written to a file. If \"file\" is \
chosen, the file name is the --json-stream-prefix value \
appended with -nnn where nnn is the object number. The \
default is \"none\"."
)]
json_stream_data: Option<String>,
#[arg(
long = "json-stream-prefix",
value_name = "PREFIX",
require_equals = true,
help = "Prefix for side files with --json-stream-data=file. With --json-output, \
defaults to the JSON output path; with JSON on stdout, an explicit \
non-empty prefix is required. An empty prefix is treated as absent."
)]
json_stream_prefix: Option<OsString>,
#[arg(long)]
linearize: bool,
#[arg(long = "replace-input")]
replace_input: bool,
#[arg(long = "min-version", require_equals = true)]
min_version: Option<String>,
#[arg(long = "force-version", require_equals = true)]
force_version: Option<String>,
#[arg(long = "static-id")]
static_id: bool,
#[arg(long = "deterministic-id")]
deterministic_id: bool,
#[arg(long = "static-aes-iv", hide = true)]
static_aes_iv: bool,
#[arg(long = "remove-restrictions",
conflicts_with_all = [
"show_object",
"show_encryption",
])]
remove_restrictions: bool,
#[arg(long = "remove-page-labels")]
remove_page_labels: bool,
#[arg(
long = "set-page-labels",
num_args = 0..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "SPEC..."
)]
set_page_labels: Option<Vec<OsString>>,
#[arg(long = "decrypt",
conflicts_with_all = [
"show_object",
"show_xref", "show_linearization",
])]
decrypt: bool,
#[arg(
long = "compress-streams",
require_equals = true,
overrides_with = "compress_streams"
)]
compress_streams: Option<String>,
#[arg(long = "recompress-flate")]
recompress_flate: bool,
#[arg(
long = "compression-level",
value_name = "LEVEL",
require_equals = true
)]
compression_level: Option<String>,
#[arg(
long = "decode-level",
value_enum,
require_equals = true,
overrides_with = "decode_level"
)]
decode_level: Option<CliDecodeLevel>,
#[arg(
long = "object-streams",
value_enum,
require_equals = true,
default_value_t = CliObjectStreamMode::Preserve,
overrides_with = "object_streams"
)]
object_streams: CliObjectStreamMode,
#[arg(
long = "stream-data",
value_enum,
require_equals = true,
overrides_with = "stream_data"
)]
stream_data: Option<CliStreamDataMode>,
#[arg(long = "newline-before-endstream", value_enum, num_args = 0..=1,
require_equals = true, default_missing_value = "y",
default_value_t = CliNewlineBeforeEndstream::Never,
overrides_with = "newline_before_endstream")]
newline_before_endstream: CliNewlineBeforeEndstream,
#[arg(long = "linearize-pass1", require_equals = true)]
linearize_pass1: Option<PathBuf>,
#[arg(long = "no-original-object-ids")]
no_original_object_ids: bool,
#[arg(long = "qdf")]
qdf: bool,
#[arg(
long = "preserve-unreferenced",
help = "Preserve unreferenced input objects in writer output"
)]
preserve_unreferenced: bool,
#[arg(
long = "remove-unreferenced-resources",
value_enum,
require_equals = true,
default_value_t = CliRemoveUnreferencedResources::Auto,
help = "Remove unreferenced page resources (qpdf default: auto)",
overrides_with = "remove_unreferenced_resources"
)]
remove_unreferenced_resources: CliRemoveUnreferencedResources,
#[arg(
long = "normalize-content",
value_enum,
require_equals = true,
help = "Normalize page content streams (qpdf default: n; --qdf default: y)",
overrides_with = "normalize_content"
)]
normalize_content: Option<CliYesNo>,
#[arg(long = "coalesce-contents",
conflicts_with_all = [
"show_object",
"show_encryption",
"show_attachment", "remove_attachment",
"add_attachment", "copy_attachments_from",
])]
coalesce_contents: bool,
#[arg(
long = "flatten-annotations",
value_enum,
value_name = "MODE",
require_equals = true,
overrides_with = "flatten_annotations",
conflicts_with_all = [
"show_object",
"show_encryption",
],
help = "Flatten annotations into page content; MODE is all, screen, or print",
overrides_with = "flatten_annotations"
)]
flatten_annotations: Option<CliFlattenMode>,
#[arg(
long = "flatten-rotation",
help = "Flatten page rotation by baking /Rotate into content"
)]
flatten_rotation: bool,
#[arg(long = "generate-appearances")]
generate_appearances: bool,
#[arg(long = "optimize-images")]
optimize_images: bool,
#[arg(long = "externalize-inline-images")]
externalize_inline_images: bool,
#[arg(long = "keep-inline-images")]
keep_inline_images: bool,
#[arg(long = "oi-min-width", value_name = "WIDTH", require_equals = true)]
oi_min_width: Option<String>,
#[arg(long = "oi-min-height", value_name = "HEIGHT", require_equals = true)]
oi_min_height: Option<String>,
#[arg(long = "oi-min-area", value_name = "AREA", require_equals = true)]
oi_min_area: Option<String>,
#[arg(long = "ii-min-bytes", value_name = "BYTES", require_equals = true)]
ii_min_bytes: Option<String>,
#[command(flatten)]
page_ops: PageOpArgs,
#[arg(
long = "overlay",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "[--file=]FILE [sub-flags]",
help = "Overlay pages from FILE on top of the output (qpdf --overlay); \
repeatable, terminate each group with --"
)]
overlay: Vec<OsString>,
#[arg(
long = "underlay",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "[--file=]FILE [sub-flags]",
help = "Underlay pages from FILE beneath the output (qpdf --underlay); \
repeatable, terminate each group with --"
)]
underlay: Vec<OsString>,
#[arg(
long = "add-attachment",
num_args = 0..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "FILE [sub-flags]",
help = "Add a file attachment (qpdf --add-attachment compatible); \
terminate segment with --"
)]
add_attachment: Vec<OsString>,
#[arg(
long = "remove-attachment",
value_name = "KEY",
require_equals = true,
help = "Remove the embedded file with the given key (qpdf --remove-attachment)"
)]
remove_attachment: Vec<OsString>,
#[arg(
long = "list-attachments",
conflicts_with = "output",
overrides_with = "list_attachments",
help = "List all embedded-file attachments (qpdf --list-attachments)"
)]
list_attachments: bool,
#[arg(
long = "verbose",
help = "Print verbose progress and diagnostic messages \
(mirrors qpdf --verbose)"
)]
verbose: bool,
#[arg(long = "progress")]
progress: bool,
#[arg(
long = "show-attachment",
conflicts_with = "output",
value_name = "KEY",
require_equals = true,
overrides_with = "show_attachment",
help = "Extract the embedded file with the given key to stdout \
(qpdf --show-attachment)"
)]
show_attachment: Option<OsString>,
#[arg(
long = "copy-attachments-from",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "FILE [sub-flags]",
help = "Copy attachments from another PDF (qpdf --copy-attachments-from compatible); \
terminate segment with --"
)]
copy_attachments_from: Vec<OsString>,
#[arg(
long = "encrypt",
num_args = 0..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "USER-PW OWNER-PW KEY-LEN [sub-flags]",
// Reject combinations that don't make sense on the rewrite path.
// --check and --show-npages are inspection paths that qpdf accepts
// alongside writer encryption settings; when no output is created,
// those settings are simply not consumed. --linearize is NOT rejected:
// qpdf itself
// supports `--linearize --encrypt ...` (verified: `qpdf --linearize
// --encrypt "" "" 128 --use-aes=y --` produces a valid,
// `qpdf --check`-clean linearized+encrypted file), and
// `write_linearized` threads `options.encrypt` through correctly.
conflicts_with_all = [
"show_object",
"show_xref", "show_linearization",
"remove_restrictions",
],
help = "Encrypt output (qpdf --encrypt compatible): \
USER-PW OWNER-PW KEY-LEN [sub-flags] --"
)]
encrypt: Option<Vec<OsString>>,
#[arg(skip)]
raw_encrypt: Option<Vec<Vec<u8>>>,
#[arg(skip)]
raw_encrypt_segments: Option<Vec<Vec<Vec<u8>>>>,
#[arg(skip)]
parsed_encrypt_segments: Option<Vec<ParsedEncryptSegment>>,
#[arg(skip)]
last_encryption_mode: Option<EncryptionMode>,
#[arg(
long = "copy-encryption",
value_name = "FILE",
require_equals = true,
conflicts_with_all = [
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"remove_restrictions",
],
help = "Copy /Encrypt from donor PDF (qpdf --copy-encryption); \
pair with --encryption-file-password"
)]
copy_encryption: Option<PathBuf>,
#[arg(
long = "encryption-file-password",
value_name = "PW",
require_equals = true,
requires = "copy_encryption",
help = "User password to open the donor PDF for --copy-encryption"
)]
encryption_file_password: Option<OsString>,
#[arg(skip)]
raw_encryption_file_password: Option<Vec<u8>>,
#[arg(skip)]
raw_copy_attachments_from: Option<Vec<Vec<Vec<u8>>>>,
input: Option<PathBuf>,
output: Option<PathBuf>,
}
#[derive(Debug, Clone, Default, ClapArgs)]
struct PageOpArgs {
#[arg(
long = "keep-files-open",
value_enum,
require_equals = true,
overrides_with = "keep_files_open"
)]
keep_files_open: Option<CliYesNo>,
#[arg(
long = "keep-files-open-threshold",
value_name = "COUNT",
require_equals = true
)]
keep_files_open_threshold: Option<String>,
#[arg(
long = "pages",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "SPEC",
help = "Select pages from input files: --pages [--file=]f [--password=p] \
[range] [...] -- (qpdf-compatible). '.' = primary input; omitted \
range = all pages."
)]
pages: Vec<OsString>,
#[arg(skip)]
raw_pages: Option<Vec<Vec<u8>>>,
#[arg(skip)]
parsed_page_specs: Option<Vec<PageSegmentSpec>>,
#[arg(
long = "rotate",
action = clap::ArgAction::Append,
value_name = "[+|-]angle[:range]",
require_equals = true,
help = "Rotate pages by 0/90/180/270 degrees (qpdf --rotate); repeatable"
)]
rotate: Vec<OsString>,
#[arg(
long = "split-pages",
num_args = 0..=1,
default_missing_value = "1",
require_equals = true,
value_name = "N",
help = "Split output into N-page files (qpdf --split-pages[=n], default 1)"
)]
split_pages: Option<String>,
#[arg(
long = "collate",
num_args = 0..=1,
action = clap::ArgAction::Append,
default_missing_value = "1",
require_equals = true,
value_name = "N[,M,...]",
help = "Collate --pages selections in groups of N[,M,...] (qpdf --collate[=n[,m,...]], default 1)"
)]
collate: Vec<String>,
#[arg(
long = "empty",
help = "(qpdf --empty) use an empty document as the primary input"
)]
empty: bool,
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug, Subcommand)]
enum Commands {
#[command(about = "Validate PDF structure and report diagnostics")]
Check(CheckCommand),
#[command(
name = "check-linearization",
about = "Validate linearization structure (param dict, hint stream, offsets)"
)]
CheckLinearization(CheckLinearizationCommand),
#[command(about = "Show page structure summary or detail")]
Pages(PagesCommand),
#[command(about = "Create a PDF in QDF form (alias of `rewrite --qdf`)")]
Qdf(QdfCommand),
#[command(
name = "qdf-fix",
about = "Repair stream /Length, xref offsets, /Size and startxref in a hand-edited QDF file (qpdf fix-qdf equivalent)"
)]
QdfFix(QdfFixCommand),
#[command(
name = "zlib-flate",
about = "Compress or uncompress a raw zlib stream on stdin/stdout"
)]
ZlibFlate(ZlibFlateCommand),
#[command(about = "Rewrite the input PDF to a normalized output")]
Rewrite(RewriteCommand),
#[command(
name = "show-encryption",
about = "Show encryption parameters (qpdf --show-encryption compatible)",
long_about = "\
Print a parseable, greppable encryption report for FILE.
The qpdf `--show-encryption` lines are emitted verbatim (`R = `, `P = `,
the `extract/print/modify ...: allowed|not allowed` block, and the
`stream/string/file encryption method:` lines for V>=4) so scripts that
including `User password = ...` and V<5 owner-password recovery. If the
password is wrong, qpdf's `Incorrect password supplied` line is emitted
before the parsed encryption report. If FILE is not encrypted, prints qpdf's
`File is not encrypted` and exits 0."
)]
ShowEncryption(EncryptionInspectCommand),
#[command(
name = "is-encrypted",
about = "Exit 0 if FILE is encrypted, 2 if not (qpdf --is-encrypted)",
long_about = "\
Silently exit 0 if FILE is encrypted, 2 if it is not encrypted. Works for
password-protected files even without the password. Mirrors qpdf
`--is-encrypted` (qpdf_exit_is_not_encrypted=2)."
)]
IsEncrypted(IsEncryptedCommand),
#[command(
name = "requires-password",
about = "Exit 0/2/3 reporting whether a password is required (qpdf --requires-password)",
long_about = "\
Silently exit reporting FILE's password requirement (qpdf
--requires-password):
0 = encrypted and a password other than the one supplied is required
2 = not encrypted (qpdf_exit_is_not_encrypted)
3 = encrypted and the supplied/empty password opens it
(qpdf_exit_correct_password)"
)]
RequiresPassword(EncryptionInspectCommand),
#[command(
name = "show-encryption-key",
about = "Print the file encryption key as lowercase hex (qpdf --show-encryption-key)",
long_about = "\
Authenticate FILE with the supplied/empty password, then print the
derived file encryption key as lowercase hex. Mirrors qpdf
`--show-encryption-key`. Errors (exit 2) if FILE is not encrypted or the
password is incorrect."
)]
ShowEncryptionKey(EncryptionInspectCommand),
}
#[derive(Debug, ClapArgs)]
struct EncryptionInspectCommand {
input: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[derive(Debug, ClapArgs)]
struct IsEncryptedCommand {
input: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
recovery: RecoveryArgs,
}
#[derive(Debug, ClapArgs)]
struct CheckCommand {
input: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[derive(Debug, ClapArgs)]
struct CheckLinearizationCommand {
input: PathBuf,
}
#[derive(Debug, ClapArgs)]
struct PagesCommand {
input: PathBuf,
#[arg(long = "show-npages")]
show_npages: bool,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[derive(Debug, ClapArgs)]
struct QdfCommand {
input: PathBuf,
output: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(long = "preserve-unreferenced")]
preserve_unreferenced: bool,
}
#[derive(Debug, ClapArgs)]
struct QdfFixCommand {
input: PathBuf,
output: PathBuf,
}
#[derive(Debug, ClapArgs)]
struct ZlibFlateCommand {
#[arg(value_name = "MODE", allow_hyphen_values = true, num_args = 0..)]
modes: Vec<OsString>,
}
#[derive(Debug, ClapArgs)]
struct RewriteCommand {
input: PathBuf,
output: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(long)]
linearize: bool,
#[arg(long = "static-id")]
static_id: bool,
#[arg(long = "deterministic-id")]
deterministic_id: bool,
#[arg(long = "static-aes-iv", hide = true)]
static_aes_iv: bool,
#[arg(long = "remove-restrictions")]
remove_restrictions: bool,
#[arg(long = "remove-page-labels")]
remove_page_labels: bool,
#[arg(
long = "set-page-labels",
num_args = 0..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "SPEC..."
)]
set_page_labels: Option<Vec<OsString>>,
#[arg(long = "decrypt")]
decrypt: bool,
#[arg(
long = "encrypt",
num_args = 0..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "USER-PW OWNER-PW KEY-LEN [sub-flags]",
conflicts_with_all = [
"remove_restrictions", "decrypt",
"copy_encryption",
]
)]
encrypt: Option<Vec<OsString>>,
#[arg(skip)]
raw_encrypt: Option<Vec<Vec<u8>>>,
#[arg(skip)]
parsed_encrypt_segments: Option<Vec<ParsedEncryptSegment>>,
#[arg(
long = "copy-encryption",
value_name = "FILE",
require_equals = true,
conflicts_with_all = [
"encrypt",
"remove_restrictions", "decrypt",
],
help = "Copy /Encrypt from donor PDF (qpdf --copy-encryption); \
pair with --encryption-file-password"
)]
copy_encryption: Option<PathBuf>,
#[arg(
long = "encryption-file-password",
value_name = "PW",
require_equals = true,
requires = "copy_encryption",
help = "User password to open the donor PDF for --copy-encryption"
)]
encryption_file_password: Option<OsString>,
#[arg(skip)]
raw_encryption_file_password: Option<Vec<u8>>,
#[arg(skip)]
raw_copy_attachments_from: Option<Vec<Vec<Vec<u8>>>>,
#[arg(long = "min-version", require_equals = true)]
min_version: Option<String>,
#[arg(long = "force-version", require_equals = true)]
force_version: Option<String>,
#[arg(long = "no-original-object-ids")]
no_original_object_ids: bool,
#[arg(long = "qdf")]
qdf: bool,
#[arg(long = "preserve-unreferenced")]
preserve_unreferenced: bool,
#[arg(long = "object-streams", value_enum, require_equals = true, default_value_t = CliObjectStreamMode::Preserve, overrides_with = "object_streams")]
object_streams: CliObjectStreamMode,
#[arg(
long = "compress-streams",
value_enum,
require_equals = true,
help = "Compress output streams with FlateDecode (qpdf default: y)",
overrides_with = "compress_streams"
)]
compress_streams: Option<CliYesNo>,
#[arg(
long = "decode-level",
value_enum,
require_equals = true,
overrides_with = "decode_level"
)]
decode_level: Option<CliDecodeLevel>,
#[arg(
long = "normalize-content",
value_enum,
require_equals = true,
help = "Normalize page content streams (qpdf default: n)",
overrides_with = "normalize_content"
)]
normalize_content: Option<CliYesNo>,
#[arg(
long = "coalesce-contents",
help = "Merge per-page /Contents arrays into a single stream (qpdf default: off)"
)]
coalesce_contents: bool,
#[arg(long = "remove-unreferenced-resources", value_enum, require_equals = true,
default_value_t = CliRemoveUnreferencedResources::Auto,
help = "Remove unreferenced /Resources entries (qpdf default: auto)",
overrides_with = "remove_unreferenced_resources")]
remove_unreferenced_resources: CliRemoveUnreferencedResources,
#[arg(long = "newline-before-endstream", value_enum, num_args = 0..=1,
require_equals = true, default_missing_value = "y",
default_value_t = CliNewlineBeforeEndstream::Never,
help = "Insert newline before endstream keyword (qpdf default: never)",
overrides_with = "newline_before_endstream")]
newline_before_endstream: CliNewlineBeforeEndstream,
#[arg(
long = "stream-data",
value_enum,
require_equals = true,
overrides_with = "stream_data"
)]
stream_data: Option<CliStreamDataMode>,
#[arg(long = "recompress-flate")]
recompress_flate: bool,
#[arg(
long = "compression-level",
value_name = "LEVEL",
require_equals = true
)]
compression_level: Option<String>,
#[arg(
long = "flatten-annotations",
value_enum,
value_name = "MODE",
require_equals = true,
help = "Flatten annotations into page content; MODE is all, screen, or print",
overrides_with = "flatten_annotations"
)]
flatten_annotations: Option<CliFlattenMode>,
#[arg(
long = "generate-appearances",
help = "Generate appearance streams for form fields that lack them"
)]
generate_appearances: bool,
#[arg(long = "optimize-images")]
optimize_images: bool,
#[arg(long = "externalize-inline-images")]
externalize_inline_images: bool,
#[arg(long = "keep-inline-images")]
keep_inline_images: bool,
#[arg(long = "oi-min-width", value_name = "WIDTH", require_equals = true)]
oi_min_width: Option<String>,
#[arg(long = "oi-min-height", value_name = "HEIGHT", require_equals = true)]
oi_min_height: Option<String>,
#[arg(long = "oi-min-area", value_name = "AREA", require_equals = true)]
oi_min_area: Option<String>,
#[arg(long = "ii-min-bytes", value_name = "BYTES", require_equals = true)]
ii_min_bytes: Option<String>,
#[arg(
long = "flatten-rotation",
help = "Flatten page rotation by baking /Rotate into content"
)]
flatten_rotation: bool,
#[command(flatten)]
page_ops: PageOpArgs,
#[arg(
long = "overlay",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "[--file=]FILE [sub-flags]",
help = "Overlay pages from FILE on top of the output (qpdf --overlay); \
repeatable, terminate each group with --"
)]
overlay: Vec<OsString>,
#[arg(
long = "underlay",
num_args = 1..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "[--file=]FILE [sub-flags]",
help = "Underlay pages from FILE beneath the output (qpdf --underlay); \
repeatable, terminate each group with --"
)]
underlay: Vec<OsString>,
#[arg(
long = "verbose",
help = "Print verbose progress and diagnostic messages \
(mirrors qpdf --verbose)"
)]
verbose: bool,
#[arg(long = "progress")]
progress: bool,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, ValueEnum)]
enum CliObjectStreamMode {
#[default]
Preserve,
Disable,
Generate,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliDecodeLevel {
None,
Generalized,
Specialized,
All,
}
impl From<CliDecodeLevel> for StreamDecodeLevel {
fn from(value: CliDecodeLevel) -> Self {
match value {
CliDecodeLevel::None => Self::None,
CliDecodeLevel::Generalized => Self::Generalized,
CliDecodeLevel::Specialized => Self::Specialized,
CliDecodeLevel::All => Self::All,
}
}
}
impl From<CliDecodeLevel> for DecodeLevel {
fn from(value: CliDecodeLevel) -> Self {
match value {
CliDecodeLevel::None => Self::None,
CliDecodeLevel::Generalized => Self::Generalized,
CliDecodeLevel::Specialized => Self::Specialized,
CliDecodeLevel::All => Self::All,
}
}
}
impl From<CliObjectStreamMode> for ObjectStreamMode {
fn from(value: CliObjectStreamMode) -> Self {
match value {
CliObjectStreamMode::Preserve => ObjectStreamMode::Preserve,
CliObjectStreamMode::Disable => ObjectStreamMode::Disable,
CliObjectStreamMode::Generate => ObjectStreamMode::Generate,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliStreamDataMode {
Preserve,
Uncompress,
Compress,
}
impl From<CliStreamDataMode> for StreamDataMode {
fn from(v: CliStreamDataMode) -> Self {
match v {
CliStreamDataMode::Preserve => StreamDataMode::Preserve,
CliStreamDataMode::Uncompress => StreamDataMode::Uncompress,
CliStreamDataMode::Compress => StreamDataMode::Compress,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliFlattenMode {
All,
Screen,
Print,
}
impl CliFlattenMode {
#[cfg(test)]
fn flags(self) -> (i64, i64) {
FlattenAnnotationsMode::from(self).qpdf_flags()
}
}
impl From<CliFlattenMode> for FlattenAnnotationsMode {
fn from(value: CliFlattenMode) -> Self {
match value {
CliFlattenMode::All => Self::All,
CliFlattenMode::Screen => Self::Screen,
CliFlattenMode::Print => Self::Print,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliYesNo {
#[clap(name = "y")]
Yes,
#[clap(name = "n")]
No,
}
fn normalize_content_enabled(setting: Option<CliYesNo>, qdf: bool) -> bool {
match setting {
Some(CliYesNo::Yes) => true,
Some(CliYesNo::No) => false,
None => qdf,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliNewlineBeforeEndstream {
#[clap(name = "y")]
Yes,
#[clap(name = "n")]
No,
#[clap(name = "never")]
Never,
}
impl From<CliNewlineBeforeEndstream> for NewlineBeforeEndstream {
fn from(v: CliNewlineBeforeEndstream) -> Self {
match v {
CliNewlineBeforeEndstream::Yes => NewlineBeforeEndstream::Yes,
CliNewlineBeforeEndstream::No => NewlineBeforeEndstream::Yes,
CliNewlineBeforeEndstream::Never => NewlineBeforeEndstream::Never,
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, ValueEnum)]
enum CliRemoveUnreferencedResources {
#[default]
Auto,
Yes,
No,
}
impl From<CliRemoveUnreferencedResources> for RemoveUnreferencedResources {
fn from(v: CliRemoveUnreferencedResources) -> Self {
match v {
CliRemoveUnreferencedResources::Auto => RemoveUnreferencedResources::Auto,
CliRemoveUnreferencedResources::Yes => RemoveUnreferencedResources::Yes,
CliRemoveUnreferencedResources::No => RemoveUnreferencedResources::No,
}
}
}
#[derive(Debug, Clone, Copy, Default, ClapArgs)]
struct RecoveryArgs {
#[arg(long = "ignore-xref-streams")]
ignore_xref_streams: bool,
#[arg(long = "suppress-recovery", conflicts_with = "repair")]
suppress_recovery: bool,
}
#[derive(Debug, Clone, Default, ClapArgs)]
struct PasswordArgs {
#[command(flatten)]
recovery: RecoveryArgs,
#[arg(skip)]
verbose: bool,
#[arg(skip)]
raw_password: Option<Vec<u8>>,
#[arg(long, require_equals = true, conflicts_with = "password_file")]
password: Option<OsString>,
#[arg(long = "password-file", value_name = "PATH", require_equals = true)]
password_file: Option<PathBuf>,
#[arg(long = "password-mode", value_enum, require_equals = true, default_value_t = CliPasswordMode::Auto, overrides_with = "password_mode")]
password_mode: CliPasswordMode,
#[arg(long = "allow-weak-crypto")]
allow_weak_crypto: bool,
#[arg(
long = "password-is-hex-key",
long_help = "Interpret the --password value as the precomputed file \
encryption key encoded as hex, NOT a user or owner password. All \
password→key derivation (Algorithm 2 / 2.A / 2.B / 6 / 7) is skipped and the \
decoded bytes are used directly as the file key for stream/string \
decryption. Upper- or lower-case hex and embedded whitespace are accepted; \
the decoded key must be at most 32 bytes. Mirrors qpdf \
--password-is-hex-key. Pair with `show-encryption-key` to recover the key \
from a known password, then reopen the file with that key."
)]
password_is_hex_key: bool,
#[arg(
long = "suppress-password-recovery",
long_help = "Accepted for qpdf script compatibility. qpdf retries \
alternate password encodings (UTF-8 / PDFDocEncoding) when authentication \
fails; this flag disables that recovery."
)]
suppress_password_recovery: bool,
}
impl PasswordArgs {
fn password_bytes(&self) -> Option<Vec<u8>> {
self.raw_password.clone().or_else(|| {
self.password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
})
}
fn set_password_bytes(&mut self, password: Option<Vec<u8>>) {
self.raw_password = password.clone();
self.password = password.map(|password| arg_parser::os_string_from_bytes(&password));
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, ValueEnum)]
enum CliPasswordMode {
#[default]
Auto,
Bytes,
#[clap(name = "hex-bytes")]
HexBytes,
Unicode,
}
impl From<CliPasswordMode> for PasswordMode {
fn from(value: CliPasswordMode) -> Self {
match value {
CliPasswordMode::Auto => PasswordMode::Auto,
CliPasswordMode::Bytes => PasswordMode::Bytes,
CliPasswordMode::HexBytes => PasswordMode::HexBytes,
CliPasswordMode::Unicode => PasswordMode::Unicode,
}
}
}
const STATIC_ID_QUIET_ENV: &str = "FLPDF_STATIC_ID_QUIET";
fn static_id_warning_applies(args: &Cli) -> bool {
matches!(&args.command, Some(Commands::Rewrite(cmd)) if cmd.static_id)
}
fn warn_if_static_id(args: &Cli) {
if !static_id_warning_applies(args) {
return;
}
if std::env::var_os(STATIC_ID_QUIET_ENV).is_some() {
return;
}
emit_logger_error(
"flpdf: warning: --static-id is for testing only and must not be used for production output\n",
);
}
fn preprocess_qpdf_args<T: Into<OsString>>(args: Vec<T>) -> CliResult<PreprocessedArgs> {
let args = args.into_iter().map(Into::into).collect();
let mut segment_handler = QpdfSegmentHandler::default();
let parsed = arg_parser::ArgParser::from_command(cli_command())
.parse_os_with_handler(args, &mut segment_handler)?;
let QpdfSegmentHandler {
overlay_specs,
page_specs,
encrypt_segments,
..
} = segment_handler;
let arg_parser::ParsedArgs {
residual_args,
original_residual_args,
raw_residual_args,
raw_named_segments,
native_subcommand_mode,
expanded_arg_count,
first_unknown_option,
..
} = parsed;
let mut attachment_segments = Vec::new();
let mut raw_encrypt = None;
let mut raw_encrypt_segments = Vec::new();
let mut raw_pages = None;
let mut raw_copy_attachments_from = Vec::new();
for segment in raw_named_segments {
let option = segment.option;
let tokens = segment
.tokens
.into_iter()
.map(|token| token.as_bytes().to_vec())
.collect::<Vec<_>>();
match option.as_str() {
"overlay" | "underlay" => {}
"add-attachment" => attachment_segments.push(tokens),
"encrypt" => {
raw_encrypt_segments.push(tokens.clone());
raw_encrypt = Some(tokens);
}
"pages" => raw_pages = Some(tokens),
"copy-attachments-from" => {
raw_copy_attachments_from.push(tokens)
}
_ => {}
}
}
Ok(PreprocessedArgs {
residual_args,
original_residual_args,
native_subcommand_mode,
expanded_arg_count,
first_unknown_option,
overlay_specs,
attachment_segments,
raw_overrides: RawCliOverrides {
password: raw_option_value(&raw_residual_args, "password"),
encryption_file_password: raw_option_value(
&raw_residual_args,
"encryption-file-password",
),
raw_encrypt,
raw_pages,
parsed_page_specs: page_specs,
raw_encrypt_segments: (!raw_encrypt_segments.is_empty())
.then_some(raw_encrypt_segments),
parsed_encrypt_segments: (!encrypt_segments.is_empty()).then_some(encrypt_segments),
last_encryption_mode: last_encryption_mode(&raw_residual_args),
raw_copy_attachments_from: (!raw_copy_attachments_from.is_empty())
.then_some(raw_copy_attachments_from),
},
})
}
fn raw_option_value(args: &[arg_parser::RawArg], name: &str) -> Option<Vec<u8>> {
let mut attached_prefix = b"--".to_vec();
attached_prefix.extend_from_slice(name.as_bytes());
let mut separate_option = b"--".to_vec();
separate_option.extend_from_slice(name.as_bytes());
let mut found = None;
let mut index = 1;
while index < args.len() {
let bytes = args[index].as_bytes();
if bytes == b"--" {
break;
}
if is_named_segment_option(bytes) {
index += 1;
while index < args.len() && args[index].as_bytes() != b"--" {
index += 1;
}
index += usize::from(index < args.len());
continue;
}
if let Some(value) = bytes
.strip_prefix(attached_prefix.as_slice())
.and_then(|value| {
value
.first()
.is_some_and(|byte| *byte == b'=')
.then(|| value[1..].to_vec())
})
{
found = Some(value);
} else if bytes == separate_option.as_slice() {
if let Some(value) = args.get(index + 1) {
found = Some(value.as_bytes().to_vec());
index += 1;
}
}
index += 1;
}
found
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EncryptionMode {
Decrypt,
Encrypt,
CopyEncryption,
}
fn last_encryption_mode(args: &[arg_parser::RawArg]) -> Option<EncryptionMode> {
let mut mode = None;
for arg in args.iter().skip(1) {
let bytes = arg.as_bytes();
match bytes {
b"--decrypt" => mode = Some(EncryptionMode::Decrypt),
b"--encrypt" => mode = Some(EncryptionMode::Encrypt),
bytes
if bytes
.strip_prefix(b"--copy-encryption")
.is_some_and(|suffix| suffix.is_empty() || suffix[0] == b'=') =>
{
mode = Some(EncryptionMode::CopyEncryption);
}
_ => {}
}
}
mode
}
fn is_named_segment_option(bytes: &[u8]) -> bool {
matches!(
bytes,
b"--encrypt"
| b"--pages"
| b"--add-attachment"
| b"--copy-attachments-from"
| b"--overlay"
| b"--underlay"
)
}
fn raw_os_args(args: &[OsString]) -> Vec<Vec<u8>> {
args.iter().map(|arg| arg_parser::os_bytes(arg)).collect()
}
fn apply_raw_overrides(args: &mut Cli, overrides: RawCliOverrides) {
let RawCliOverrides {
password,
encryption_file_password,
raw_encrypt,
raw_encrypt_segments,
raw_pages,
parsed_page_specs,
parsed_encrypt_segments,
last_encryption_mode,
raw_copy_attachments_from,
} = overrides;
args.password.raw_password = password.clone();
args.raw_encryption_file_password = encryption_file_password.clone().or_else(|| {
args.encryption_file_password
.as_ref()
.map(|value| arg_parser::os_bytes(value))
});
args.last_encryption_mode = last_encryption_mode;
args.raw_encrypt =
raw_encrypt.or_else(|| args.encrypt.as_ref().map(|tokens| raw_os_args(tokens)));
args.raw_encrypt_segments = raw_encrypt_segments;
args.parsed_encrypt_segments = parsed_encrypt_segments.clone();
args.page_ops.raw_pages = raw_pages
.or_else(|| (!args.page_ops.pages.is_empty()).then(|| raw_os_args(&args.page_ops.pages)));
args.page_ops.parsed_page_specs = parsed_page_specs.clone();
args.raw_copy_attachments_from = raw_copy_attachments_from.or_else(|| {
(!args.copy_attachments_from.is_empty())
.then(|| vec![raw_os_args(&args.copy_attachments_from)])
});
if let Some(command) = args.command.as_mut() {
match command {
Commands::Check(command) => command.password.raw_password = password.clone(),
Commands::Pages(command) => command.password.raw_password = password.clone(),
Commands::Qdf(command) => command.password.raw_password = password.clone(),
Commands::ShowEncryption(command)
| Commands::RequiresPassword(command)
| Commands::ShowEncryptionKey(command) => {
command.password.raw_password = password.clone()
}
Commands::Rewrite(command) => {
command.password.raw_password = password.clone();
command.raw_encryption_file_password = args.raw_encryption_file_password.clone();
command.raw_encrypt = args.raw_encrypt.clone();
command.parsed_encrypt_segments = args.parsed_encrypt_segments.clone();
command.page_ops.raw_pages = args.page_ops.raw_pages.clone();
command.page_ops.parsed_page_specs = args.page_ops.parsed_page_specs.clone();
command.raw_copy_attachments_from = args.raw_copy_attachments_from.clone();
}
Commands::CheckLinearization(_)
| Commands::IsEncrypted(_)
| Commands::QdfFix(_)
| Commands::ZlibFlate(_) => {}
}
}
}
const CLI_COMMAND_STACK_RED_ZONE: usize = 4 * 1024 * 1024;
const CLI_COMMAND_STACK_GROWTH_SIZE: usize = 4 * 1024 * 1024;
fn cli_command() -> clap::Command {
stacker::maybe_grow(
CLI_COMMAND_STACK_RED_ZONE,
CLI_COMMAND_STACK_GROWTH_SIZE,
Cli::command,
)
}
#[cfg(test)]
fn cli_parse_from(args: Vec<OsString>) -> Cli {
cli_parse_from_mode(args, true)
}
fn cli_parse_from_mode(args: Vec<OsString>, native_subcommand_mode: bool) -> Cli {
stacker::maybe_grow(
CLI_COMMAND_STACK_RED_ZONE,
CLI_COMMAND_STACK_GROWTH_SIZE,
|| {
if native_subcommand_mode {
return Cli::parse_from(args);
}
let mut disabled_index = 0;
let command = cli_command().mut_subcommands(|subcommand| {
let disabled_name: &'static str = Box::leak(
format!("__flpdf_qpdf_compat_native_subcommand_{disabled_index}")
.into_boxed_str(),
);
disabled_index += 1;
subcommand
.name(disabled_name)
.hide(true)
.alias(None)
.visible_alias(None)
.short_flag(None)
.short_flag_alias(None)
.visible_short_flag_alias(None)
});
let matches = command.get_matches_from(args);
Cli::from_arg_matches(&matches).unwrap_or_else(|error| error.exit())
},
)
}
fn print_qpdf_version() {
emit_logger_info(format!(
"qpdf version {}\nRun qpdf --copyright to see copyright and license information.\n",
flpdf::qpdf_version()
));
}
fn print_qpdf_copyright() {
emit_logger_info(format!(
"qpdf version {}\n\n\
Copyright (c) 2005-2024 Jay Berkenbilt\n\
QPDF is licensed under the Apache License, Version 2.0 (the \"License\");\n\
you may not use this file except in compliance with the License.\n\
You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n\
Unless required by applicable law or agreed to in writing, software\n\
distributed under the License is distributed on an \"AS IS\" BASIS,\n\
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
See the License for the specific language governing permissions and\n\
limitations under the License.\n\n\
Versions of qpdf prior to version 7 were released under the terms\n\
of version 2.0 of the Artistic License. At your option, you may\n\
continue to consider qpdf to be licensed under those terms. Please\n\
see the manual for additional information.\n",
flpdf::qpdf_version()
));
}
fn print_flpdf_help() {
let mut command = cli_command();
emit_logger_info(command.render_help().to_string());
}
fn qpdf_help_topic_body(topic: &[u8]) -> Option<Vec<u8>> {
let who = progname();
match topic {
b"usage" => Some(
format!(
r#"Read a PDF file, apply transformations or modifications, and write
a new PDF file.
Usage: {who} [infile] [options] [outfile]
OR {who} --help[={{topic|--option}}]
- infile, options, and outfile may be in any order as long as infile
precedes outfile.
- Use --empty in place of an input file for a zero-page, empty input
- Use --replace-input in place of an output file to overwrite the
input file with the output
- outfile may be - to write to stdout; reading from stdin is not supported
- @filename is an argument file; each line is treated as a separate
command-line argument
- @- may be used to read arguments from stdin
- Later options may override earlier options if contradictory
Related options:
--empty: use empty file as input
--job-json-file: job JSON file
--replace-input: overwrite input with output
For detailed help, visit the qpdf manual: https://qpdf.readthedocs.io
"#
)
.into_bytes(),
),
b"exit-status" => Some(
br#"Meaning of exit codes:
- 0: no errors or warnings
- 1: not used by qpdf but may be used by the shell if unable to invoke qpdf
- 2: errors detected
- 3: warnings detected, unless --warning-exit-0 is given
Related options:
--warning-exit-0: exit 0 even with warnings
For detailed help, visit the qpdf manual: https://qpdf.readthedocs.io
"#
.to_vec(),
),
_ => None,
}
}
fn qpdf_sole_help_topic(preprocessed: &PreprocessedArgs) -> Option<Option<Vec<u8>>> {
if preprocessed.expanded_arg_count != 2 || preprocessed.original_residual_args.len() != 2 {
return None;
}
let bytes = preprocessed.original_residual_args[1].as_bytes();
if bytes == b"--help" || bytes == b"-help" {
return Some(None);
}
bytes
.strip_prefix(b"--help=")
.or_else(|| bytes.strip_prefix(b"-help="))
.map(|topic| Some(topic.to_vec()))
}
fn unknown_help_option_error(topic: &[u8]) -> UsageError {
let mut message = b"unknown help option".to_vec();
if !topic.is_empty() {
message.push(b' ');
message.extend_from_slice(topic);
}
UsageError::new(message)
}
fn unrecognized_argument_error(argument: &[u8]) -> UsageError {
let mut message = b"unrecognized argument ".to_vec();
message.extend_from_slice(argument);
UsageError::new(message)
}
fn qpdf_compat_help_usage_error(preprocessed: &PreprocessedArgs) -> Option<UsageError> {
if preprocessed.native_subcommand_mode {
return None;
}
let sole_option = preprocessed.expanded_arg_count == 2 && preprocessed.residual_args.len() == 2;
let args = &preprocessed.residual_args;
let original_args = &preprocessed.original_residual_args;
debug_assert_eq!(args.len(), original_args.len());
let mut index = 1;
while index < args.len() {
let bytes = arg_parser::os_bytes(&args[index]);
if is_named_segment_option(&bytes) {
index += 1;
while index < args.len() && arg_parser::os_bytes(&args[index]) != b"--" {
index += 1;
}
index += usize::from(index < args.len());
continue;
}
let original_bytes = original_args[index].as_bytes();
if preprocessed
.first_unknown_option
.as_ref()
.is_some_and(|(unknown_index, _)| *unknown_index == index)
{
return Some(unrecognized_argument_error(original_bytes));
}
let is_help_table_option = original_bytes == b"-h"
|| original_bytes == b"--help"
|| original_bytes == b"-help"
|| original_bytes.starts_with(b"--help=")
|| original_bytes.starts_with(b"-help=")
|| original_bytes == b"--version"
|| original_bytes == b"-version"
|| original_bytes == b"--copyright"
|| original_bytes == b"-copyright";
if is_help_table_option && (!sole_option || original_bytes == b"-h") {
return Some(unrecognized_argument_error(original_bytes));
}
index += 1;
}
None
}
fn main() {
let _ = cli_logger();
let raw_args: Vec<OsString> = std::env::args_os().collect();
if raw_args
.first()
.is_some_and(|program| is_zlib_flate_program(program))
{
if let Err(error) = run_zlib_flate(&raw_args[1..], "zlib-flate", "zlib-flate") {
let code = error
.downcast_ref::<CliExitError>()
.map_or(ExitCode::Errors, |error| error.code);
std::process::exit(code.as_i32());
}
return;
}
let preprocessed = match preprocess_qpdf_args(raw_args) {
Ok(parsed) => parsed,
Err(error) => {
if let Some(usage_error) = find_usage_error(error.as_ref()) {
usage_exit(usage_error);
}
emit_logger_error(format!("{}: {error}\n", progname()));
std::process::exit(2);
}
};
if let Some(topic) = qpdf_sole_help_topic(&preprocessed) {
match topic {
None => {
print_flpdf_help();
return;
}
Some(topic) => {
if let Some(body) = qpdf_help_topic_body(&topic) {
emit_logger_info(body);
return;
}
usage_exit(&unknown_help_option_error(&topic));
}
}
}
if let Some(error) = qpdf_compat_help_usage_error(&preprocessed) {
usage_exit(&error);
}
if preprocessed.expanded_arg_count == 2 && preprocessed.original_residual_args.len() == 2 {
match preprocessed.original_residual_args[1].as_bytes() {
b"--version" | b"-version" => {
print_qpdf_version();
return;
}
b"--copyright" | b"-copyright" => {
print_qpdf_copyright();
return;
}
_ => {}
}
}
let PreprocessedArgs {
residual_args,
native_subcommand_mode,
overlay_specs,
attachment_segments,
raw_overrides,
..
} = preprocessed;
let mut args = cli_parse_from_mode(residual_args, native_subcommand_mode);
apply_raw_overrides(&mut args, raw_overrides);
let _ = CLI_WARNING_EXIT_ZERO.set(args.warning_exit_zero);
args.password.verbose = args.verbose;
validate_collate_values(&args.page_ops.collate);
if let Err(error) = validate_keep_files_open_threshold(&args.page_ops) {
emit_logger_error(format!("flpdf: {error}\n"));
std::process::exit(2);
}
let top_level_version_options =
match parse_cli_version_options(args.min_version.as_deref(), args.force_version.as_deref())
{
Ok(options) => options,
Err(error) => {
emit_logger_error(format!("flpdf: {error}\n"));
std::process::exit(1);
}
};
let top_level_compression_level =
match parse_compression_level(args.compression_level.as_deref()) {
Ok(level) => level,
Err(error) => {
emit_logger_error(format!("flpdf: {error}\n"));
std::process::exit(2);
}
};
let top_level_image_options = match image_optimization_options(
args.keep_inline_images,
args.oi_min_width.as_deref(),
args.oi_min_height.as_deref(),
args.oi_min_area.as_deref(),
args.ii_min_bytes.as_deref(),
) {
Ok(options) => options,
Err(error) => {
emit_logger_error(format!("flpdf: {error}\n"));
std::process::exit(2);
}
};
let top_level_image_transform_options = ImageTransformOptions::new(
args.externalize_inline_images,
args.optimize_images,
top_level_image_options,
);
let mut top_level_inspection_transform_options = InspectionTransformOptions::new(
top_level_image_transform_options,
args.generate_appearances,
args.flatten_annotations,
);
top_level_inspection_transform_options.flatten_rotation = args.flatten_rotation;
let normalize_content =
normalize_content_enabled(args.normalize_content, args.qdf && !args.linearize);
warn_if_static_id(&args);
if !overlay_specs.is_empty() {
let target_is_rewrite = match &args.command {
Some(Commands::Rewrite(_)) => true,
Some(_) => false,
None => {
args.json.is_none()
&& args.show_object.is_none()
&& !args.show_npages
&& !args.show_pages
&& !args.show_xref
&& !args.check_linearization
&& !args.show_linearization
&& !args.show_encryption
&& !args.check
&& !args.list_attachments
&& args.show_attachment.is_none()
&& args.remove_attachment.is_empty()
&& attachment_segments.is_empty()
&& args.copy_attachments_from.is_empty()
}
};
let target_is_inspection = args.check
|| args.show_object.is_some()
|| args.show_npages
|| args.show_pages
|| args.show_xref
|| args.check_linearization
|| args.show_linearization
|| args.list_attachments
|| args.show_attachment.is_some();
if !target_is_rewrite && !target_is_inspection {
emit_logger_error(
"flpdf: --overlay/--underlay can only be used with rewrite output, \
not with inspection or other commands\n",
);
std::process::exit(2);
}
}
if args.replace_input && split_pages_active(args.page_ops.split_pages.as_deref()) {
usage_exit(&UsageError::new(
"--split-pages may not be used with --replace-input",
));
}
if args.replace_input
&& (args.check
|| args.check_linearization
|| args.show_object.is_some()
|| args.show_npages
|| args.show_pages
|| args.show_xref
|| args.show_linearization
|| args.show_encryption
|| args.is_encrypted
|| args.requires_password
|| args.list_attachments
|| args.show_attachment.is_some())
{
usage_exit(&UsageError::new(
"no output file may be given for this option",
));
}
let json_input_inspection = (args.json_input || args.update_from_json.is_some())
&& (args.check
|| args.show_npages
|| args.show_pages
|| args.show_xref
|| args.show_encryption);
if args.check_linearization && args.output.is_some() {
usage_exit(&no_output_file_for_inspection_error());
}
let attachment_mutation_requested = !attachment_segments.is_empty()
|| !args.remove_attachment.is_empty()
|| !args.copy_attachments_from.is_empty();
let result = if args.replace_input && (args.json.is_some() || args.json_output.is_some()) {
Err(UsageError::new("--json may not be used with --replace-input").into())
} else if !args.job_json_file.is_empty() {
run_job_json_files(
&args.job_json_file,
args.input.as_deref(),
args.output.as_deref(),
args.replace_input,
&args.password,
args.no_warn,
)
} else if json_input_inspection {
run_json_input_inspection(&args, top_level_inspection_transform_options)
} else if args.json.is_some() || args.json_output.is_some() {
run_json(
&args,
top_level_inspection_transform_options,
&attachment_segments,
args.page_ops.empty,
)
} else if let Some(command) = args.command {
run_command(command, &overlay_specs)
} else if args.is_encrypted {
if args.page_ops.empty {
run_empty_document_encryption_status()
} else {
match args.input.as_ref() {
Some(input) => run_is_encrypted(input, args.repair, &args.password, args.no_warn),
None => Err(missing_input_usage_error().into()),
}
}
} else if args.requires_password {
if args.page_ops.empty {
run_empty_document_encryption_status()
} else {
match args.input.as_ref() {
Some(input) => {
run_requires_password(input, args.repair, &args.password, args.no_warn)
}
None => Err(missing_input_usage_error().into()),
}
}
} else if top_level_inspection_combination_requested(
&args,
!overlay_specs.is_empty(),
attachment_mutation_requested,
) {
run_combined_top_level_inspection(
&args,
top_level_inspection_transform_options,
&overlay_specs,
&attachment_segments,
)
} else if let Some(object_ref) = args.show_object.as_deref() {
run_show_object(
args.input,
args.repair,
&args.password,
object_ref,
args.raw_stream_data,
args.filtered_stream_data,
matches!(args.normalize_content, Some(CliYesNo::Yes)),
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.show_npages {
run_show_npages(
args.input,
args.repair,
&args.password,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.show_pages {
run_show_pages(
args.input,
args.repair,
&args.password,
args.with_images,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.show_xref {
run_show_xref(
args.input,
args.repair,
&args.password,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.check_linearization {
run_check_linearization(
args.input,
args.repair,
&args.password,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.show_linearization {
run_show_linearization(
args.input,
args.repair,
&args.password,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.show_encryption {
run_show_encryption(
args.input,
args.repair,
&args.password,
args.no_warn,
args.show_encryption_key,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.check {
run_check(
args.input,
args.repair,
&args.password,
args.no_warn,
args.show_encryption_key,
args.page_ops.empty,
top_level_inspection_transform_options,
args.verbose,
)
} else if args.list_attachments {
run_list_attachments(
args.input,
args.repair,
&args.password,
args.verbose,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
)
} else if let Some(key) = args.show_attachment {
run_show_attachment(
args.input,
args.repair,
&args.password,
&key,
args.verbose,
args.no_warn,
args.page_ops.empty,
top_level_inspection_transform_options,
)
} else if !args.remove_attachment.is_empty() {
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_remove_attachment(
args.input,
args.output,
args.replace_input,
args.repair,
&args.password,
&args.remove_attachment,
args.verbose,
args.no_warn,
args.remove_restrictions,
args.linearize,
args.linearize_pass1.as_deref(),
options,
top_level_inspection_transform_options,
)
} else if !attachment_segments.is_empty() {
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_add_attachment(
args.input,
args.output,
args.replace_input,
args.repair,
&args.password,
attachment_segments,
args.verbose,
args.no_warn,
args.remove_restrictions,
args.linearize,
args.linearize_pass1.as_deref(),
options,
top_level_inspection_transform_options,
)
} else if !args.copy_attachments_from.is_empty() {
let copy_groups = args
.raw_copy_attachments_from
.clone()
.unwrap_or_else(|| vec![raw_os_args(&args.copy_attachments_from)]);
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_copy_attachments_from(
args.input,
args.output,
args.replace_input,
args.repair,
&args.password,
copy_groups,
args.verbose,
args.no_warn,
args.remove_restrictions,
args.linearize,
args.linearize_pass1.as_deref(),
options,
top_level_inspection_transform_options,
)
} else if args.page_ops.empty
&& args.page_ops.pages.is_empty()
&& args.page_ops.rotate.is_empty()
&& !split_pages_active(args.page_ops.split_pages.as_deref())
{
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_rewrite(
args.input,
args.output,
args.replace_input,
args.repair,
&args.password,
args.json_input,
args.update_from_json.as_deref(),
args.linearize,
args.linearize_pass1.as_deref(),
args.remove_restrictions,
args.decrypt,
normalize_content,
args.coalesce_contents,
args.remove_unreferenced_resources,
args.generate_appearances,
top_level_image_transform_options,
args.flatten_annotations,
args.flatten_rotation,
page_label_options(args.set_page_labels.as_deref(), args.remove_page_labels),
&overlay_specs,
args.verbose,
args.no_warn,
options,
true,
)
} else if args.linearize && !page_ops_active(&args.page_ops) {
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
let result = run_rewrite(
args.input,
args.output.clone(),
args.replace_input,
args.repair,
&args.password,
args.json_input,
args.update_from_json.as_deref(),
true,
args.linearize_pass1.as_deref(),
args.remove_restrictions,
args.decrypt,
normalize_content,
args.coalesce_contents,
args.remove_unreferenced_resources,
args.generate_appearances,
top_level_image_transform_options,
args.flatten_annotations,
args.flatten_rotation,
page_label_options(args.set_page_labels.as_deref(), args.remove_page_labels),
&overlay_specs,
args.verbose,
args.no_warn,
options,
args.page_ops.empty,
);
result
} else if page_ops_active(&args.page_ops) {
let mut options = WriterOptions {
static_id: args.static_id,
deterministic_id: args.deterministic_id,
static_aes_iv: args.static_aes_iv,
no_original_object_ids: args.no_original_object_ids,
preserve_unreferenced_objects: args.preserve_unreferenced,
progress: args.progress,
verbose: args.verbose,
recompress_flate: args.recompress_flate,
compression_level: top_level_compression_level,
object_streams: args.object_streams.into(),
stream_data: args.stream_data.map(Into::into),
content_normalization: normalize_content,
content_normalization_set: args.normalize_content.is_some(),
qdf: args.qdf,
newline_before_endstream: args.newline_before_endstream.into(),
password_mode: args.password.password_mode.into(),
allow_weak_crypto: args.password.allow_weak_crypto,
..WriterOptions::default()
};
apply_cli_decode_level(&mut options, args.decode_level);
apply_cli_version_options(&mut options, &top_level_version_options);
if let Some(ref cs) = args.compress_streams {
match cs.as_str() {
"y" => options.compress_streams = Some(CompressStreams::Yes),
"n" => options.compress_streams = Some(CompressStreams::No),
other => {
emit_logger_error(format!(
"flpdf: --compress-streams must be y or n, got: {:?}\n",
other
));
std::process::exit(2);
}
}
}
apply_encryption_options(
&mut options,
EncryptionCliOptions {
encrypt: args.raw_encrypt.as_deref(),
encrypt_segments: args.raw_encrypt_segments.as_deref(),
parsed_encrypt_segments: args.parsed_encrypt_segments.as_deref(),
copy_encryption: None,
encryption_file_password: args.raw_encryption_file_password.as_deref(),
password_args: &args.password,
suppress_warnings: args.no_warn,
last_mode: args.last_encryption_mode,
},
);
if args.decrypt {
options.preserve_encryption = false;
}
run_page_operations_with_qpdf_job(
&args,
options,
top_level_image_transform_options,
&overlay_specs,
)
} else {
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_rewrite(
args.input,
args.output,
args.replace_input,
args.repair,
&args.password,
args.json_input,
args.update_from_json.as_deref(),
false,
None,
args.remove_restrictions,
args.decrypt,
normalize_content,
args.coalesce_contents,
args.remove_unreferenced_resources,
args.generate_appearances,
top_level_image_transform_options,
args.flatten_annotations,
args.flatten_rotation,
page_label_options(args.set_page_labels.as_deref(), args.remove_page_labels),
&overlay_specs,
args.verbose,
args.no_warn,
options,
args.page_ops.empty,
)
};
if let Err(error) = result {
if let Some(exit_err) = error.downcast_ref::<CliExitError>() {
if !exit_err.message.is_empty() {
emit_logger_error(format!("\n{}: {}\n", progname(), exit_err.message));
}
std::process::exit(exit_err.code.as_i32());
}
if let Some(usage_error) = find_usage_error(error.as_ref()) {
usage_exit(usage_error);
}
if let Some(message) = find_raw_error_message(error.as_ref()) {
let mut line = progname().into_bytes();
line.extend_from_slice(b": ");
line.extend_from_slice(message);
line.push(b'\n');
emit_logger_error(line);
std::process::exit(2);
}
if let Some(flpdf::Error::FileIo {
operation: "open",
path,
source,
}) = error.downcast_ref::<flpdf::Error>()
{
let mut line = progname().into_bytes();
line.extend_from_slice(b": open ");
line.extend_from_slice(&path_description(path));
line.extend_from_slice(b": ");
line.extend_from_slice(qpdf_open_io_error_message(source).as_bytes());
line.push(b'\n');
emit_logger_error(line);
std::process::exit(2);
}
if let Some(path_error) = error.downcast_ref::<CliPathError>() {
let mut line = progname().into_bytes();
line.extend_from_slice(b": ");
if let Some(operation) = path_error.operation {
line.extend_from_slice(operation.as_bytes());
line.push(b' ');
}
line.extend_from_slice(&path_error.path);
line.extend_from_slice(b": ");
line.extend_from_slice(path_error.message.as_bytes());
line.push(b'\n');
emit_logger_error(line);
std::process::exit(2);
}
emit_logger_error(format!("{}: {error}\n", progname()));
std::process::exit(2);
}
}
fn find_usage_error<'a>(error: &'a (dyn std::error::Error + 'static)) -> Option<&'a UsageError> {
if let Some(usage_error) = error.downcast_ref::<UsageError>() {
return Some(usage_error);
}
if let Some(Error::Usage(usage_error)) = error.downcast_ref::<Error>() {
return Some(usage_error);
}
error.source().and_then(find_usage_error)
}
fn find_raw_error_message<'a>(error: &'a (dyn std::error::Error + 'static)) -> Option<&'a [u8]> {
if let Some(error) = error.downcast_ref::<Error>() {
if let Some(message) = error.raw_message() {
return Some(message);
}
}
error.source().and_then(find_raw_error_message)
}
fn usage_exit(error: &UsageError) -> ! {
let who = progname();
let mut message = format!("\n{who}: ").into_bytes();
message.extend_from_slice(error.what_bytes());
message.extend_from_slice(
format!(
"\n\nFor help:\n {who} --help=usage usage information\n \
{who} --help=topic help on a topic\n {who} --help=--option help on an option\n \
{who} --help general help and a topic list\n\n"
)
.as_bytes(),
);
emit_logger_error(message);
std::process::exit(2);
}
fn missing_input_usage_error() -> UsageError {
UsageError::new("an input file name is required")
}
fn missing_output_usage_error() -> UsageError {
UsageError::new("an output file name is required; use - for standard output")
}
fn no_output_file_for_inspection_error() -> UsageError {
UsageError::new("no output file may be given for this option")
}
fn reject_empty_inspection_output(input: Option<&Path>) -> CliResult<()> {
if input.is_some() {
return Err(no_output_file_for_inspection_error().into());
}
Ok(())
}
fn new_cli_job(suppress_warnings: bool) -> QPDFJob {
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(suppress_warnings);
job.set_warnings_exit_zero(cli_warning_exit_zero());
job
}
fn top_level_inspection_combination_requested(
args: &Cli,
overlay_requested: bool,
attachment_mutation_requested: bool,
) -> bool {
let inspection_count = [
args.check,
args.show_object.is_some(),
args.show_npages,
args.show_pages,
args.show_xref,
args.check_linearization,
args.show_linearization,
args.show_encryption,
args.list_attachments,
args.show_attachment.is_some(),
]
.into_iter()
.filter(|selected| *selected)
.count();
if overlay_requested && inspection_count > 0 {
return true;
}
if inspection_count > 1
|| (inspection_count == 1 && !args.page_ops.pages.is_empty())
|| (inspection_count == 1 && (args.remove_restrictions || args.coalesce_contents))
|| (inspection_count == 1 && attachment_mutation_requested)
{
return true;
}
args.check_linearization
&& (args.linearize
|| args.static_id
|| args.deterministic_id
|| args.static_aes_iv
|| args.preserve_unreferenced
|| args.decrypt
|| args.qdf
|| args.coalesce_contents
|| args.remove_restrictions
|| !args.page_ops.rotate.is_empty()
|| !args.page_ops.collate.is_empty())
}
fn configure_top_level_inspection_job(job: &mut QPDFJob, args: &Cli) -> CliResult<()> {
job.set_password_is_hex_key(args.password.password_is_hex_key);
job.set_show_encryption_key(args.show_encryption_key);
job.set_with_images(args.with_images);
job.set_verbose(args.verbose);
if args.normalize_content.is_some() {
job.set_content_normalization(matches!(args.normalize_content, Some(CliYesNo::Yes)));
}
let mut configuration = job.config();
if args.check {
configuration.check();
}
if args.show_npages {
configuration.show_npages();
}
if args.show_encryption {
configuration.show_encryption();
}
if args.check_linearization {
configuration.check_linearization();
}
if args.show_linearization {
configuration.show_linearization();
}
if args.show_xref {
configuration.show_xref();
}
if let Some(selector) = args.show_object.as_deref() {
configuration.show_object(selector)?;
if args.raw_stream_data {
configuration.raw_stream_data();
}
if args.filtered_stream_data {
configuration.filtered_stream_data();
}
}
if args.show_pages {
configuration.show_pages();
}
if args.list_attachments {
configuration.list_attachments();
}
if let Some(key) = args.show_attachment.as_ref() {
configuration.show_attachment(arg_parser::os_bytes(key.as_os_str()).to_vec());
}
Ok(())
}
fn configure_top_level_attachment_mutations(
job: &mut QPDFJob,
args: &Cli,
attachment_segments: &[Vec<Vec<u8>>],
) -> CliResult<()> {
let mut configuration = job.config();
for tokens in attachment_segments.iter().cloned() {
let attachment = parse_add_attachment_segment(tokens)?;
let basename = path_basename(&attachment.file)?;
configuration.add_attachment(AttachmentAddOptions {
path: attachment.file,
key: attachment.key.unwrap_or_else(|| basename.clone()),
filename: attachment.filename.unwrap_or(basename),
mimetype: attachment.mimetype,
description: attachment.description,
creation_date: attachment.creation_date,
modification_date: attachment.mod_date,
replace: attachment.replace,
verbose: args.verbose,
});
}
for key in &args.remove_attachment {
configuration.remove_attachment(arg_parser::os_bytes(key));
}
for tokens in args.raw_copy_attachments_from.clone().unwrap_or_default() {
let donor = parse_copy_attachments_segment(tokens)?;
configuration.copy_attachments_from(
donor.file,
donor.password,
donor.prefix.unwrap_or_default(),
);
}
Ok(())
}
fn configure_cli_overlay_specs(job: &mut QPDFJob, specs: &[OverlaySpec]) -> CliResult<()> {
if specs.is_empty() {
return Ok(());
}
let mut configuration = job.config();
for spec in specs {
let from = match spec.from.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(range) => PageRange::parse_numrange(range)?,
};
let to = match spec.to.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(range) => PageRange::parse_numrange(range)?,
};
let repeat = match spec.repeat.as_deref() {
None | Some("") => None,
Some(range) => Some(PageRange::parse_numrange(range)?),
};
let password = spec
.raw_password
.clone()
.or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password).to_vec())
})
.unwrap_or_default();
let path = PathBuf::from(spec.file.clone());
match spec.kind {
OverlayKind::Overlay => {
configuration.overlay(path, password, from, to, repeat);
}
OverlayKind::Underlay => {
configuration.underlay(path, password, from, to, repeat);
}
}
}
Ok(())
}
fn run_top_level_page_selection_inspection(
args: &Cli,
transform_options: InspectionTransformOptions,
overlay_specs: &[OverlaySpec],
attachment_segments: &[Vec<Vec<u8>>],
) -> CliResult<()> {
let mut job = new_cli_job(args.no_warn);
let input_options = pdf_open_options(args.repair, &args.password)?;
job.set_password(input_options.password);
job.set_password_mode(args.password.password_mode.into());
job.set_password_is_hex_key(args.password.password_is_hex_key);
job.set_suppress_password_recovery(args.password.suppress_password_recovery);
job.set_suppress_recovery(args.password.recovery.suppress_recovery);
job.set_ignore_xref_streams(args.password.recovery.ignore_xref_streams);
job.set_verbose(args.verbose);
configure_top_level_inspection_job(&mut job, args)?;
configure_cli_overlay_specs(&mut job, overlay_specs)?;
if args.show_attachment.is_some() {
job.logger().save_to_standard_output(true)?;
}
configure_top_level_attachment_mutations(&mut job, args, attachment_segments)?;
configure_top_level_inspection_transformations(
&mut job,
transform_options,
args.verbose,
args.remove_restrictions,
args.coalesce_contents,
);
configure_keep_files_open(&mut job, &args.page_ops)?;
if args.page_ops.empty {
reject_empty_inspection_output(args.input.as_deref())?;
job.config().empty_input()?;
} else {
let input = args.input.as_ref().ok_or_else(missing_input_usage_error)?;
job.config().input_file(input.clone())?;
}
let raw_specs = configured_page_specs(&args.page_ops)?;
{
let mut configuration = job.config();
for spec in raw_specs {
let password = spec.raw_password.or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password.as_os_str()))
});
configuration.add_page_spec(PathBuf::from(spec.file_token), &spec.range, password)?;
}
for parameter in &args.page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
for parameter in &args.page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
configuration.remove_unreferenced_resources(args.remove_unreferenced_resources.into());
}
finish_job_exit_status(job.run()?)
}
fn run_combined_top_level_inspection(
args: &Cli,
transform_options: InspectionTransformOptions,
overlay_specs: &[OverlaySpec],
attachment_segments: &[Vec<Vec<u8>>],
) -> CliResult<()> {
if !args.page_ops.pages.is_empty() {
return run_top_level_page_selection_inspection(
args,
transform_options,
overlay_specs,
attachment_segments,
);
}
let mut job = new_cli_job(args.no_warn);
configure_top_level_inspection_job(&mut job, args)?;
configure_cli_overlay_specs(&mut job, overlay_specs)?;
if args.show_attachment.is_some() {
job.logger().save_to_standard_output(true)?;
}
configure_top_level_inspection_transformations(
&mut job,
transform_options,
args.verbose,
args.remove_restrictions,
args.coalesce_contents,
);
configure_top_level_attachment_mutations(&mut job, args, attachment_segments)?;
if args.page_ops.empty {
reject_empty_inspection_output(args.input.as_deref())?;
job.config().empty_input()?;
} else {
let input = args.input.as_ref().ok_or_else(missing_input_usage_error)?;
let input_options = pdf_open_options(args.repair, &args.password)?;
job.set_password(input_options.password);
job.set_password_mode(args.password.password_mode.into());
job.set_password_is_hex_key(args.password.password_is_hex_key);
job.set_suppress_password_recovery(args.password.suppress_password_recovery);
job.set_suppress_recovery(args.password.recovery.suppress_recovery);
job.set_ignore_xref_streams(args.password.recovery.ignore_xref_streams);
job.config().input_file(input.clone())?;
}
{
let mut configuration = job.config();
for parameter in &args.page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
}
finish_job_exit_status(job.run()?)
}
fn create_empty_primary_document(
job: &mut QPDFJob,
update_from_json: Option<&Path>,
) -> CliResult<flpdf::job::JobDocument> {
let mut pdf = job.create_empty_document()?;
apply_json_update_with_job(job, &mut pdf, update_from_json)?;
Ok(pdf)
}
fn run_job_json_files(
paths: &[PathBuf],
input: Option<&Path>,
output: Option<&Path>,
replace_input: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<()> {
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_suppress_warnings(suppress_warnings);
for path in paths {
let json = std::fs::read(path).map_err(|error| {
error_with_file(path, Box::new(error) as Box<dyn std::error::Error>)
})?;
job.initialize_from_json_partial_bytes(&json)
.map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(path, error),
}) as Box<dyn std::error::Error>
})?;
}
let error_path = paths.last().expect("job-json-file list is non-empty");
if let Some(input) = input {
job.set_input_file(input.to_path_buf()).map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(error_path, error),
}) as Box<dyn std::error::Error>
})?;
}
if let Some(output) = output {
job.set_output_file(output.to_path_buf()).map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(error_path, error),
}) as Box<dyn std::error::Error>
})?;
}
if replace_input {
job.config().replace_input().map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(error_path, error),
}) as Box<dyn std::error::Error>
})?;
}
if let Some(password) = password.password_bytes() {
job.set_password(password);
}
job.set_message_prefix(progname());
finish_job_exit_status(job.run()?)
}
fn format_job_json_error(path: &Path, error: impl std::fmt::Display) -> String {
format!(
"error with job-json file {}: {error}\nRun {} --job-json-help for information on the file format.\n\nFor help:\n {} --help=usage usage information\n {} --help=topic help on a topic\n {} --help=--option help on an option\n {} --help general help and a topic list\n",
path.display(),
progname(),
progname(),
progname(),
progname(),
progname(),
)
}
fn run_json(
cli: &Cli,
transform_options: InspectionTransformOptions,
attachment_segments: &[Vec<Vec<u8>>],
empty: bool,
) -> CliResult<()> {
const QPDF_JSON_KEY_NAMES: &[&str] = &[
"acroform",
"attachments",
"encrypt",
"objectinfo",
"objects",
"outlines",
"pagelabels",
"pages",
"qpdf",
];
let json_output_mode = cli.json_output.is_some();
let json_version = cli
.json_output
.as_deref()
.or(cli.json.as_deref())
.unwrap_or("2");
let json_version = match json_version {
"1" => 1,
"2" | "latest" => 2,
other => return Err(format!("unsupported json version {other}").into()),
};
let mut json_keys: Vec<JsonKey> = Vec::new();
for raw in &cli.json_key {
if json_version != 1 && matches!(raw.as_str(), "objects" | "objectinfo") {
emit_logger_error(
"flpdf: json keys \"objects\" and \"objectinfo\" are only valid for json version 1"
.to_owned()
+ "\n",
);
std::process::exit(2);
}
if json_version == 1 && raw == "qpdf" {
emit_logger_error("flpdf: json key \"qpdf\" is only valid for json version > 1\n");
std::process::exit(2);
}
match JsonKey::from_str(raw.as_str()) {
Some(k) => json_keys.push(k),
None => {
let names = QPDF_JSON_KEY_NAMES.join(",");
emit_logger_error(format!(
"flpdf: --json-key must be given as --json-key={{{names}}}\n"
));
std::process::exit(2);
}
}
}
if json_output_mode {
if json_version == 1 {
emit_logger_error("flpdf: --json-output requires JSON version 2\n");
std::process::exit(2);
}
if !json_keys.contains(&JsonKey::Qpdf) {
json_keys.push(JsonKey::Qpdf);
}
}
let json_objects = cli.json_object.clone();
let stream_data = match cli
.json_stream_data
.as_deref()
.unwrap_or(if json_output_mode { "inline" } else { "none" })
{
"none" => JsonStreamData::None,
"inline" => JsonStreamData::Inline,
"file" => JsonStreamData::File,
other => {
emit_logger_error(format!(
"flpdf: --json-stream-data must be none, inline, or file; got: {other}\n"
));
std::process::exit(2);
}
};
let input = if empty {
None
} else {
Some(cli.input.as_ref().ok_or_else(missing_input_usage_error)?)
};
let output_path = if empty {
if let Some(extra) = cli.output.as_ref() {
return Err(UsageError::new(format!("unknown argument {}", extra.display())).into());
}
cli.input.as_deref()
} else {
cli.output.as_deref()
};
if let (Some(input), Some(output)) = (input, output_path.filter(|path| *path != Path::new("-")))
{
reject_same_json_output(input, output)?;
}
let mut standard_output = if output_path.is_none_or(|path| path == Path::new("-")) {
Some(standard_save_writer()?)
} else {
None
};
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(cli.no_warn);
job.set_password_mode(cli.password.password_mode.into());
job.set_password_is_hex_key(cli.password.password_is_hex_key);
job.set_suppress_password_recovery(cli.password.suppress_password_recovery);
job.set_suppress_recovery(cli.password.recovery.suppress_recovery);
job.set_ignore_xref_streams(cli.password.recovery.ignore_xref_streams);
if let Some(input) = input {
job.set_input_name_bytes(path_description(input));
}
job.set_verbose(cli.verbose);
configure_top_level_attachment_mutations(&mut job, cli, attachment_segments)?;
{
let mut configuration = job.config();
for parameter in &cli.page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
}
if empty {
let mut pdf = create_empty_primary_document(&mut job, cli.update_from_json.as_deref())?;
apply_top_level_inspection_transformations(
&mut job,
&mut pdf,
transform_options,
cli.verbose,
false,
cli.coalesce_contents,
)?;
let mut runtime = JsonJobRuntime {
input_identity: None,
output_path,
standard_output: &mut standard_output,
job: &mut job,
};
return run_json_document(
cli,
&mut runtime,
&mut pdf,
json_version,
cli.test_json_schema,
cli.show_encryption_key,
json_output_mode,
stream_data,
&json_keys,
&json_objects,
);
}
let input = input.expect("non-empty JSON route has an input");
let input_file = File::open(input).map_err(|error| {
if cli.json_input {
qpdf_json_input_open_error(input, error)
} else {
json_input_open_error(input, error)
}
})?;
let input_identity = input_file
.try_clone()
.map_err(|error| error_with_file(input, error.into()))?;
if cli.json_input {
let mut pdf = job
.create_from_json_document(input_file, path_description(input))
.map_err(|error| json_error_with_file(input, Box::new(error)))?;
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
apply_top_level_inspection_transformations(
&mut job,
&mut pdf,
transform_options,
cli.verbose,
false,
cli.coalesce_contents,
)?;
let mut runtime = JsonJobRuntime {
input_identity: Some(&input_identity),
output_path,
standard_output: &mut standard_output,
job: &mut job,
};
run_json_document(
cli,
&mut runtime,
&mut pdf,
json_version,
cli.test_json_schema,
cli.show_encryption_key,
json_output_mode,
stream_data,
&json_keys,
&json_objects,
)
} else {
let mut pdf =
open_pdf_from_file(input, input_file, cli.repair, &cli.password, cli.no_warn)?;
job.record_document_warnings(&pdf);
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
apply_json_page_specs(&mut job, &mut pdf, input, &cli.page_ops)?;
apply_top_level_inspection_transformations(
&mut job,
&mut pdf,
transform_options,
cli.verbose,
false,
cli.coalesce_contents,
)?;
let mut runtime = JsonJobRuntime {
input_identity: Some(&input_identity),
output_path,
standard_output: &mut standard_output,
job: &mut job,
};
run_json_document(
cli,
&mut runtime,
&mut pdf,
json_version,
cli.test_json_schema,
cli.show_encryption_key,
json_output_mode,
stream_data,
&json_keys,
&json_objects,
)
}
}
fn apply_json_page_specs<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
primary_input: &Path,
page_ops: &PageOpArgs,
) -> CliResult<()> {
if page_ops.pages.is_empty() {
return Ok(());
}
let raw_specs = configured_page_specs(page_ops)?;
let inputs = resolve_page_specs(&raw_specs, primary_input)?;
if inputs.iter().any(|input| input.path != primary_input) {
return Err("--pages: JSON output currently accepts only the primary input source".into());
}
let specs: Vec<_> = inputs
.into_iter()
.map(|input| PageSpecInput::new(0, input.range))
.collect();
let collate = parse_collate_values(&page_ops.collate)?;
match job.handle_page_specs(
std::slice::from_mut(pdf),
&specs,
collate.as_deref(),
RemoveUnreferencedResources::Auto,
false,
)? {
PageSpecJobOutput::InPlace {
pdf,
result,
prune_mode,
} => {
QPDFJob::complete_in_place_page_selection(pdf, &result, prune_mode).map_err(Into::into)
}
PageSpecJobOutput::Merged(_) => {
Err("--pages: JSON output unexpectedly selected a multi-source page job".into())
}
}
}
fn run_json_input_inspection(
cli: &Cli,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
if cli.page_ops.empty {
reject_empty_inspection_output(cli.input.as_deref())?;
let mut job = new_cli_job(cli.no_warn);
let mut pdf = create_empty_primary_document(&mut job, cli.update_from_json.as_deref())?;
return run_job_inspection_on_pdf(cli, &mut job, &mut pdf, transform_options);
}
let input = cli.input.as_ref().ok_or_else(missing_input_usage_error)?;
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(cli.no_warn);
let file = File::open(input).map_err(|error| {
if cli.json_input {
qpdf_json_input_open_error(input, error)
} else {
open_error_with_file(input, error.into())
}
})?;
if cli.json_input {
let mut pdf = job
.create_from_json_document(file, path_description(input))
.map_err(|error| json_error_with_file(input, Box::new(error)))?;
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
return run_job_inspection_on_pdf(cli, &mut job, &mut pdf, transform_options);
}
let mut options = pdf_open_options(cli.repair, &cli.password)?;
if cli.check {
options.suppress_warnings = true;
} else if cli.show_encryption {
options.suppress_warnings = cli.no_warn;
}
let mut pdf =
match job.open_with_description(BufReader::new(file), path_description(input), options) {
Ok(pdf) => pdf,
Err(error) => {
job.report_open_failure(&error)?;
return Err(error_with_file(input, actionable_password_error(error)));
}
};
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
run_job_inspection_on_pdf(cli, &mut job, &mut pdf, transform_options)
}
fn run_job_inspection_on_pdf<R: Read + Seek + 'static>(
cli: &Cli,
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
apply_top_level_inspection_transformations(
job,
pdf,
transform_options,
cli.verbose,
cli.remove_restrictions,
cli.coalesce_contents,
)?;
job.set_with_images(cli.with_images);
if cli.check {
job.set_show_encryption_key(cli.show_encryption_key);
return finish_check_job(job.check(pdf));
}
if cli.show_npages {
return finish_job_exit_status(job.show_npages(pdf)?);
}
if cli.show_pages {
return finish_job_exit_status(job.show_pages(pdf)?);
}
if cli.show_xref {
return finish_job_exit_status(job.show_xref(pdf)?);
}
if cli.show_encryption {
job.set_show_encryption_key(cli.show_encryption_key);
return finish_show_encryption(job, pdf, cli.password.password_is_hex_key);
}
Err("JSON input/update inspection mode is missing a consumer".into())
}
#[allow(clippy::too_many_arguments)]
fn run_json_document<R: Read + Seek>(
cli: &Cli,
runtime: &mut JsonJobRuntime<'_>,
pdf: &mut Pdf<R>,
json_version: i32,
test_json_schema: bool,
show_encryption_key: bool,
json_output_mode: bool,
stream_data: JsonStreamData,
json_keys: &[JsonKey],
json_objects: &[String],
) -> CliResult<()> {
let json_decode_level =
cli.decode_level
.map(DecodeLevel::from)
.unwrap_or(if json_output_mode {
DecodeLevel::None
} else {
DecodeLevel::Generalized
});
let output_path = runtime.output_path.filter(|path| *path != Path::new("-"));
let stream_prefix = cli.json_stream_prefix.as_deref().map(arg_parser::os_bytes);
let json_result = if let Some(path) = output_path {
let mut file = open_verified_json_output(runtime.input_identity, path)?;
let options = JsonJobOptions {
decode_level: json_decode_level,
stream_data,
stream_prefix: stream_prefix.as_deref(),
keys: json_keys,
objects: json_objects,
};
runtime.job.write_json_with_version(
pdf,
json_version,
test_json_schema,
json_output_mode,
show_encryption_key,
cli.verbose,
options,
JsonJobOutput::File {
filename: path,
writer: &mut file,
},
)
} else {
let options = JsonJobOptions {
decode_level: json_decode_level,
stream_data,
stream_prefix: stream_prefix.as_deref(),
keys: json_keys,
objects: json_objects,
};
runtime.job.write_json_with_version(
pdf,
json_version,
test_json_schema,
json_output_mode,
show_encryption_key,
cli.verbose,
options,
JsonJobOutput::Stdout(
runtime
.standard_output
.as_mut()
.expect("stdout writer prepared for JSON stdout"),
),
)
};
let stdout_finish = if output_path.is_none() {
Some(
runtime
.standard_output
.as_mut()
.expect("stdout writer prepared for JSON stdout")
.finish_pipeline(),
)
} else {
None
};
match json_result {
Ok(JobExitCode::Success) => {}
Ok(JobExitCode::Error) => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
Ok(JobExitCode::Warning) => {
return Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}));
}
Err(JsonJobError::Output(error)) => return Err(Box::new(Error::from(error))),
Err(JsonJobError::Usage(error)) => return Err(Box::new(error)),
Err(JsonJobError::Completion(error)) => return Err(Box::new(error)),
}
if let Some(result) = stdout_finish {
result?;
}
Ok(())
}
fn run_command(command: Commands, overlay_specs: &[OverlaySpec]) -> CliResult<()> {
match command {
Commands::Check(cmd) => run_check(
Some(cmd.input),
cmd.repair,
&cmd.password,
false,
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
),
Commands::CheckLinearization(cmd) => run_check_linearization(
Some(cmd.input),
false,
&PasswordArgs::default(),
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
),
Commands::Pages(cmd) => {
if cmd.show_npages {
run_show_npages(
Some(cmd.input),
cmd.repair,
&cmd.password,
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
)
} else {
run_show_pages(
Some(cmd.input),
cmd.repair,
&cmd.password,
false,
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
)
}
}
Commands::Qdf(cmd) => run_qdf(
Some(cmd.input),
Some(cmd.output),
cmd.repair,
&cmd.password,
cmd.preserve_unreferenced,
),
Commands::QdfFix(cmd) => run_qdf_fix(&cmd.input, &cmd.output),
Commands::ZlibFlate(cmd) => {
let whoami = progname();
let usage_name = format!("{whoami} zlib-flate");
run_zlib_flate(&cmd.modes, &whoami, &usage_name)
}
Commands::ShowEncryption(cmd) => {
run_show_encryption(
Some(cmd.input),
cmd.repair,
&cmd.password,
false,
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
)
}
Commands::IsEncrypted(cmd) => {
let password = PasswordArgs {
recovery: cmd.recovery,
..PasswordArgs::default()
};
run_is_encrypted(&cmd.input, cmd.repair, &password, false)
}
Commands::RequiresPassword(cmd) => {
run_requires_password(&cmd.input, cmd.repair, &cmd.password, false)
}
Commands::ShowEncryptionKey(cmd) => {
run_show_encryption_key(&cmd.input, cmd.repair, &cmd.password)
}
Commands::Rewrite(mut cmd) => {
cmd.password.verbose = cmd.verbose;
validate_collate_values(&cmd.page_ops.collate);
validate_keep_files_open_threshold(&cmd.page_ops)?;
let version_options = match parse_cli_version_options(
cmd.min_version.as_deref(),
cmd.force_version.as_deref(),
) {
Ok(options) => options,
Err(error) => {
emit_logger_error(format!("flpdf: {error}\n"));
std::process::exit(1);
}
};
let mut options = WriterOptions {
static_id: cmd.static_id,
deterministic_id: cmd.deterministic_id,
static_aes_iv: cmd.static_aes_iv,
no_original_object_ids: cmd.no_original_object_ids,
preserve_unreferenced_objects: cmd.preserve_unreferenced,
progress: cmd.progress,
verbose: cmd.verbose,
qdf: cmd.qdf,
password_mode: cmd.password.password_mode.into(),
allow_weak_crypto: cmd.password.allow_weak_crypto,
object_streams: cmd.object_streams.into(),
compress_streams: cmd.compress_streams.map(|mode| match mode {
CliYesNo::Yes => CompressStreams::Yes,
CliYesNo::No => CompressStreams::No,
}),
newline_before_endstream: cmd.newline_before_endstream.into(),
stream_data: cmd.stream_data.map(Into::into),
recompress_flate: cmd.recompress_flate,
compression_level: parse_compression_level(cmd.compression_level.as_deref())?,
..WriterOptions::default()
};
apply_cli_decode_level(&mut options, cmd.decode_level);
apply_cli_version_options(&mut options, &version_options);
apply_encryption_options(
&mut options,
EncryptionCliOptions {
encrypt: cmd.raw_encrypt.as_deref(),
encrypt_segments: None,
parsed_encrypt_segments: cmd.parsed_encrypt_segments.as_deref(),
copy_encryption: cmd.copy_encryption.as_deref(),
encryption_file_password: cmd.raw_encryption_file_password.as_deref(),
password_args: &cmd.password,
suppress_warnings: false,
last_mode: None,
},
);
let normalize_content = matches!(cmd.normalize_content, Some(CliYesNo::Yes));
options.content_normalization = normalize_content;
options.content_normalization_set = cmd.normalize_content.is_some();
let coalesce_contents = cmd.coalesce_contents;
let remove_unref = cmd.remove_unreferenced_resources;
let image_options = image_optimization_options(
cmd.keep_inline_images,
cmd.oi_min_width.as_deref(),
cmd.oi_min_height.as_deref(),
cmd.oi_min_area.as_deref(),
cmd.ii_min_bytes.as_deref(),
)?;
let image_transform_options = ImageTransformOptions::new(
cmd.externalize_inline_images,
cmd.optimize_images,
image_options,
);
if page_ops_active(&cmd.page_ops) {
if cmd.page_ops.pages.is_empty() && !overlay_specs.is_empty() {
emit_logger_error(
"flpdf: --overlay/--underlay is not applied with \
--rotate/--split-pages alone (no --pages); \
rerun with --pages or without the overlay\n",
);
std::process::exit(1);
}
if cmd.page_ops.pages.is_empty()
&& remove_unref != CliRemoveUnreferencedResources::Auto
{
emit_logger_error(
"flpdf: --remove-unreferenced-resources is not applied \
with --rotate/--split-pages alone; rerun without it \
or add --pages\n",
);
std::process::exit(1);
}
return if cmd.page_ops.empty && !cmd.page_ops.pages.is_empty() {
run_empty_page_extraction(
&cmd.output,
cmd.repair,
&cmd.password,
None,
&cmd.page_ops,
overlay_specs,
remove_unref,
cmd.remove_restrictions,
cmd.decrypt,
options,
cmd.linearize,
None,
image_transform_options,
cmd.coalesce_contents,
cmd.generate_appearances,
cmd.flatten_annotations,
cmd.flatten_rotation,
cmd.verbose,
false,
)
} else if !cmd.page_ops.pages.is_empty() {
run_page_extraction(
&cmd.input,
&cmd.output,
cmd.repair,
&cmd.password,
false,
None,
&cmd.page_ops,
overlay_specs,
remove_unref,
cmd.remove_restrictions,
cmd.decrypt,
options,
cmd.linearize,
None,
image_transform_options,
cmd.coalesce_contents,
cmd.generate_appearances,
cmd.flatten_annotations,
cmd.flatten_rotation,
cmd.verbose,
false,
)
} else {
run_rewrite_with_page_ops(
&cmd.input,
&cmd.output,
cmd.repair,
&cmd.password,
false,
None,
&cmd.page_ops,
remove_unref,
cmd.remove_restrictions,
cmd.decrypt,
options,
cmd.linearize,
None,
image_transform_options,
cmd.coalesce_contents,
cmd.generate_appearances,
cmd.flatten_annotations,
cmd.flatten_rotation,
cmd.verbose,
false,
)
};
}
run_rewrite(
Some(cmd.input),
Some(cmd.output),
false,
cmd.repair,
&cmd.password,
false,
None,
cmd.linearize,
None,
cmd.remove_restrictions,
cmd.decrypt,
normalize_content,
coalesce_contents,
remove_unref,
cmd.generate_appearances,
image_transform_options,
cmd.flatten_annotations,
cmd.flatten_rotation,
page_label_options(cmd.set_page_labels.as_deref(), cmd.remove_page_labels),
overlay_specs,
cmd.verbose,
false, options,
cmd.page_ops.empty,
)
}
}
}
#[allow(clippy::too_many_arguments)]
fn run_check(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
show_encryption_key: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(no_warn);
job.set_show_encryption_key(show_encryption_key);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_check_job(job.check(&mut pdf));
}
let input = input.ok_or_else(missing_input_usage_error)?;
let file = File::open(&input).map_err(|error| open_error_with_file(&input, error.into()))?;
let mut job = new_cli_job(no_warn);
job.set_show_encryption_key(show_encryption_key);
let mut options = pdf_open_options(repair, password)?;
options.suppress_warnings = no_warn;
let mut pdf =
match job.open_with_description(BufReader::new(file), path_description(&input), options) {
Ok(pdf) => pdf,
Err(error) => {
return Err(error_with_file(&input, actionable_password_error(error)));
}
};
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_check_job(job.check(&mut pdf))
}
fn run_check_linearization(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(no_warn);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_job_exit_status(job.show_linearization(&mut pdf)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let file = File::open(&input).map_err(|error| open_error_with_file(&input, error.into()))?;
let mut job = new_cli_job(no_warn);
let options = pdf_open_options(repair, password)?;
let mut pdf = job
.open_with_description(BufReader::new(file), path_description(&input), options)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_job_exit_status(job.check_linearization(&mut pdf)?)
}
struct EncryptionCliOptions<'a> {
encrypt: Option<&'a [Vec<u8>]>,
encrypt_segments: Option<&'a [Vec<Vec<u8>>]>,
parsed_encrypt_segments: Option<&'a [ParsedEncryptSegment]>,
copy_encryption: Option<&'a std::path::Path>,
encryption_file_password: Option<&'a [u8]>,
password_args: &'a PasswordArgs,
suppress_warnings: bool,
last_mode: Option<EncryptionMode>,
}
fn apply_encryption_options(options: &mut WriterOptions, inputs: EncryptionCliOptions<'_>) {
let EncryptionCliOptions {
encrypt,
encrypt_segments,
parsed_encrypt_segments,
copy_encryption,
encryption_file_password,
password_args,
suppress_warnings,
last_mode,
} = inputs;
let parsed_encrypt = parsed_encrypt_segments
.and_then(|segments| segments.last().cloned())
.or_else(|| {
encrypt_segments.map(|segments| {
let mut parsed = None;
for segment in segments {
match parse_encrypt_segment(segment) {
Ok(value) => parsed = Some(value),
Err(error) => {
emit_logger_error(format!("{}: {error}\n", progname()));
std::process::exit(2);
}
}
}
parsed.expect("non-empty encrypt segment list")
})
});
match last_mode.or_else(|| {
if encrypt.is_some() {
Some(EncryptionMode::Encrypt)
} else if copy_encryption.is_some() {
Some(EncryptionMode::CopyEncryption)
} else {
None
}
}) {
Some(EncryptionMode::Encrypt) => {
let parsed = parsed_encrypt.or_else(|| {
encrypt.map(|encrypt| match parse_encrypt_segment(encrypt) {
Ok(value) => value,
Err(error) => {
emit_logger_error(format!("{}: {error}\n", progname()));
std::process::exit(2);
}
})
});
if let Some(parsed) = parsed {
if parsed.accessibility_warning {
emit_logger_error(format!(
"{}: -accessibility=n is ignored for modern encryption formats\n",
progname()
));
}
options.encrypt = Some(parsed.params);
}
}
Some(EncryptionMode::CopyEncryption) => {
if let Some(donor_path) = copy_encryption {
match build_copy_encryption_source(
donor_path,
encryption_file_password,
password_args,
suppress_warnings,
) {
Ok(src) => {
if let Some(src) = src {
options.copy_encryption = Some(src);
} else {
options.preserve_encryption = false;
}
}
Err(e) => {
emit_logger_error(format!("flpdf: {e}\n"));
std::process::exit(2);
}
}
}
}
Some(EncryptionMode::Decrypt) | None => {}
}
}
fn build_copy_encryption_source(
path: &std::path::Path,
password: Option<&[u8]>,
password_args: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Option<CopyEncryptionSource>> {
let file =
File::open(path).map_err(|e| format!("--copy-encryption: cannot open {:?}: {e}", path))?;
let reader = BufReader::new(file);
let mut donor_password = password_args.clone();
donor_password.set_password_bytes(password.map(ToOwned::to_owned));
donor_password.password_file = None;
let opts = pdf_open_options(true, &donor_password)
.map_err(|error| format!("--copy-encryption: failed to configure {:?}: {error}", path))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(suppress_warnings);
let mut donor = job
.open_with_description(reader, path_description(path), opts)
.map_err(|e| format!("--copy-encryption: failed to open {:?}: {e}", path))?;
donor
.root_handle()
.map_err(|e| format!("--copy-encryption: failed to open {:?}: {e}", path))?;
let Some(version) = donor.encryption_version() else {
return Ok(None);
};
let length_bits = donor.encryption_length_bits().ok_or_else(|| {
format!(
"--copy-encryption: donor {:?} has no encryption key length",
path
)
})?;
let revision = donor.encryption_revision().ok_or_else(|| {
format!(
"--copy-encryption: donor {:?} has no encryption revision",
path
)
})?;
let supported = match (version, revision) {
(1, 2) => length_bits == 40,
(2, 2 | 3) => (40..=128).contains(&length_bits) && length_bits % 8 == 0,
(4, 4) => length_bits == 128,
(5, 5 | 6) => length_bits == 256,
_ => false,
};
if !supported {
return Err(format!(
"--copy-encryption: donor {:?} uses unsupported Standard handler V={} R={} length={}",
path, version, revision, length_bits,
)
.into());
}
let file_key: Vec<u8> = donor.encryption_file_key().ok_or_else(|| {
format!(
"--copy-encryption: failed to recover donor file key for {:?} \
(wrong --encryption-file-password?)",
path
)
})?;
let Some(mut source) = donor.writer_copy_encryption_source()? else {
return Ok(None);
};
source.file_key = file_key;
source.object_key_alg = if version >= 4 {
ObjectKeyAlg::Aes
} else {
ObjectKeyAlg::Rc4
};
Ok(Some(source))
}
fn parse_perm_yn(flag: &str, val: &str) -> CliResult<bool> {
match val {
"y" => Ok(true),
"n" => Ok(false),
other => Err(format!("{flag} must be y or n (got {other:?})").into()),
}
}
#[derive(Debug, Clone)]
struct ParsedEncryptSegment {
params: EncryptParams,
accessibility_warning: bool,
}
trait RawCliArg {
fn raw_bytes(&self) -> Vec<u8>;
fn os_string(&self) -> OsString;
}
impl RawCliArg for String {
fn raw_bytes(&self) -> Vec<u8> {
self.as_bytes().to_vec()
}
fn os_string(&self) -> OsString {
OsString::from(self)
}
}
impl RawCliArg for OsString {
fn raw_bytes(&self) -> Vec<u8> {
arg_parser::os_bytes(self)
}
fn os_string(&self) -> OsString {
self.clone()
}
}
impl RawCliArg for Vec<u8> {
fn raw_bytes(&self) -> Vec<u8> {
self.clone()
}
fn os_string(&self) -> OsString {
arg_parser::os_string_from_bytes(self)
}
}
impl RawCliArg for arg_parser::RawArg {
fn raw_bytes(&self) -> Vec<u8> {
self.as_bytes().to_vec()
}
fn os_string(&self) -> OsString {
self.as_os_str().to_os_string()
}
}
fn encrypt_option_table_name(key_len: Option<u32>) -> &'static str {
match key_len {
Some(40) => "40-bit encryption",
Some(128) => "128-bit encryption",
Some(256) => "256-bit encryption",
None | Some(_) => "encryption",
}
}
fn encryption_option_table_accepts(key_len: Option<u32>, name: &str) -> bool {
match key_len {
None => matches!(name, "user-password" | "owner-password" | "bits"),
Some(40) => matches!(name, "extract" | "annotate" | "print" | "modify"),
Some(128) => matches!(
name,
"cleartext-metadata"
| "force-V4"
| "accessibility"
| "extract"
| "print"
| "assemble"
| "annotate"
| "form"
| "modify-other"
| "modify"
| "use-aes"
),
Some(256) => matches!(
name,
"cleartext-metadata"
| "force-R5"
| "allow-insecure"
| "accessibility"
| "extract"
| "print"
| "assemble"
| "annotate"
| "form"
| "modify-other"
| "modify"
),
Some(_) => false,
}
}
fn unrecognized_encrypt_argument(token: &str, key_len: Option<u32>) -> UsageError {
UsageError::new(format!(
"unrecognized argument {token} ({} options must be terminated with --)",
encrypt_option_table_name(key_len)
))
}
#[derive(Debug, Clone)]
struct EncryptSubFlag {
original: Vec<u8>,
canonical: Vec<u8>,
}
struct EncryptSegmentCallbackState {
positional: Vec<Vec<u8>>,
dashed_mode: bool,
positional_mode: bool,
user_password: Option<Vec<u8>>,
owner_password: Option<Vec<u8>>,
key_len: Option<u32>,
key_len_seen: bool,
subflags: Vec<EncryptSubFlag>,
}
impl EncryptSegmentCallbackState {
fn new() -> Self {
Self {
positional: Vec::new(),
dashed_mode: false,
positional_mode: false,
user_password: None,
owner_password: None,
key_len: None,
key_len_seen: false,
subflags: Vec::new(),
}
}
fn push(&mut self, original: &[u8], canonical: &[u8]) -> CliResult<()> {
let token_text = String::from_utf8_lossy(original);
let equal = canonical.iter().position(|byte| *byte == b'=');
let (raw_name, attached) = match equal {
Some(position) => (&canonical[..position], Some(&canonical[position + 1..])),
None => (canonical, None),
};
let option_name = segment_option_name(raw_name);
if let Some(name) = option_name {
if !encryption_option_table_accepts(self.key_len, name) {
return Err(unrecognized_encrypt_argument(&token_text, self.key_len).into());
}
if matches!(name, "user-password" | "owner-password" | "bits") {
if self.positional_mode {
return Err(Box::new(UsageError::new(
"positional and dashed encryption arguments may not be mixed",
)));
}
let value = attached.ok_or_else(|| {
let parameter = match name {
"user-password" => "user_password",
"owner-password" => "owner_password",
"bits" => "{40,128,256}",
_ => unreachable!("name was matched above"),
};
Box::new(UsageError::new(format!(
"--{name} must be given as --{name}={parameter}"
))) as Box<dyn std::error::Error>
})?;
self.dashed_mode = true;
match name {
"user-password" => self.user_password = Some(value.to_vec()),
"owner-password" => self.owner_password = Some(value.to_vec()),
"bits" => {
self.key_len =
Some(parse_encrypt_key_len(&String::from_utf8_lossy(value))?);
self.key_len_seen = true;
}
_ => unreachable!("name was matched above"),
}
return Ok(());
}
}
if canonical.starts_with(b"-") && canonical != b"-" {
if self.dashed_mode && !self.key_len_seen {
return Err(unrecognized_encrypt_argument(&token_text, self.key_len).into());
}
if !self.dashed_mode && self.positional.len() < 3 {
return Err(unrecognized_encrypt_argument(&token_text, self.key_len).into());
}
self.subflags.push(EncryptSubFlag {
original: original.to_vec(),
canonical: canonical.to_vec(),
});
return Ok(());
}
if self.dashed_mode {
return Err(Box::new(UsageError::new(
"positional and dashed encryption arguments may not be mixed",
)));
}
if self.positional.len() < 3 {
self.positional_mode = true;
self.positional.push(canonical.to_vec());
if self.positional.len() == 3 {
self.key_len = Some(parse_encrypt_key_len(&String::from_utf8_lossy(canonical))?);
}
return Ok(());
}
Err(unrecognized_encrypt_argument(&token_text, self.key_len).into())
}
fn finish(self) -> CliResult<ParsedEncryptSegment> {
let EncryptSegmentCallbackState {
positional,
dashed_mode,
user_password,
owner_password,
key_len,
subflags,
..
} = self;
finish_encrypt_segment(
positional,
dashed_mode,
user_password,
owner_password,
key_len,
subflags,
)
}
}
fn parse_encrypt_segment<T: RawCliArg>(tokens: &[T]) -> CliResult<ParsedEncryptSegment> {
let mut parser = EncryptSegmentCallbackState::new();
for token in tokens {
let token_bytes = token.raw_bytes();
parser.push(&token_bytes, &token_bytes)?;
}
parser.finish()
}
fn finish_encrypt_segment(
positional: Vec<Vec<u8>>,
dashed_mode: bool,
user_password: Option<Vec<u8>>,
owner_password: Option<Vec<u8>>,
key_len: Option<u32>,
subflags: Vec<EncryptSubFlag>,
) -> CliResult<ParsedEncryptSegment> {
let (user_password, owner_password, key_len) = if dashed_mode {
if key_len.is_none() && !subflags.is_empty() {
return Err(Box::new(UsageError::new(
"--encrypt key length is required before encryption options",
)));
}
(
user_password.unwrap_or_default(),
owner_password.unwrap_or_default(),
key_len.ok_or_else(|| {
Box::new(UsageError::new("encryption key length is required"))
as Box<dyn std::error::Error>
})?,
)
} else {
if positional.len() < 3 {
return Err(Box::new(UsageError::new(
"encryption key length is required",
)));
}
let key_len = key_len.ok_or_else(|| {
Box::new(UsageError::new("encryption key length is required"))
as Box<dyn std::error::Error>
})?;
(positional[0].clone(), positional[1].clone(), key_len)
};
let mut use_aes = None;
let mut force_v4 = false;
let mut force_r5 = false;
let mut allow_insecure = false;
let mut perms = PermissionsConfig::default();
let mut r2_permissions = R2PermissionsConfig::default();
let mut cleartext_metadata = false;
let mut accessibility_explicitly_disabled = false;
for token in &subflags {
let token_text = String::from_utf8_lossy(&token.original);
let token_bytes = &token.canonical;
let equal = token_bytes.iter().position(|byte| *byte == b'=');
let (raw_flag, value_bytes) = match equal {
Some(position) => (&token_bytes[..position], &token_bytes[position + 1..]),
None => (token_bytes.as_slice(), b"".as_slice()),
};
let flag = raw_flag
.strip_prefix(b"--")
.or_else(|| raw_flag.strip_prefix(b"-"))
.and_then(|flag| std::str::from_utf8(flag).ok())
.unwrap_or("");
let value = match std::str::from_utf8(value_bytes) {
Ok(value) => value,
Err(_) => return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into()),
};
match flag {
"use-aes" => {
if key_len != 128 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
use_aes = Some(parse_perm_yn(flag, value)?);
}
"force-V4" => {
if key_len != 128 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
force_v4 = true;
}
"force-R5" => {
if key_len != 256 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
force_r5 = true;
}
"allow-insecure" => {
if key_len != 256 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
allow_insecure = true;
}
"cleartext-metadata" => {
if !matches!(key_len, 128 | 256) {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
cleartext_metadata = true;
}
"print" => {
if key_len == 40 {
r2_permissions.print = parse_perm_yn(flag, value)?;
} else {
perms.print = match value {
"full" => PrintPermission::High,
"low" => PrintPermission::Low,
"none" => PrintPermission::None,
other => {
return Err(format!(
"--print must be full, low, or none (got {other:?})"
)
.into());
}
};
}
}
"modify" => {
if key_len == 40 {
r2_permissions.modify = parse_perm_yn(flag, value)?;
} else {
let (other, annotate, forms, assemble) = match value {
"all" => (true, true, true, true),
"annotate" => (false, true, true, true),
"form" => (false, false, true, true),
"assembly" => (false, false, false, true),
"none" => (false, false, false, false),
other => {
return Err(format!(
"--modify must be all, annotate, form, assembly, or none (got {other:?})"
)
.into());
}
};
perms.modify_contents = other;
perms.annotate = annotate;
perms.fill_forms = forms;
perms.assemble = assemble;
}
}
"extract" => {
let value = parse_perm_yn(flag, value)?;
if key_len == 40 {
r2_permissions.extract = value;
} else {
perms.extract = value;
}
}
"annotate" => {
let value = parse_perm_yn(flag, value)?;
if key_len == 40 {
r2_permissions.annotate = value;
} else {
perms.annotate = value;
}
}
"form" => {
if key_len == 40 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
perms.fill_forms = parse_perm_yn(flag, value)?;
}
"assemble" => {
if key_len == 40 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
perms.assemble = parse_perm_yn(flag, value)?;
}
"accessibility" => {
if key_len == 40 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
perms.accessibility = parse_perm_yn(flag, value)?;
accessibility_explicitly_disabled = value == "n";
}
"modify-other" => {
if key_len == 40 {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
perms.modify_contents = parse_perm_yn(flag, value)?;
}
_other => {
return Err(unrecognized_encrypt_argument(&token_text, Some(key_len)).into());
}
}
}
if key_len == 40 && (force_r5 || allow_insecure || cleartext_metadata) {
return Err("--encrypt KEY-LEN=40 does not accept this encryption option".into());
}
if key_len == 128 && (force_r5 || allow_insecure) {
return Err("--encrypt KEY-LEN=128 does not accept this encryption option".into());
}
if key_len == 256 && (force_v4 || use_aes.is_some()) {
return Err("--encrypt KEY-LEN=256 does not accept --force-V4 or --use-aes".into());
}
let method = match key_len {
40 => EncryptMethod::V1Rc440,
128 if force_v4 || cleartext_metadata => {
if use_aes.unwrap_or(false) {
EncryptMethod::V4Aes128
} else {
EncryptMethod::V4Rc4128
}
}
128 if use_aes == Some(true) => EncryptMethod::V4Aes128,
128 => EncryptMethod::V2Rc4128,
256 if force_r5 => EncryptMethod::V5R5Aes256,
256 => EncryptMethod::V5R6Aes256,
_ => unreachable!("key length was validated"),
};
if cleartext_metadata
&& !matches!(
method,
EncryptMethod::V4Aes128
| EncryptMethod::V4Rc4128
| EncryptMethod::V5R5Aes256
| EncryptMethod::V5R6Aes256
)
{
return Err("--cleartext-metadata requires V=4 or V=5".into());
}
let params = match method {
EncryptMethod::V1Rc440 => {
let mut params = EncryptParams::rc4(method, user_password, owner_password);
params.r2_permissions = r2_permissions;
params
}
EncryptMethod::V2Rc4128 => {
let mut params = EncryptParams::rc4(method, user_password, owner_password);
params.permissions = perms;
params
}
EncryptMethod::V4Rc4128 | EncryptMethod::V4Aes128 => {
let mut params = if method == EncryptMethod::V4Aes128 {
EncryptParams::v4_aes128(user_password, owner_password)
} else {
EncryptParams::rc4(method, user_password, owner_password)
};
params.permissions = perms;
params.permissions.accessibility = true;
params.encrypt_metadata = !cleartext_metadata;
params
}
EncryptMethod::V5R5Aes256 | EncryptMethod::V5R6Aes256 => {
if owner_password.is_empty() && !user_password.is_empty() && !allow_insecure {
return Err(
"A PDF with a non-empty user password and an empty owner password \
encrypted with a 256-bit key is insecure as it can be opened without \
a password. If you really want to do this, you must also give the \
--allow-insecure option before the -- that follows --encrypt."
.into(),
);
}
let mut params = if method == EncryptMethod::V5R5Aes256 {
EncryptParams::v5_r5(user_password, owner_password)
} else {
EncryptParams::v5_r6(user_password, owner_password)
};
params.permissions = perms;
params.permissions.accessibility = true;
params.encrypt_metadata = !cleartext_metadata;
params
}
};
Ok(ParsedEncryptSegment {
params,
accessibility_warning: accessibility_explicitly_disabled
&& matches!(
method,
EncryptMethod::V4Rc4128
| EncryptMethod::V4Aes128
| EncryptMethod::V5R5Aes256
| EncryptMethod::V5R6Aes256
),
})
}
fn parse_encrypt_key_len(value: &str) -> CliResult<u32> {
match value {
"40" => Ok(40),
"128" => Ok(128),
"256" => Ok(256),
_ => Err(UsageError::new("encryption key length must be 40, 128, or 256").into()),
}
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite(
input: Option<PathBuf>,
output: Option<PathBuf>,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
linearize: bool,
linearize_pass1: Option<&Path>,
remove_restrictions: bool,
decrypt: bool,
normalize_content: bool,
coalesce_contents: bool,
_remove_unref: CliRemoveUnreferencedResources,
generate_appearances: bool,
image_options: ImageTransformOptions,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
page_labels: PageLabelOptions,
overlay_specs: &[OverlaySpec],
verbose: bool,
no_warn: bool,
options: WriterOptions,
empty: bool,
) -> CliResult<()> {
if empty {
if replace_input && (input.is_some() || output.is_some()) {
return Err(UsageError::new(
"replace-input can't be used since output file has already been given",
)
.into());
}
if replace_input {
return Err(UsageError::new("--replace-input may not be used with --empty").into());
}
let output = match (input, output) {
(Some(output), None) | (None, Some(output)) => output,
(Some(_), Some(extra)) => {
return Err(UsageError::new(format!("unknown argument {}", extra.display())).into())
}
(None, None) => return Err(missing_output_usage_error().into()),
};
let mut job = new_cli_job(no_warn);
let pdf = create_empty_primary_document(&mut job, update_from_json)?;
return run_rewrite_opened(
pdf,
Path::new("empty PDF"),
&output,
false,
repair,
password,
linearize,
linearize_pass1,
remove_restrictions,
decrypt,
normalize_content,
coalesce_contents,
_remove_unref,
generate_appearances,
image_options,
flatten_annotations_mode,
flatten_rotation,
page_labels,
overlay_specs,
verbose,
no_warn,
options,
);
}
let input = input.ok_or_else(missing_input_usage_error)?;
if replace_input && output.is_some() {
return Err(UsageError::new(
"replace-input can't be used since output file has already been given",
)
.into());
}
let output = if replace_input {
input.clone()
} else {
output.ok_or_else(missing_output_usage_error)?
};
if !replace_input {
reject_same_job_output(&input, &output)?;
}
run_rewrite_with_qpdf_job(
&input,
&output,
replace_input,
repair,
password,
json_input,
update_from_json,
linearize,
linearize_pass1,
remove_restrictions,
decrypt,
normalize_content,
coalesce_contents,
generate_appearances,
image_options,
flatten_annotations_mode,
flatten_rotation,
page_labels,
overlay_specs,
verbose,
no_warn,
options,
&[],
None,
_remove_unref.into(),
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_operations_with_qpdf_job(
args: &Cli,
options: WriterOptions,
image_options: ImageTransformOptions,
overlay_specs: &[OverlaySpec],
) -> CliResult<()> {
let (input, output) = if args.page_ops.empty {
if args.replace_input && (args.input.is_some() || args.output.is_some()) {
return Err(UsageError::new(
"replace-input can't be used since output file has already been given",
)
.into());
}
if args.replace_input {
return Err(UsageError::new("--replace-input may not be used with --empty").into());
}
match (args.input.clone(), args.output.clone()) {
(Some(output), None) | (None, Some(output)) => (None, output),
(Some(_), Some(_)) => {
return Err(UsageError::new(
"empty input can't be used since input file has already been given",
)
.into())
}
(None, None) => return Err(missing_output_usage_error().into()),
}
} else {
let input = args.input.clone().ok_or_else(missing_input_usage_error)?;
let output = if args.replace_input {
input.clone()
} else {
args.output.clone().ok_or_else(missing_output_usage_error)?
};
if !args.replace_input && args.page_ops.split_pages.is_none() {
reject_same_job_output(&input, &output)?;
}
(Some(input), output)
};
let input_name = input.clone().unwrap_or_else(|| PathBuf::from("empty PDF"));
let page_labels = page_label_options(args.set_page_labels.as_deref(), args.remove_page_labels);
let linearize_normalization =
args.linearize && options.content_normalization_set && options.content_normalization;
let job_options = options;
let mut job = configure_rewrite_job(
&input_name,
&output,
args.replace_input,
&args.password,
args.linearize,
args.linearize_pass1.as_deref(),
args.remove_restrictions,
image_options,
args.generate_appearances,
args.flatten_annotations,
args.coalesce_contents,
args.flatten_rotation,
&page_labels,
overlay_specs,
args.verbose,
args.no_warn,
&job_options,
)?;
if let Some(input) = input {
if !args.replace_input {
job.set_input_file(input)?;
}
} else {
job.config().empty_input()?;
}
{
let mut configuration = job.config();
if args.json_input {
configuration.json_input();
}
if let Some(update_from_json) = args.update_from_json.as_ref() {
configuration.update_from_json(update_from_json.clone());
}
}
let input_options = pdf_open_options(args.repair, &args.password)?;
job.set_password(input_options.password);
configure_keep_files_open(&mut job, &args.page_ops)?;
let raw_specs = if args.page_ops.pages.is_empty() {
Vec::new()
} else {
configured_page_specs(&args.page_ops)?
};
if (args.json_input || args.update_from_json.is_some()) && !args.page_ops.empty {
let primary = args.input.as_ref().ok_or_else(missing_input_usage_error)?;
let primary_canonical = std::fs::canonicalize(primary).unwrap_or_else(|_| primary.clone());
let has_external_source = raw_specs.iter().any(|spec| {
if spec.file_token == OsStr::new(".") {
return false;
}
let path = PathBuf::from(&spec.file_token);
let canonical = std::fs::canonicalize(&path).unwrap_or(path);
canonical != primary_canonical
});
if has_external_source {
return Err(
"--pages: cross-document page merge is not supported at this layer \
(an explicit --pages source differs from the --json-input/\
--update-from-json primary input). Single-document extraction \
('.' or the primary input's own path) is supported; cross-doc \
merge with a JSON-created/updated primary is tracked in a \
separate issue."
.into(),
);
}
}
if args.page_ops.empty
&& raw_specs
.iter()
.any(|spec| spec.file_token == OsStr::new("."))
{
return Err("--pages: '.' cannot refer to a primary input with --empty".into());
}
{
let mut configuration = job.config();
if let Some(path) = args.copy_encryption.as_ref() {
let password = args
.raw_encryption_file_password
.clone()
.or_else(|| {
args.encryption_file_password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
})
.unwrap_or_default();
configuration.copy_encryption(path.clone(), password);
}
for spec in raw_specs {
let password = spec.raw_password.or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
});
configuration.add_page_spec(PathBuf::from(spec.file_token), &spec.range, password)?;
}
for parameter in &args.page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
for parameter in &args.page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
if let Some(parameter) = args.page_ops.split_pages.as_deref() {
configuration.split_pages(parameter.as_bytes())?;
}
if args.coalesce_contents {
configuration.coalesce_contents();
}
configuration.remove_unreferenced_resources(args.remove_unreferenced_resources.into());
}
let writer_configuration = writer_configuration_unnormalized(
&job_options,
args.linearize,
args.linearize_pass1.as_deref(),
)?;
job.set_writer_configuration(writer_configuration);
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
if linearize_normalization {
let warnings = normalize_page_contents(&mut pdf)?;
if !warnings.is_empty() {
job.record_warnings();
if !args.no_warn {
for warning in warnings {
emit_content_normalization_warnings(&input_name, warning)?;
}
}
}
}
match job.write_qpdf(&mut pdf) {
Ok(()) => finish_job_exit_status(job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite_with_qpdf_job(
input: &Path,
output: &Path,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
linearize: bool,
linearize_pass1: Option<&Path>,
remove_restrictions: bool,
decrypt: bool,
normalize_content: bool,
coalesce_contents: bool,
generate_appearances: bool,
image_options: ImageTransformOptions,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
page_labels: PageLabelOptions,
overlay_specs: &[OverlaySpec],
verbose: bool,
no_warn: bool,
options: WriterOptions,
rotate_args: &[OsString],
split_pages: Option<&str>,
remove_unreferenced_resources: RemoveUnreferencedResources,
) -> CliResult<()> {
let linearize_normalization =
linearize && normalize_content && options.content_normalization_set;
let job_options = options.clone();
let mut job = configure_rewrite_job(
input,
output,
replace_input,
password,
linearize,
linearize_pass1,
remove_restrictions,
image_options,
generate_appearances,
flatten_annotations_mode,
coalesce_contents,
flatten_rotation,
&page_labels,
overlay_specs,
verbose,
no_warn,
&job_options,
)?;
if !replace_input {
job.set_input_file(input.to_path_buf())?;
}
let input_options = pdf_open_options(repair, password)?;
job.set_password(input_options.password);
{
let mut configuration = job.config();
if json_input {
configuration.json_input();
}
if let Some(path) = update_from_json {
configuration.update_from_json(path.to_path_buf());
}
for parameter in rotate_args {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
if let Some(parameter) = split_pages {
configuration.split_pages(parameter.as_bytes())?;
configuration.remove_unreferenced_resources(remove_unreferenced_resources);
}
}
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
if linearize_normalization {
let warnings = normalize_page_contents(&mut pdf)?;
if !warnings.is_empty() {
job.record_warnings();
if !no_warn {
for warning in warnings {
emit_content_normalization_warnings(input, warning)?;
}
}
}
}
let mut writer_options = job_options;
if decrypt {
writer_options.preserve_encryption = false;
}
job.set_writer_configuration(writer_configuration_unnormalized(
&writer_options,
linearize,
linearize_pass1,
)?);
match job.write_qpdf(&mut pdf) {
Ok(()) => finish_job_exit_status(job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
#[allow(clippy::too_many_arguments)]
fn configure_rewrite_job(
input: &Path,
output: &Path,
replace_input: bool,
password: &PasswordArgs,
linearize: bool,
linearize_pass1: Option<&Path>,
remove_restrictions: bool,
image_options: ImageTransformOptions,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
coalesce_contents: bool,
flatten_rotation: bool,
page_labels: &PageLabelOptions,
overlay_specs: &[OverlaySpec],
verbose: bool,
no_warn: bool,
options: &WriterOptions,
) -> CliResult<QPDFJob> {
let mut job = new_cli_job(no_warn);
job.set_input_name_bytes(path_description(input));
if replace_input {
job.set_input_file(input.to_path_buf())?;
job.config().replace_input()?;
} else {
job.set_output_file(output.to_path_buf())?;
}
job.set_suppress_recovery(password.recovery.suppress_recovery);
job.set_ignore_xref_streams(password.recovery.ignore_xref_streams);
job.set_password_mode(password.password_mode.into());
job.set_password_is_hex_key(password.password_is_hex_key);
job.set_suppress_password_recovery(password.suppress_password_recovery);
job.set_allow_weak_crypto(options.allow_weak_crypto);
job.set_verbose(verbose);
job.set_progress(options.progress);
job.set_linearization(linearize, linearize_pass1.map(Path::to_path_buf));
{
let mut configuration = job.config();
if remove_restrictions {
configuration.remove_restrictions();
}
if image_options.optimize_images {
let mut optimization = image_options.image_options;
if image_options.externalize_inline_images {
optimization.keep_inline_images = false;
}
configuration.optimize_images(optimization);
} else if image_options.externalize_inline_images {
configuration.externalize_inline_images(image_options.image_options.inline_min_bytes);
}
if generate_appearances {
configuration.generate_appearances();
}
if let Some(mode) = flatten_annotations_mode {
configuration.flatten_annotations(FlattenAnnotationsMode::from(mode));
}
if coalesce_contents {
configuration.coalesce_contents();
}
if flatten_rotation {
configuration.flatten_rotation();
}
if let Some(specs) = page_labels.set.as_ref().filter(|specs| !specs.is_empty()) {
configuration.set_page_labels(specs.iter().map(Vec::as_slice))?;
}
if page_labels.remove {
configuration.remove_page_labels();
}
for spec in overlay_specs {
let password = spec
.raw_password
.clone()
.or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password.as_os_str()))
})
.unwrap_or_default();
let from = match spec.from.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(range) => PageRange::parse_numrange(range)?,
};
let to = match spec.to.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(range) => PageRange::parse_numrange(range)?,
};
let repeat = match spec.repeat.as_deref() {
None | Some("") => None,
Some(range) => Some(PageRange::parse_numrange(range)?),
};
match spec.kind {
OverlayKind::Overlay => {
configuration.overlay(PathBuf::from(&spec.file), password, from, to, repeat)
}
OverlayKind::Underlay => {
configuration.underlay(PathBuf::from(&spec.file), password, from, to, repeat)
}
};
}
}
Ok(job)
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite_opened<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
input: &Path,
output: &Path,
replace_input: bool,
_repair: bool,
_password: &PasswordArgs,
linearize: bool,
linearize_pass1: Option<&Path>,
remove_restrictions: bool,
_decrypt: bool,
normalize_content: bool,
coalesce_contents: bool,
_remove_unref: CliRemoveUnreferencedResources,
generate_appearances: bool,
image_options: ImageTransformOptions,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
page_labels: PageLabelOptions,
overlay_specs: &[OverlaySpec],
verbose: bool,
no_warn: bool,
options: WriterOptions,
) -> CliResult<()> {
let linearize_normalization =
linearize && normalize_content && options.content_normalization_set;
let job_options = options.clone();
let mut job = configure_rewrite_job(
input,
output,
replace_input,
_password,
linearize,
linearize_pass1,
remove_restrictions,
image_options,
generate_appearances,
flatten_annotations_mode,
coalesce_contents,
flatten_rotation,
&page_labels,
overlay_specs,
verbose,
no_warn,
&job_options,
)?;
apply_transformations_for_cli(&mut job, &mut pdf)?;
if linearize_normalization {
let warnings = normalize_page_contents(&mut pdf)?;
if !warnings.is_empty() {
job.record_warnings();
if !no_warn {
for warning in warnings {
emit_content_normalization_warnings(input, warning)?;
}
}
}
}
let mut writer_options = job_options;
if _decrypt {
writer_options.preserve_encryption = false;
}
job.set_writer_configuration(writer_configuration_unnormalized(
&writer_options,
linearize,
linearize_pass1,
)?);
match job.write_qpdf(&mut pdf) {
Ok(()) => finish_job_exit_status(job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
#[derive(Debug, Clone)]
struct PageSegmentSpec {
file_token: OsString,
password: Option<OsString>,
raw_password: Option<Vec<u8>>,
range: String,
}
#[derive(Default)]
struct PagesSegmentParser {
specs: Vec<PageSegmentSpec>,
called_pages_file: bool,
called_pages_range: bool,
}
impl PagesSegmentParser {
fn push(&mut self, original: &[u8], canonical: &[u8], file_token: OsString) -> CliResult<()> {
if let Some(path) = canonical.strip_prefix(b"--file=") {
self.specs.push(PageSegmentSpec {
file_token: arg_parser::os_string_from_bytes(path),
password: None,
raw_password: None,
range: String::new(),
});
self.called_pages_range = false;
return Ok(());
}
if let Some(pw) = canonical.strip_prefix(b"--password=") {
let cur = self.specs.last_mut().ok_or_else(|| {
Box::new(UsageError::new(
"in --pages, --password must follow a file name",
)) as Box<dyn std::error::Error>
})?;
if cur.password.is_some() {
return Err(Box::new(UsageError::new(
"--password already specified for this file",
)));
}
cur.password = Some(arg_parser::os_string_from_bytes(pw));
cur.raw_password = Some(pw.to_vec());
return Ok(());
}
if let Some(range) = canonical.strip_prefix(b"--range=") {
let cur = self.specs.last_mut().ok_or_else(|| {
Box::new(UsageError::new("in --range must follow a file name"))
as Box<dyn std::error::Error>
})?;
if !cur.range.is_empty() {
return Err(Box::new(UsageError::new(
"--range already specified for this file",
)));
}
cur.range = String::from_utf8(range.to_vec())
.map_err(|_| UsageError::new("--range must be valid UTF-8"))?;
return Ok(());
}
if canonical.starts_with(b"-") && canonical != b"-" {
let name = segment_option_name(canonical);
if let Some(name) = name {
let parameter = match name {
"file" => Some("file"),
"range" => Some("page-range"),
"password" => Some("password"),
_ => None,
};
if !canonical.contains(&b'=') {
if let Some(parameter) = parameter {
return Err(Box::new(UsageError::new(format!(
"--{name} must be given as --{name}={parameter}"
))));
}
}
}
return Err(Box::new(UsageError::new(format!(
"unrecognized argument {} (pages options must be terminated with --)",
String::from_utf8_lossy(original)
))));
}
if !self.called_pages_file {
self.specs.push(PageSegmentSpec {
file_token,
password: None,
raw_password: None,
range: String::new(),
});
self.called_pages_file = true;
return Ok(());
}
if self.called_pages_range {
self.specs.push(PageSegmentSpec {
file_token,
password: None,
raw_password: None,
range: String::new(),
});
self.called_pages_range = false;
return Ok(());
}
match parse_numrange(canonical, 0) {
Ok(_) => {
let range_bytes = canonical
.split(|byte| *byte == 0)
.next()
.unwrap_or(canonical);
let range = String::from_utf8_lossy(range_bytes).into_owned();
let cur = self
.specs
.last_mut()
.expect("qpdf page range requires a preceding file");
if !cur.range.is_empty() {
return Err(Box::new(UsageError::new(
"--range already specified for this file",
)));
}
cur.range = range;
self.called_pages_range = true;
}
Err(error) => {
if !matches!(&error, Error::SystemBytes(_)) {
return Err(Box::new(error));
}
let is_file = canonical == b"."
|| File::open(arg_parser::os_string_from_bytes(canonical)).is_ok();
if is_file {
self.specs.push(PageSegmentSpec {
file_token,
password: None,
raw_password: None,
range: String::new(),
});
self.called_pages_range = false;
} else {
let message = error
.raw_message()
.map_or_else(|| error.to_string().into_bytes(), ToOwned::to_owned);
return Err(Box::new(UsageError::new(message)));
}
}
}
Ok(())
}
fn finish(self) -> CliResult<Vec<PageSegmentSpec>> {
if self.specs.is_empty() {
return Err(Box::new(UsageError::new(
"--pages: no page specifications given",
)));
}
Ok(self.specs)
}
}
fn segment_option_name(bytes: &[u8]) -> Option<&str> {
let name = bytes
.strip_prefix(b"--")
.or_else(|| bytes.strip_prefix(b"-"))?;
if name.is_empty() || name[0] == b'-' || name[0].is_ascii_digit() {
return None;
}
let end = name
.iter()
.position(|byte| *byte == b'=')
.unwrap_or(name.len());
std::str::from_utf8(&name[..end]).ok()
}
fn parse_pages_segment<T: RawCliArg>(tokens: &[T]) -> CliResult<Vec<PageSegmentSpec>> {
let mut parser = PagesSegmentParser::default();
for tok in tokens {
let token_bytes = tok.raw_bytes();
parser.push(&token_bytes, &token_bytes, tok.os_string())?;
}
parser.finish()
}
fn raw_page_tokens(page_ops: &PageOpArgs) -> Vec<Vec<u8>> {
page_ops
.raw_pages
.clone()
.unwrap_or_else(|| raw_os_args(&page_ops.pages))
}
fn configured_page_specs(page_ops: &PageOpArgs) -> CliResult<Vec<PageSegmentSpec>> {
page_ops
.parsed_page_specs
.clone()
.map_or_else(|| parse_pages_segment(&raw_page_tokens(page_ops)), Ok)
}
fn resolve_page_specs(
specs: &[PageSegmentSpec],
primary_input: &std::path::Path,
) -> CliResult<Vec<CliInputSpec>> {
let mut out = Vec::with_capacity(specs.len());
for s in specs {
let path: PathBuf = if s.file_token == OsStr::new(".") {
primary_input.to_path_buf()
} else {
PathBuf::from(&s.file_token)
};
let range = if s.range.is_empty() {
PageRange::all()
} else {
PageRange::parse_numrange(&s.range).map_err(|e| {
let message = e
.raw_message()
.expect("PageRange::parse_numrange delegates to qutil raw range errors");
let mut what = b"parsing numeric range for ".to_vec();
what.extend_from_slice(&path_description(&path));
what.extend_from_slice(b": ");
what.extend_from_slice(message);
Box::new(Error::SystemBytes(what)) as Box<dyn std::error::Error>
})?
};
out.push(CliInputSpec::new(
path,
s.raw_password.clone().or_else(|| {
s.password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
}),
range,
));
}
Ok(out)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OverlayKind {
Overlay,
Underlay,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct OverlaySpec {
kind: OverlayKind,
file: OsString,
password: Option<OsString>,
raw_password: Option<Vec<u8>>,
from: Option<String>,
to: Option<String>,
repeat: Option<String>,
}
struct OverlaySegmentParser {
kind: OverlayKind,
file: Option<OsString>,
password: Option<OsString>,
raw_password: Option<Vec<u8>>,
from: Option<String>,
to: Option<String>,
repeat: Option<String>,
}
impl OverlaySegmentParser {
fn new(kind: OverlayKind) -> Self {
Self {
kind,
file: None,
password: None,
raw_password: None,
from: None,
to: None,
repeat: None,
}
}
fn flag(&self) -> &'static str {
match self.kind {
OverlayKind::Overlay => "overlay",
OverlayKind::Underlay => "underlay",
}
}
fn push(&mut self, original: &[u8], canonical: &[u8], file_token: OsString) -> CliResult<()> {
if let Some(path) = canonical.strip_prefix(b"--file=") {
if self.file.is_some() {
return Err(Box::new(UsageError::new(format!(
"{} file already specified",
self.flag()
))));
}
self.file = Some(arg_parser::os_string_from_bytes(path));
return Ok(());
}
if let Some(password) = canonical.strip_prefix(b"--password=") {
self.password = Some(arg_parser::os_string_from_bytes(password));
self.raw_password = Some(password.to_vec());
return Ok(());
}
if let Some(range) = canonical.strip_prefix(b"--to=") {
let range = String::from_utf8(range.to_vec())
.map_err(|_| format!("{} --to must be valid UTF-8", self.flag()))?;
PageRange::parse_numrange(&range).map_err(|error| {
format!(
"{}: invalid --to= page range {range:?}: {error}",
self.flag()
)
})?;
self.to = Some(range);
return Ok(());
}
if let Some(range) = canonical.strip_prefix(b"--from=") {
let range = String::from_utf8(range.to_vec())
.map_err(|_| format!("{} --from must be valid UTF-8", self.flag()))?;
if !range.is_empty() {
PageRange::parse_numrange(&range).map_err(|error| {
format!(
"{}: invalid --from= page range {range:?}: {error}",
self.flag()
)
})?;
}
self.from = Some(range);
return Ok(());
}
if let Some(range) = canonical.strip_prefix(b"--repeat=") {
let range = String::from_utf8(range.to_vec())
.map_err(|_| format!("{} --repeat must be valid UTF-8", self.flag()))?;
if !range.is_empty() {
PageRange::parse_numrange(&range).map_err(|error| {
format!(
"{}: invalid --repeat= page range {range:?}: {error}",
self.flag()
)
})?;
}
self.repeat = Some(range);
return Ok(());
}
if canonical.starts_with(b"-") && canonical != b"-" {
let name = segment_option_name(canonical);
if let Some(name) = name {
let parameter = match name {
"file" => Some("file"),
"password" => Some("password"),
"to" | "from" | "repeat" => Some("page-range"),
_ => None,
};
if !canonical.contains(&b'=') {
if let Some(parameter) = parameter {
return Err(Box::new(UsageError::new(format!(
"--{name} must be given as --{name}={parameter}"
))));
}
}
}
return Err(Box::new(UsageError::new(format!(
"unrecognized argument {} (underlay/overlay options must be terminated with --)",
String::from_utf8_lossy(original)
))));
}
if self.file.is_some() {
return Err(Box::new(UsageError::new(format!(
"{} file already specified",
self.flag()
))));
}
self.file = Some(file_token);
Ok(())
}
fn finish(self) -> CliResult<OverlaySpec> {
let flag = self.flag();
let file = self.file.ok_or_else(|| {
Box::new(UsageError::new(format!("{} file not specified", flag)))
as Box<dyn std::error::Error>
})?;
if file.is_empty() {
return Err(Box::new(UsageError::new(format!(
"{} file not specified",
flag
))));
}
Ok(OverlaySpec {
kind: self.kind,
file,
password: self.password,
raw_password: self.raw_password,
from: self.from,
to: self.to,
repeat: self.repeat,
})
}
}
struct PreprocessedArgs {
residual_args: Vec<OsString>,
original_residual_args: Vec<arg_parser::RawArg>,
native_subcommand_mode: bool,
overlay_specs: Vec<OverlaySpec>,
attachment_segments: Vec<Vec<Vec<u8>>>,
raw_overrides: RawCliOverrides,
expanded_arg_count: usize,
first_unknown_option: Option<(usize, arg_parser::RawArg)>,
}
#[derive(Debug, Default)]
struct RawCliOverrides {
password: Option<Vec<u8>>,
encryption_file_password: Option<Vec<u8>>,
raw_encrypt: Option<Vec<Vec<u8>>>,
raw_encrypt_segments: Option<Vec<Vec<Vec<u8>>>>,
raw_pages: Option<Vec<Vec<u8>>>,
parsed_page_specs: Option<Vec<PageSegmentSpec>>,
parsed_encrypt_segments: Option<Vec<ParsedEncryptSegment>>,
last_encryption_mode: Option<EncryptionMode>,
raw_copy_attachments_from: Option<Vec<Vec<Vec<u8>>>>,
}
enum ActiveQpdfSegment {
Pages(PagesSegmentParser),
Overlay(OverlaySegmentParser),
Encrypt(EncryptSegmentCallbackState),
Other,
}
#[derive(Default)]
struct QpdfSegmentHandler {
active: Option<ActiveQpdfSegment>,
pages_seen: bool,
page_specs: Option<Vec<PageSegmentSpec>>,
overlay_specs: Vec<OverlaySpec>,
encrypt_segments: Vec<ParsedEncryptSegment>,
}
impl arg_parser::SegmentHandler for QpdfSegmentHandler {
fn begin(&mut self, kind: arg_parser::SegmentKind, option: &str) -> CliResult<()> {
if self.active.is_some() {
return Err(Error::Internal("nested qpdf named segment".into()).into());
}
self.active = Some(match kind {
arg_parser::SegmentKind::Pages => {
if self.pages_seen {
return Err(Box::new(UsageError::new(
"--pages may only be specified one time",
)));
}
self.pages_seen = true;
ActiveQpdfSegment::Pages(PagesSegmentParser::default())
}
arg_parser::SegmentKind::Overlay => {
let kind = if option == "underlay" {
OverlayKind::Underlay
} else {
OverlayKind::Overlay
};
ActiveQpdfSegment::Overlay(OverlaySegmentParser::new(kind))
}
arg_parser::SegmentKind::Encrypt => {
ActiveQpdfSegment::Encrypt(EncryptSegmentCallbackState::new())
}
arg_parser::SegmentKind::AddAttachment
| arg_parser::SegmentKind::CopyAttachments
| arg_parser::SegmentKind::PageLabels => ActiveQpdfSegment::Other,
});
Ok(())
}
fn token(
&mut self,
_kind: arg_parser::SegmentKind,
original: &arg_parser::RawArg,
canonical: &arg_parser::RawArg,
) -> CliResult<()> {
match self.active.as_mut() {
Some(ActiveQpdfSegment::Pages(parser)) => parser.push(
original.as_bytes(),
canonical.as_bytes(),
original.as_os_str().to_os_string(),
),
Some(ActiveQpdfSegment::Overlay(parser)) => parser.push(
original.as_bytes(),
canonical.as_bytes(),
original.as_os_str().to_os_string(),
),
Some(ActiveQpdfSegment::Encrypt(parser)) => {
parser.push(original.as_bytes(), canonical.as_bytes())
}
Some(ActiveQpdfSegment::Other) | None => Ok(()),
}
}
fn end(&mut self, _kind: arg_parser::SegmentKind) -> CliResult<()> {
let active = self
.active
.take()
.ok_or_else(|| Error::Internal("qpdf named segment ended without a begin".into()))?;
match active {
ActiveQpdfSegment::Pages(parser) => self.page_specs = Some(parser.finish()?),
ActiveQpdfSegment::Overlay(parser) => self.overlay_specs.push(parser.finish()?),
ActiveQpdfSegment::Encrypt(parser) => self.encrypt_segments.push(parser.finish()?),
ActiveQpdfSegment::Other => {}
}
Ok(())
}
fn missing_terminator(
&mut self,
kind: arg_parser::SegmentKind,
_option: &str,
) -> Box<dyn std::error::Error> {
let table = match self.active.as_ref() {
Some(ActiveQpdfSegment::Encrypt(parser)) => encrypt_option_table_name(parser.key_len),
Some(ActiveQpdfSegment::Pages(_)) => "pages",
Some(ActiveQpdfSegment::Overlay(_)) => "underlay/overlay",
Some(ActiveQpdfSegment::Other) | None => match kind {
arg_parser::SegmentKind::Encrypt => "encryption",
arg_parser::SegmentKind::Pages => "pages",
arg_parser::SegmentKind::AddAttachment => "attachment",
arg_parser::SegmentKind::CopyAttachments => "copy attachment",
arg_parser::SegmentKind::Overlay => "underlay/overlay",
arg_parser::SegmentKind::PageLabels => "set page labels",
},
};
UsageError::new(format!("missing -- at end of {table} options")).into()
}
}
#[cfg(test)]
fn parse_overlay_segment<T: RawCliArg>(kind: OverlayKind, tokens: &[T]) -> CliResult<OverlaySpec> {
let mut parser = OverlaySegmentParser::new(kind);
for tok in tokens {
let token_bytes = tok.raw_bytes();
parser.push(&token_bytes, &token_bytes, tok.os_string())?;
}
parser.finish()
}
#[cfg(test)]
fn parse_test_args(args: Vec<String>) -> CliResult<arg_parser::ParsedArgs> {
let has_program = args.first().is_some_and(|arg| !arg.starts_with('-'));
let mut parser_args = args;
if !has_program {
parser_args.insert(0, "flpdf".to_owned());
}
let mut parsed = arg_parser::ArgParser::from_command(cli_command()).parse(parser_args)?;
if !has_program {
parsed.residual_args.remove(0);
}
Ok(parsed)
}
#[cfg(test)]
fn rewrite_qpdf_single_dash(args: Vec<String>) -> Vec<String> {
parse_test_args(args)
.expect("test argv should parse")
.residual_args
.into_iter()
.map(|arg| arg.into_string().expect("test argv must be UTF-8"))
.collect()
}
#[cfg(test)]
fn normalize_qpdf_bare_equals(args: Vec<String>) -> Vec<String> {
rewrite_qpdf_single_dash(args)
}
#[cfg(test)]
fn extract_overlay_groups(args: Vec<String>) -> CliResult<(Vec<String>, Vec<OverlaySpec>)> {
let parsed = parse_test_args(args)?;
let mut overlay_specs = Vec::new();
for segment in parsed.named_segments {
let kind = match segment.option.as_str() {
"overlay" => OverlayKind::Overlay,
"underlay" => OverlayKind::Underlay,
_ => continue,
};
overlay_specs.push(parse_overlay_segment(kind, &segment.tokens)?);
}
let residual_args = parsed
.residual_args
.into_iter()
.map(|arg| arg.into_string().expect("test argv must be UTF-8"))
.collect();
Ok((residual_args, overlay_specs))
}
#[cfg(test)]
fn extract_attachment_groups(args: Vec<String>) -> CliResult<(Vec<String>, Vec<Vec<String>>)> {
let parsed = parse_test_args(args)?;
let groups = parsed
.named_segments
.into_iter()
.filter(|segment| segment.option == "add-attachment")
.map(|segment| {
segment
.tokens
.into_iter()
.map(|token| token.into_string().expect("test argv must be UTF-8"))
.collect()
})
.collect();
let residual_args = parsed
.residual_args
.into_iter()
.map(|arg| arg.into_string().expect("test argv must be UTF-8"))
.collect();
Ok((residual_args, groups))
}
#[cfg(test)]
fn build_overlay_specs(
specs: &[OverlaySpec],
repair: bool,
password: &PasswordArgs,
) -> CliResult<Vec<flpdf::OverlaySpec<BufReader<File>>>> {
build_overlay_specs_with_suppression(specs, repair, password, false)
}
#[cfg(test)]
fn build_overlay_specs_with_suppression(
specs: &[OverlaySpec],
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Vec<flpdf::OverlaySpec<BufReader<File>>>> {
let mut built = Vec::with_capacity(specs.len());
for spec in specs {
let path = PathBuf::from(spec.file.as_os_str());
let file = File::open(&path).map_err(|error| open_error_with_file(&path, error.into()))?;
let mut source_password = password.clone();
source_password.set_password_bytes(spec.raw_password.clone().or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
}));
source_password.password_file = None;
let options = pdf_open_options(repair, &source_password)?;
let mut source_job = QPDFJob::new();
source_job.set_logger(cli_logger());
source_job.set_message_prefix(progname());
source_job.set_suppress_warnings(suppress_warnings);
let mut source = source_job
.open_with_description(BufReader::new(file), path_description(&path), options)
.map_err(|error| error_with_file(&path, actionable_password_error(error)))?;
source
.root_handle()
.map_err(|error| error_with_file(&path, actionable_password_error(error)))?;
let kind = match spec.kind {
OverlayKind::Overlay => flpdf::OverlayKind::Overlay,
OverlayKind::Underlay => flpdf::OverlayKind::Underlay,
};
let from = match spec.from.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(r) => PageRange::parse_numrange(r)?,
};
let to = match spec.to.as_deref() {
None => PageRange::all(),
Some("") => PageRange::empty(),
Some(r) => PageRange::parse_numrange(r)?,
};
let repeat = match spec.repeat.as_deref() {
None | Some("") => None,
Some(r) => Some(PageRange::parse_numrange(r)?),
};
built.push(flpdf::OverlaySpec {
source,
kind,
from,
to,
repeat,
});
}
Ok(built)
}
fn parse_collate_values(raw_values: &[String]) -> CliResult<Option<Vec<usize>>> {
if raw_values.is_empty() {
return Ok(None);
}
let mut values = Vec::new();
for raw in raw_values {
values.extend(QPDFJob::parse_collate(raw)?);
}
Ok(Some(values))
}
fn validate_collate_values(raw_values: &[String]) {
if let Err(error) = parse_collate_values(raw_values) {
if let Some(usage_error) = find_usage_error(error.as_ref()) {
usage_exit(usage_error);
}
emit_logger_error(format!("{}: {error}\n", progname()));
std::process::exit(2);
}
}
fn configure_keep_files_open(job: &mut QPDFJob, page_ops: &PageOpArgs) -> CliResult<()> {
if let Some(value) = page_ops.keep_files_open {
job.set_keep_files_open(matches!(value, CliYesNo::Yes));
}
if let Some(threshold) = page_ops.keep_files_open_threshold.as_deref() {
job.set_keep_files_open_threshold(QPDFJob::parse_keep_files_open_threshold(threshold)?);
}
Ok(())
}
fn validate_keep_files_open_threshold(page_ops: &PageOpArgs) -> CliResult<()> {
if let Some(value) = page_ops.keep_files_open_threshold.as_deref() {
QPDFJob::parse_keep_files_open_threshold(value)?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction(
primary_input: &std::path::Path,
output: &std::path::Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
verbose: bool,
no_warn: bool,
) -> CliResult<()> {
if !split_pages_active(page_ops.split_pages.as_deref()) {
reject_same_job_output(primary_input, output)?;
}
let standard_output = prepare_page_operation_standard_output(output, page_ops)?;
let creates_output = standard_output.is_none();
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
let specs = configured_page_specs(page_ops)?;
let mut inputs = resolve_page_specs(&specs, primary_input)?;
let has_external_source = inputs.iter().any(|spec| spec.path != primary_input);
if !has_external_source {
if let Some(top_pw) = password.password_bytes() {
for spec in &mut inputs {
if spec.password.is_none() {
spec.password = Some(top_pw.clone());
}
}
}
}
let mut distinct: Vec<std::path::PathBuf> = Vec::new();
for spec in &inputs {
let key = std::fs::canonicalize(&spec.path).unwrap_or_else(|_| spec.path.clone());
if !distinct.contains(&key) {
distinct.push(key);
}
}
if json_input || update_from_json.is_some() {
let primary_canonical =
std::fs::canonicalize(primary_input).unwrap_or_else(|_| primary_input.to_path_buf());
if distinct.iter().any(|path| *path != primary_canonical) {
return Err(
"--pages: cross-document page merge is not supported at this layer \
(an explicit --pages source differs from the --json-input/\
--update-from-json primary input). Single-document extraction \
('.' or the primary input's own path) is supported; cross-doc \
merge with a JSON-created/updated primary is tracked in a \
separate issue."
.into(),
);
}
let opened = open_job_pdf(
primary_input,
repair,
password,
json_input,
update_from_json,
false,
no_warn,
)?;
return match opened {
JobPdf::File(pdf) => run_page_extraction_from_single_source(
pdf,
primary_input,
output,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
verbose,
standard_output,
creates_output,
&inputs,
no_warn,
),
JobPdf::Json(pdf) => run_page_extraction_from_single_source(
pdf,
primary_input,
output,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
verbose,
standard_output,
creates_output,
&inputs,
no_warn,
),
};
}
if has_external_source {
return run_page_extraction_from_multiple_sources(
primary_input,
output,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
verbose,
no_warn,
standard_output,
creates_output,
inputs,
);
}
run_page_extraction_from_single_source(
open_pdf_with_suppression(&primary_input.to_path_buf(), repair, password, no_warn)?,
primary_input,
output,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
verbose,
standard_output,
creates_output,
&inputs,
no_warn,
)
}
#[allow(clippy::too_many_arguments)]
fn run_empty_page_extraction(
output: &Path,
repair: bool,
password: &PasswordArgs,
update_from_json: Option<&Path>,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
verbose: bool,
no_warn: bool,
) -> CliResult<()> {
let standard_output = prepare_page_operation_standard_output(output, page_ops)?;
let creates_output = standard_output.is_none();
let raw_specs = configured_page_specs(page_ops)?;
if raw_specs
.iter()
.any(|spec| spec.file_token == OsStr::new("."))
{
return Err("--pages: '.' cannot refer to a primary input with --empty".into());
}
let inputs = resolve_page_specs(&raw_specs, Path::new("<empty>"))?;
let mut source_paths = Vec::new();
let mut source_passwords = Vec::new();
let mut specs = Vec::with_capacity(inputs.len());
for input in inputs {
let source_index =
if let Some(index) = source_paths.iter().position(|path| *path == input.path) {
index + 1
} else {
source_paths.push(input.path.clone());
source_passwords.push(input.password.clone());
source_paths.len()
};
specs.push(PageSpecInput::new(source_index, input.range));
}
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_verbose(verbose);
job.set_suppress_warnings(no_warn);
configure_keep_files_open(&mut job, page_ops)?;
let keep_files_open = job.keep_files_open_for_page_specs(&specs);
job.report_page_spec_selection(&specs)?;
let mut sources = Vec::with_capacity(source_paths.len() + 1);
sources.push(job.create_empty_document()?);
apply_json_update_with_job(&mut job, &mut sources[0], update_from_json)?;
for (source_index, path) in source_paths.iter().enumerate() {
job.report_page_source_processing(path_description(path))?;
let mut source_password = password.clone();
source_password.set_password_bytes(source_passwords[source_index].clone());
source_password.password_file = None;
sources.push(open_page_source(
path,
repair,
&source_password,
keep_files_open,
no_warn,
)?);
}
let mut options = options;
for source in &mut sources {
update_input_version_floor(&mut options.input_version_floor, source)?;
}
let collate = parse_collate_values(&page_ops.collate)?;
let source_warnings = job.has_warnings();
let page_output = job.handle_page_specs(
&mut sources,
&specs,
collate.as_deref(),
remove_unref.into(),
options.preserve_unreferenced_objects,
)?;
let source_warnings = source_warnings || job.has_warnings();
let PageSpecJobOutput::Merged(mut merged) = page_output else {
return Err("--empty --pages unexpectedly returned an in-place document".into());
};
let selected_pages = pages::page_refs(&mut merged)?;
run_page_extraction_after_plan(
&mut merged,
output,
Path::new("<empty>"),
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
standard_output,
creates_output,
false,
None,
source_warnings,
None,
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_multiple_sources(
primary_input: &Path,
output: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
verbose: bool,
no_warn: bool,
standard_output: Option<PipelineWriter>,
creates_output: bool,
inputs: Vec<CliInputSpec>,
) -> CliResult<()> {
let primary_encrypted = open_page_source(
&primary_input.to_path_buf(),
repair,
password,
true,
no_warn,
)?
.is_encrypted();
let mut source_paths = vec![primary_input.to_path_buf()];
let mut source_passwords: Vec<Option<Vec<u8>>> = vec![None];
let mut specs = Vec::with_capacity(inputs.len());
for input in inputs {
let source_index = if input.path == primary_input {
0
} else if let Some(index) = source_paths.iter().position(|path| path == &input.path) {
index
} else {
let index = source_paths.len();
source_paths.push(input.path.clone());
source_passwords.push(input.password.clone());
index
};
specs.push(PageSpecInput::new(source_index, input.range));
}
let mut sources = Vec::with_capacity(source_paths.len());
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_verbose(verbose);
job.set_suppress_warnings(no_warn);
configure_keep_files_open(&mut job, page_ops)?;
let keep_files_open = job.keep_files_open_for_page_specs(&specs);
job.report_page_spec_selection(&specs)?;
sources.push(open_page_source(
&primary_input.to_path_buf(),
repair,
password,
true,
no_warn,
)?);
for (source_index, path) in source_paths.iter().enumerate().skip(1) {
let mut source_password = password.clone();
source_password.set_password_bytes(source_passwords[source_index].clone());
source_password.password_file = None;
job.report_page_source_processing(path_description(path))?;
sources.push(open_page_source(
path,
repair,
&source_password,
keep_files_open,
no_warn,
)?);
}
let mut options = options;
for source in &mut sources {
update_input_version_floor(&mut options.input_version_floor, source)?;
}
let primary_copy_encryption = sources
.first_mut()
.ok_or("--pages: primary input was not opened")?
.writer_copy_encryption_source()?;
let collate = parse_collate_values(&page_ops.collate)?;
let source_warnings = job.has_warnings();
let page_output = job.handle_page_specs(
&mut sources,
&specs,
collate.as_deref(),
remove_unref.into(),
options.preserve_unreferenced_objects,
)?;
let source_warnings = source_warnings || job.has_warnings();
let mut merged = match page_output {
PageSpecJobOutput::Merged(merged) => merged,
PageSpecJobOutput::InPlace { .. } => {
return Err("--pages: multiple-source job returned an in-place result".into());
}
};
let selected_pages = pages::page_refs(&mut merged)?;
run_page_extraction_after_plan(
&mut merged,
output,
primary_input,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
source_warnings,
None,
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_single_source<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
primary_input: &Path,
output: &Path,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
verbose: bool,
standard_output: Option<PipelineWriter>,
creates_output: bool,
inputs: &[CliInputSpec],
no_warn: bool,
) -> CliResult<()> {
let primary_encrypted = pdf.is_encrypted();
let primary_copy_encryption = pdf.writer_copy_encryption_source()?;
let specs: Vec<PageSpecInput> = inputs
.iter()
.map(|input| PageSpecInput::new(0, input.range.clone()))
.collect();
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_verbose(verbose);
job.set_suppress_warnings(no_warn);
configure_keep_files_open(&mut job, page_ops)?;
job.report_page_spec_selection(&specs)?;
let collate = parse_collate_values(&page_ops.collate)?;
let mut sources = vec![pdf];
let before_warnings = job.has_warnings();
let page_output = job.handle_page_specs(
&mut sources,
&specs,
collate.as_deref(),
remove_unref.into(),
options.preserve_unreferenced_objects,
)?;
let source_warnings = before_warnings || job.has_warnings();
match page_output {
PageSpecJobOutput::InPlace {
pdf,
result,
prune_mode,
} => {
let selected_pages = result.new_kids.clone();
run_page_extraction_after_plan(
pdf,
output,
primary_input,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
source_warnings,
Some((result, prune_mode)),
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
)
}
PageSpecJobOutput::Merged(mut merged) => {
let selected_pages = pages::page_refs(&mut merged)?;
run_page_extraction_after_plan(
&mut merged,
output,
primary_input,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
source_warnings,
None,
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
)
}
}
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_after_plan<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
output: &Path,
input_path: &Path,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
verbose: bool,
mut standard_output: Option<PipelineWriter>,
creates_output: bool,
primary_encrypted: bool,
primary_copy_encryption: Option<CopyEncryptionSource>,
prior_warnings: bool,
page_job_result: Option<(RebuildResult, RemoveUnreferencedResources)>,
selected_pages: Vec<ObjectRef>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
no_warn: bool,
) -> CliResult<()> {
pdf.set_suppress_warnings(no_warn);
let selected = selected_pages;
let (result, prune_mode) = if let Some((result, prune_mode)) = page_job_result {
(result, prune_mode)
} else {
let result = rebuild_page_tree(pdf, &selected)?;
copy_duplicate_page_annotations(pdf, &result)?;
(result, RemoveUnreferencedResources::No)
};
QPDFJob::complete_in_place_page_selection(pdf, &result, prune_mode)?;
let mut options = options;
let split_pages = page_ops
.split_pages
.as_deref()
.map(parse_split_n)
.transpose()?;
let split_pages_active = split_pages.is_some_and(|size| size > 0);
options.preserve_encryption =
options.preserve_encryption && primary_encrypted && !split_pages_active && !decrypt;
if options.preserve_encryption
&& !split_pages_active
&& options.encrypt.is_none()
&& options.copy_encryption.is_none()
&& !options.qdf
&& !options.content_normalization
&& !matches!(
options.stream_data,
Some(StreamDataMode::Uncompress) | Some(StreamDataMode::Compress)
)
&& !(options.decode_level_set && options.decode_level != StreamDecodeLevel::None)
{
options.copy_encryption = primary_copy_encryption;
}
let has_transformations = !overlay_specs.is_empty()
|| !page_ops.rotate.is_empty()
|| image_options.externalize_inline_images
|| image_options.optimize_images
|| remove_restrictions
|| coalesce_contents
|| generate_appearances
|| flatten_annotations_mode.is_some()
|| flatten_rotation;
let mut transform_job = if has_transformations {
if !overlay_specs.is_empty() {
update_input_version_floor(&mut options.input_version_floor, pdf)?;
}
let mut job = new_cli_job(no_warn);
job.set_password_mode(password.password_mode.into());
job.set_password_is_hex_key(password.password_is_hex_key);
job.set_suppress_password_recovery(password.suppress_password_recovery);
job.set_suppress_recovery(password.recovery.suppress_recovery);
job.set_ignore_xref_streams(password.recovery.ignore_xref_streams);
job.set_verbose(verbose);
configure_cli_overlay_specs(&mut job, overlay_specs)?;
{
let mut configuration = job.config();
for parameter in &page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
if image_options.optimize_images {
let mut optimization = image_options.image_options;
if image_options.externalize_inline_images {
optimization.keep_inline_images = false;
}
configuration.optimize_images(optimization);
} else if image_options.externalize_inline_images {
configuration
.externalize_inline_images(image_options.image_options.inline_min_bytes);
}
if remove_restrictions {
configuration.remove_restrictions();
}
if generate_appearances {
configuration.generate_appearances();
}
if let Some(mode) = flatten_annotations_mode {
configuration.flatten_annotations(FlattenAnnotationsMode::from(mode));
}
if coalesce_contents {
configuration.coalesce_contents();
}
if flatten_rotation {
configuration.flatten_rotation();
}
}
Some(job)
} else {
None
};
if let Some(job) = transform_job.as_mut() {
apply_transformations_for_cli(job, pdf)?;
if let Some(floor) = job.input_version_floor() {
options.input_version_floor = Some(
options
.input_version_floor
.map_or(floor, |current| current.max(floor)),
);
}
}
let split_progress = split_pages_active && options.progress;
if split_progress {
options.progress = false;
}
if let Some(n) = split_pages.filter(|size| *size > 0) {
let (_, mut split_job) = split_pdf(
pdf,
n,
output,
input_path,
options.deterministic_id,
split_progress,
verbose,
no_warn,
remove_unref.into(),
writer_configuration(&options, linearize, linearize_pass1)?,
)?;
split_job.record_document_warnings(pdf);
if prior_warnings {
split_job.record_warnings();
}
split_job.complete(true)?;
return finish_job_exit_status(split_job.get_exit_code());
} else {
let announce_file = standard_output.is_none();
write_with_pdf_writer(
pdf,
output,
&mut standard_output,
&options,
linearize,
linearize_pass1,
)?;
if verbose && announce_file {
logger_info(wrote_file_message(&progname(), output))?;
}
}
finish_operation_warnings_with_prior(pdf, creates_output, prior_warnings)
}
fn parse_split_n(raw: &str) -> CliResult<usize> {
let n: usize = raw
.parse()
.map_err(|_| format!("--split-pages: expected a non-negative integer, got {raw:?}"))?;
Ok(n)
}
fn split_pages_active(raw: Option<&str>) -> bool {
raw.is_some_and(|value| value.parse::<usize>().map_or(true, |size| size > 0))
}
#[allow(clippy::too_many_arguments)]
fn split_pdf<R: Read + Seek + 'static>(
source: &mut Pdf<R>,
chunk_size: usize,
output: &Path,
input_path: &Path,
deterministic_id: bool,
progress: bool,
verbose: bool,
suppress_warnings: bool,
remove_unreferenced_resources: RemoveUnreferencedResources,
writer_configuration: WriterConfiguration,
) -> CliResult<(Vec<PathBuf>, QPDFJob)> {
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_input_name_bytes(path_description(input_path));
job.set_suppress_warnings(suppress_warnings);
job.set_warnings_exit_zero(cli_warning_exit_zero());
if progress {
job.set_progress(true);
job.set_output_file(output.to_path_buf())?;
}
let options = SplitPageOptions::new(chunk_size, output)
.with_input_path(input_path)
.with_deterministic_id(deterministic_id)
.with_verbose(verbose)
.with_remove_unreferenced_resources(remove_unreferenced_resources)
.with_writer_configuration(writer_configuration);
let written = job.split_pages(source, options)?;
Ok((written, job))
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite_with_page_ops(
input: &std::path::Path,
output: &std::path::Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
page_ops: &PageOpArgs,
remove_unref: CliRemoveUnreferencedResources,
remove_restrictions: bool,
decrypt: bool,
options: WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
verbose: bool,
no_warn: bool,
) -> CliResult<()> {
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
run_rewrite_with_qpdf_job(
input,
output,
false,
repair,
password,
json_input,
update_from_json,
linearize,
linearize_pass1,
remove_restrictions,
decrypt,
options.content_normalization,
coalesce_contents,
generate_appearances,
image_options,
flatten_annotations_mode,
flatten_rotation,
PageLabelOptions::default(),
&[],
verbose,
no_warn,
options,
&page_ops.rotate,
page_ops.split_pages.as_deref(),
remove_unref.into(),
)
}
fn page_ops_active(p: &PageOpArgs) -> bool {
!p.pages.is_empty()
|| !p.rotate.is_empty()
|| split_pages_active(p.split_pages.as_deref())
|| p.empty
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ContentNormalizationWarning {
parsed_offset: Option<u64>,
last_token_was_bad: bool,
}
fn normalize_page_contents<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> CliResult<Vec<ContentNormalizationWarning>> {
let mut warnings = Vec::new();
let mut seen = HashSet::new();
let page_refs = pages::page_refs(pdf)?;
for page_ref in page_refs {
warnings.extend(apply_normalize_content(pdf, page_ref, &mut seen)?);
}
Ok(warnings)
}
fn apply_normalize_content<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
seen: &mut HashSet<ObjectRef>,
) -> CliResult<Vec<ContentNormalizationWarning>> {
let mut warnings = Vec::new();
let page = pdf.get_object_handle(page_ref);
let contents = page.try_get_key(b"/Contents")?;
let contents_ref = contents.object_ref();
let mut streams = Vec::new();
if contents.try_is_stream_of_type(b"", b"")? {
if let Some(stream_ref) = contents_ref {
streams.push((stream_ref, contents));
}
} else if contents.try_is_array()? {
let items = contents.as_array().unwrap_or_default();
for item in items {
let item_ref = item.object_ref();
if item.try_is_stream_of_type(b"", b"")? {
if let Some(item_ref) = item_ref {
streams.push((item_ref, item));
}
}
}
}
for (stream_ref, stream) in streams {
if let Some(last_bad) = normalize_and_store_stream_handle(stream_ref, stream, seen)? {
warnings.push(last_bad);
}
}
Ok(warnings)
}
fn normalize_and_store_stream_handle(
stream_ref: ObjectRef,
stream: ObjectHandle,
seen: &mut HashSet<ObjectRef>,
) -> CliResult<Option<ContentNormalizationWarning>> {
if !seen.insert(stream_ref) {
return Ok(None);
}
let decoded = stream.get_stream_data(StreamDecodeLevel::All)?;
let normalized = normalize_content_stream(decoded.as_ref());
let warning = normalized
.any_bad_tokens()
.then(|| ContentNormalizationWarning {
parsed_offset: u64::try_from(stream.get_parsed_offset()).ok(),
last_token_was_bad: normalized.last_token_was_bad(),
});
let normalized = normalized.into_bytes();
let normalized = std::rc::Rc::new(normalized);
stream.replace_stream_data(
std::rc::Rc::clone(&normalized),
Some(ObjectHandle::null()),
Some(ObjectHandle::null()),
);
if let Some(dict) = stream.as_stream_dict() {
dict.replace_key(
b"/Length",
ObjectHandle::integer(i64::try_from(normalized.len())?),
)?;
}
stream.mark_content_normalization_applied();
Ok(warning)
}
fn run_qdf(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
preserve_unreferenced: bool,
) -> CliResult<()> {
let input = input.ok_or_else(missing_input_usage_error)?;
let output = output.ok_or_else(missing_output_usage_error)?;
let mut standard_output = prepare_pdf_standard_output(&output)?;
let creates_output = standard_output.is_none();
let mut pdf = open_pdf(&input, repair, password)?;
let options = WriterOptions {
qdf: true,
preserve_unreferenced_objects: preserve_unreferenced,
..WriterOptions::default()
};
write_with_pdf_writer(
&mut pdf,
&output,
&mut standard_output,
&options,
false,
None,
)?;
finish_operation_warnings(&pdf, creates_output)
}
fn run_qdf_fix(input: &std::path::Path, output: &std::path::Path) -> CliResult<()> {
let bytes = std::fs::read(input)?;
let fixed = fix_qdf(&bytes)?;
std::fs::write(output, fixed)?;
Ok(())
}
fn is_zlib_flate_program(program: &OsStr) -> bool {
Path::new(program).file_name().is_some_and(|name| {
name == OsStr::new("zlib-flate") || name == OsStr::new("zlib-flate.exe")
})
}
fn zlib_flate_usage(usage_name: &str) -> CliResult<()> {
emit_logger_error(format!(
"Usage: {usage_name} {{ -uncompress | -compress[=n] }}\n\
If n is specified with -compress, it is a zlib compression level from\n\
1 to 9 where lower numbers are faster and less compressed and higher\n\
numbers are slower and more compressed\n"
));
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
fn zlib_flate_failure(whoami: &str, error: impl std::fmt::Display) -> CliResult<()> {
emit_logger_error(format!("{whoami}: {error}\n"));
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
fn run_zlib_flate(args: &[OsString], whoami: &str, usage_name: &str) -> CliResult<()> {
if args.len() == 1 && args[0] == OsStr::new("--version") {
emit_logger_info(format!(
"{whoami} from qpdf version {}\n",
flpdf::qpdf_version()
));
return Ok(());
}
if args.len() != 1 {
return zlib_flate_usage(usage_name);
}
let Some(mode) = args[0].to_str() else {
return zlib_flate_usage(usage_name);
};
let (action, compression_level) = match mode {
"-uncompress" => (FlateAction::Inflate, None),
"-compress" => (FlateAction::Deflate, None),
value => match value.strip_prefix("-compress=") {
Some(level) => {
let level = match qpdf_selector_integer(level) {
Ok(level) => level,
Err(error) => return zlib_flate_failure(whoami, error),
};
(FlateAction::Deflate, Some(level))
}
None => return zlib_flate_usage(usage_name),
},
};
let input = std::io::stdin();
let mut input = input.lock();
let output = std::io::stdout();
let mut output = output.lock();
let mut sink = PlStdioFile::new("stdout", &mut output);
let flate_result = match compression_level {
Some(level) => PlFlate::new_with_compression_level("flate", &mut sink, action, level),
None => PlFlate::new("flate", &mut sink, action),
};
let mut flate = match flate_result {
Ok(flate) => flate,
Err(error) => return zlib_flate_failure(whoami, error),
};
let warned = std::rc::Rc::new(std::cell::Cell::new(false));
let warned_for_callback = std::rc::Rc::clone(&warned);
let warning_whoami = whoami.to_owned();
flate.set_warn_callback(move |message, code| {
warned_for_callback.set(true);
emit_logger_error(format!(
"{warning_whoami}: WARNING: zlib code {code}, msg = {message}\n"
));
Ok(())
});
let mut buffer = [0u8; 10_000];
loop {
let length = match input.read(&mut buffer) {
Ok(length) => length,
Err(error) => {
drop(flate);
return zlib_flate_failure(whoami, error);
}
};
if length == 0 {
break;
}
if let Err(error) = flate.write(&buffer[..length]) {
drop(flate);
return zlib_flate_failure(whoami, error);
}
}
let finish = flate.finish();
drop(flate);
if let Err(error) = finish {
return zlib_flate_failure(whoami, error);
}
if warned.get() {
return Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}));
}
Ok(())
}
fn reject_same_json_output(input: &Path, output: &Path) -> CliResult<()> {
reject_same_file(
input,
output,
"input file and output file are the same; choose a different --json-output path",
"--json-output",
)
}
fn reject_same_job_output(input: &Path, output: &Path) -> CliResult<()> {
reject_same_file(
input,
output,
"input file and output file are the same; use --replace-input to intentionally overwrite the input file",
"output",
)
}
fn reject_same_file(
input: &Path,
output: &Path,
same_file_message: &str,
inspect_label: &str,
) -> CliResult<()> {
match std::fs::metadata(output) {
Ok(_) => {
if qpdf_same_file(input, output) {
return Err(UsageError::new(same_file_message).into());
}
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => {
return Err(format!(
"unable to inspect {inspect_label} file {}: {error}",
output.display()
)
.into())
}
}
Ok(())
}
fn json_input_open_error(input: &Path, error: std::io::Error) -> Box<dyn std::error::Error> {
let rendered = error.to_string();
let message = error
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered);
format!("open {}: {message}", input.display()).into()
}
fn qpdf_json_input_open_error(input: &Path, error: std::io::Error) -> Box<dyn std::error::Error> {
let rendered = error.to_string();
let message = if error.kind() == std::io::ErrorKind::NotFound {
"No such file or directory"
} else {
error
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered)
};
format!("open {}: {message}", input.display()).into()
}
fn open_verified_json_output(input: Option<&File>, output: &Path) -> CliResult<File> {
let mut output_file = OpenOptions::new()
.write(true)
.create(true)
.truncate(false)
.open(output)
.map_err(|error| open_error_with_file(output, error.into()))?;
if let Some(input) = input {
let input_handle = same_file::Handle::from_file(input.try_clone()?)?;
let output_handle = same_file::Handle::from_file(output_file.try_clone()?)?;
if input_handle == output_handle {
return Err(
"input file and output file are the same; choose a different --json-output path"
.into(),
);
}
}
if output_file.metadata()?.file_type().is_file() {
output_file.set_len(0)?;
output_file.seek(SeekFrom::Start(0))?;
}
Ok(output_file)
}
#[derive(Debug, Clone, Copy)]
enum ShowObjectSelector {
Trailer,
Object { number: i32, generation: i32 },
Null,
NoObject,
}
fn parse_show_object_selector(value: &str) -> CliResult<ShowObjectSelector> {
match JsonObjectSelector::parse(value).map_err(UsageError::new)? {
JsonObjectSelector::Trailer => Ok(ShowObjectSelector::Trailer),
JsonObjectSelector::Object { number, .. } if number <= 0 => {
Ok(ShowObjectSelector::NoObject)
}
JsonObjectSelector::Object { generation, .. } if generation < 0 => {
Ok(ShowObjectSelector::Null)
}
JsonObjectSelector::Object { number, generation } => {
Ok(ShowObjectSelector::Object { number, generation })
}
}
}
fn qpdf_selector_integer(value: &str) -> CliResult<i32> {
let original = value;
let value = value.trim_start_matches(|character| {
matches!(
character,
' ' | '\n' | '\r' | '\t' | '\u{000c}' | '\u{000b}'
)
});
let digits_start = usize::from(matches!(value.as_bytes().first(), Some(b'+') | Some(b'-')));
let digits_end = digits_start
+ value[digits_start..]
.bytes()
.take_while(u8::is_ascii_digit)
.count();
if digits_end == digits_start {
return Ok(0);
}
let prefix = &value[..digits_end];
let parsed = prefix.parse::<i128>().map_err(|_| {
UsageError::new(format!(
"overflow/underflow converting {original} to 64-bit integer"
))
})?;
if !(i128::from(i64::MIN)..=i128::from(i64::MAX)).contains(&parsed) {
return Err(UsageError::new(format!(
"overflow/underflow converting {original} to 64-bit integer"
))
.into());
}
let parsed = parsed as i64;
Ok(i32::try_from(parsed).map_err(|_| {
UsageError::new(format!(
"integer out of range converting {parsed} from a 8-byte signed type to a 4-byte signed type"
))
})?)
}
#[allow(clippy::too_many_arguments)]
fn run_show_object(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
selector: &str,
raw_stream_data: bool,
filtered_stream_data: bool,
normalize_content: bool,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
let selector = parse_show_object_selector(selector)?;
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
job.set_content_normalization(normalize_content);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let object = match selector {
ShowObjectSelector::Trailer => pdf.trailer(),
ShowObjectSelector::Object { number, generation } => {
pdf.get_object_handle_by_raw_identity(number, generation)
}
ShowObjectSelector::NoObject => {
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
ShowObjectSelector::Null => {
logger_info(b"null\n")?;
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
};
return finish_job_exit_status(job.show_object(
&mut pdf,
object,
raw_stream_data,
filtered_stream_data,
)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
let mut job = new_cli_job(suppress_warnings);
job.set_content_normalization(normalize_content);
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let object = match selector {
ShowObjectSelector::Trailer => pdf.trailer(),
ShowObjectSelector::Object { number, generation } => {
pdf.get_object_handle_by_raw_identity(number, generation)
}
ShowObjectSelector::NoObject => {
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
ShowObjectSelector::Null => {
logger_info(b"null\n")?;
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
};
finish_job_exit_status(job.show_object(
&mut pdf,
object,
raw_stream_data,
filtered_stream_data,
)?)
}
fn run_show_npages(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_job_exit_status(job.show_npages(&mut pdf)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
let mut job = new_cli_job(suppress_warnings);
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_job_exit_status(job.show_npages(&mut pdf)?)
}
#[allow(clippy::too_many_arguments)]
fn run_show_pages(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
with_images: bool,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
job.set_with_images(with_images);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_job_exit_status(job.show_pages(&mut pdf)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
let mut job = new_cli_job(suppress_warnings);
job.set_with_images(with_images);
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_job_exit_status(job.show_pages(&mut pdf)?)
}
fn run_show_xref(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_job_exit_status(job.show_xref(&mut pdf)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
let mut job = new_cli_job(suppress_warnings);
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_job_exit_status(job.show_xref(&mut pdf)?)
}
fn run_show_linearization(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(no_warn);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_job_exit_status(job.show_linearization(&mut pdf)?);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let file = File::open(&input).map_err(|error| open_error_with_file(&input, error.into()))?;
let mut job = new_cli_job(no_warn);
let mut options = pdf_open_options(repair, password)?;
options.suppress_warnings = no_warn;
let mut pdf =
match job.open_with_description(BufReader::new(file), path_description(&input), options) {
Ok(pdf) => pdf,
Err(error) => return Err(error_with_file(&input, actionable_password_error(error))),
};
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
finish_job_exit_status(job.show_linearization(&mut pdf)?)
}
enum EncryptionProbe {
Opened { encrypted: bool },
EncryptedAuthFailed,
}
fn probe_encryption(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<EncryptionProbe> {
let file = File::open(input).map_err(|error| open_error_with_file(input, error.into()))?;
let options = pdf_open_options(repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(suppress_warnings);
match job.open_with_description(BufReader::new(file), path_description(input), options) {
Ok(mut pdf) => {
pdf.root_handle()
.map_err(|error| error_with_file(input, actionable_password_error(error)))?;
Ok(EncryptionProbe::Opened {
encrypted: pdf.is_encrypted(),
})
}
Err(error) if is_bad_password_error(&error) => Ok(EncryptionProbe::EncryptedAuthFailed),
Err(other) => Err(error_with_file(input, actionable_password_error(other))),
}
}
fn is_bad_password_error(error: &flpdf::Error) -> bool {
let source = error.open_failure().map_or(error, |(source, _)| source);
matches!(
source,
flpdf::Error::Encrypted(flpdf::EncryptedError::BadPassword)
)
}
fn run_empty_document_encryption_status() -> CliResult<()> {
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
fn run_is_encrypted(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<()> {
let encrypted = match probe_encryption(input, repair, password, suppress_warnings)? {
EncryptionProbe::Opened { encrypted } => encrypted,
EncryptionProbe::EncryptedAuthFailed => true,
};
if encrypted {
Ok(()) } else {
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
}
fn run_requires_password(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<()> {
match probe_encryption(input, repair, password, suppress_warnings)? {
EncryptionProbe::Opened { encrypted: false } => {
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
EncryptionProbe::Opened { encrypted: true } => {
Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}))
}
EncryptionProbe::EncryptedAuthFailed => {
Ok(())
}
}
}
fn run_show_encryption_key(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<()> {
let pdf = open_pdf_for_inspection(input, repair, password)?;
match pdf.encryption_file_key() {
Some(key) => {
logger_info(format!("{}\n", hex_lower(&key)))?;
finish_operation_warnings(&pdf, false)
}
None if pdf.is_encrypted() => Err("invalid password".into()),
None => Err("file is not encrypted; no encryption key to show".into()),
}
}
#[allow(clippy::too_many_arguments)]
fn run_show_encryption(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
show_encryption_key: bool,
empty: bool,
transform_options: InspectionTransformOptions,
verbose: bool,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(no_warn);
job.set_show_encryption_key(show_encryption_key);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
return finish_show_encryption(&mut job, &mut pdf, password.password_is_hex_key);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let file = File::open(&input).map_err(|error| open_error_with_file(&input, error.into()))?;
let mut job = new_cli_job(no_warn);
job.set_show_encryption_key(show_encryption_key);
let mut options = pdf_open_options(repair, password)?;
options.suppress_warnings = no_warn;
let mut pdf = job
.open_for_encryption_inspection_with_description(
BufReader::new(file),
path_description(&input),
options,
)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
if !(pdf.is_encrypted() && pdf.encryption_file_key().is_none()) {
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
}
finish_show_encryption(&mut job, &mut pdf, password.password_is_hex_key)
}
fn finish_show_encryption<R: Read + Seek>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
password_is_hex_key: bool,
) -> CliResult<()> {
job.show_encryption(pdf, password_is_hex_key)?;
job.record_document_warnings(pdf);
job.complete(false)?;
finish_job_exit_status(job.get_exit_code())
}
fn hex_lower(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 2);
for b in bytes {
out.push_str(&format!("{b:02x}"));
}
out
}
enum JobPdf {
File(Pdf<BufReader<File>>),
Json(Pdf<Cursor<Vec<u8>>>),
}
struct JsonJobRuntime<'a> {
input_identity: Option<&'a File>,
output_path: Option<&'a Path>,
standard_output: &'a mut Option<PipelineWriter>,
job: &'a mut QPDFJob,
}
fn apply_json_update<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
update_from_json: Option<&Path>,
) -> CliResult<()> {
if let Some(path) = update_from_json {
let source = File::open(path).map_err(|error| qpdf_json_input_open_error(path, error))?;
pdf.update_from_json(source, path_description(path))
.map_err(|error| json_error_with_file(path, Box::new(error)))?;
}
Ok(())
}
fn apply_json_update_with_job<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
update_from_json: Option<&Path>,
) -> CliResult<()> {
if let Some(path) = update_from_json {
let source = File::open(path).map_err(|error| qpdf_json_input_open_error(path, error))?;
job.update_from_json(pdf, source, path_description(path))
.map_err(|error| json_error_with_file(path, Box::new(error)))?;
}
Ok(())
}
fn open_job_pdf(
input: &Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
check_inspection: bool,
suppress_warnings: bool,
) -> CliResult<JobPdf> {
if json_input {
Ok(JobPdf::Json(open_json_pdf(
input,
update_from_json,
suppress_warnings,
)?))
} else {
let mut pdf = if check_inspection {
open_pdf_for_check_inspection(&input.to_path_buf(), repair, password)?
} else {
open_pdf_with_suppression(&input.to_path_buf(), repair, password, suppress_warnings)?
};
apply_json_update(&mut pdf, update_from_json)?;
Ok(JobPdf::File(pdf))
}
}
fn open_json_pdf(
input: &Path,
update_from_json: Option<&Path>,
suppress_warnings: bool,
) -> CliResult<Pdf<Cursor<Vec<u8>>>> {
let source = File::open(input).map_err(|error| qpdf_json_input_open_error(input, error))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(suppress_warnings);
let mut pdf = job
.create_from_json(source, path_description(input))
.map_err(|error| json_error_with_file(input, Box::new(error)))?;
apply_json_update(&mut pdf, update_from_json)?;
Ok(pdf)
}
fn open_pdf(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, false)
}
fn open_pdf_with_suppression(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, suppress_warnings)
}
fn open_page_source(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
stay_open: bool,
suppress_warnings: bool,
) -> CliResult<Pdf<Box<dyn flpdf::ReadSeek>>> {
let mut options = pdf_open_options(repair, password)?;
configure_document_logger(&mut options, input);
options.suppress_warnings = suppress_warnings;
let mut pdf = Pdf::<Box<dyn flpdf::ReadSeek>>::open_file_with_options(input, options)
.map_err(|error| open_error_with_file(input, actionable_password_error(error)))?;
pdf.root_handle()
.map_err(|error| error_with_file(input, actionable_password_error(error)))?;
pdf.set_input_source_stay_open(stay_open);
Ok(pdf)
}
fn open_pdf_from_file(
input: &Path,
file: File,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_file_impl(input, file, repair, password, suppress_warnings, false)
}
fn open_pdf_for_inspection(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
let file = File::open(input).map_err(|error| open_error_with_file(input, error.into()))?;
open_pdf_file_impl(input, file, repair, password, false, true)
}
fn open_pdf_for_check_inspection(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, true)
}
fn open_pdf_impl(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Pdf<BufReader<File>>> {
let file = File::open(input).map_err(|error| open_error_with_file(input, error.into()))?;
open_pdf_file_impl(input, file, repair, password, suppress_warnings, false)
}
fn open_pdf_file_impl(
input: &Path,
file: File,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
encryption_inspection: bool,
) -> CliResult<Pdf<BufReader<File>>> {
let mut options = pdf_open_options(repair, password)?;
if suppress_warnings {
options.suppress_warnings = true;
}
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(suppress_warnings);
let pdf = if encryption_inspection {
job.open_for_encryption_inspection_with_description(
BufReader::new(file),
path_description(input),
options,
)
} else {
job.open_with_description(BufReader::new(file), path_description(input), options)
}
.map_err(|error| error_with_file(input, actionable_password_error(error)))?;
Ok(pdf)
}
fn pdf_open_options(repair: bool, password: &PasswordArgs) -> CliResult<PdfOpenOptions> {
let password_bytes = if let Some(password) = password.password_bytes() {
password
} else if let Some(path) = &password.password_file {
read_password_file(path)?
} else {
Vec::new()
};
Ok(pdf_open_options_with_password_bytes(
repair,
password,
password_bytes,
))
}
fn read_password_file(path: &Path) -> std::io::Result<Vec<u8>> {
let bytes = if path == Path::new("-") {
let mut bytes = Vec::new();
std::io::stdin().read_to_end(&mut bytes)?;
bytes
} else {
std::fs::read(path)?
};
let first_newline = bytes.iter().position(|&byte| byte == b'\n');
let first_line_len = first_newline.unwrap_or(bytes.len());
let mut first_line = bytes[..first_line_len].to_vec();
if first_line.ends_with(b"\r") {
first_line.pop();
}
if first_newline.is_some_and(|index| index + 1 < bytes.len()) {
emit_logger_error(format!(
"{}: WARNING: all but the first line of the password file are ignored\n",
progname()
));
}
Ok(first_line)
}
fn pdf_open_options_with_password_bytes(
repair: bool,
password: &PasswordArgs,
password_bytes: Vec<u8>,
) -> PdfOpenOptions {
let recovery = password.recovery;
PdfOpenOptions {
repair: !recovery.suppress_recovery && (repair || PdfOpenOptions::default().repair),
ignore_xref_streams: recovery.ignore_xref_streams,
password: password_bytes,
password_mode: password.password_mode.into(),
suppress_password_recovery: password.suppress_password_recovery,
password_is_hex_key: password.password_is_hex_key,
verbose: password.verbose,
message_prefix: progname().into_bytes(),
..PdfOpenOptions::default()
}
}
fn cli_logger() -> QPDFLogger {
static LOGGER: OnceLock<QPDFLogger> = OnceLock::new();
LOGGER.get_or_init(QPDFLogger::create).clone()
}
static CLI_WARNING_EXIT_ZERO: OnceLock<bool> = OnceLock::new();
fn cli_warning_exit_zero() -> bool {
CLI_WARNING_EXIT_ZERO.get().copied().unwrap_or(false)
}
fn standard_save_writer() -> CliResult<PipelineWriter> {
standard_save_writer_for(&cli_logger())
}
fn standard_save_writer_for(logger: &QPDFLogger) -> CliResult<PipelineWriter> {
logger.save_to_standard_output(true)?;
Ok(PipelineWriter {
pipeline: logger.get_save()?,
})
}
fn prepare_pdf_standard_output(output: &Path) -> CliResult<Option<PipelineWriter>> {
if output.as_os_str() == "-" {
Ok(Some(standard_save_writer()?))
} else {
Ok(None)
}
}
fn prepare_page_operation_standard_output(
output: &Path,
page_ops: &PageOpArgs,
) -> CliResult<Option<PipelineWriter>> {
if output.as_os_str() == "-" && split_pages_active(page_ops.split_pages.as_deref()) {
return Err("--split-pages may not be used when writing to standard output".into());
}
prepare_pdf_standard_output(output)
}
fn logger_info(data: impl AsRef<[u8]>) -> CliResult<()> {
cli_logger().info(data)?;
Ok(())
}
fn logger_warn(data: impl AsRef<[u8]>) -> CliResult<()> {
cli_logger().warn(data)?;
Ok(())
}
fn emit_logger_info(data: impl AsRef<[u8]>) {
let _ = logger_info(data);
}
fn emit_logger_error(data: impl AsRef<[u8]>) {
if let Err(error) = cli_logger().error(data) {
eprintln!("flpdf: unable to write diagnostic: {error}"); }
}
fn configure_document_logger(options: &mut PdfOpenOptions, input: &Path) {
options.logger = Some(cli_logger());
options.description = path_description(input);
}
#[cfg(unix)]
fn path_description(input: &Path) -> Vec<u8> {
use std::os::unix::ffi::OsStrExt;
input.as_os_str().as_bytes().to_vec()
}
#[cfg(not(unix))]
fn path_description(input: &Path) -> Vec<u8> {
input.to_string_lossy().into_owned().into_bytes()
}
fn wrote_file_message(prefix: &str, output: &Path) -> Vec<u8> {
let mut message = format!("{prefix}: wrote file ").into_bytes();
message.extend_from_slice(&path_description(output));
message.push(b'\n');
message
}
fn progname() -> String {
std::env::var("FLPDF_PROGNAME")
.ok()
.filter(|name| !name.is_empty())
.unwrap_or_else(|| "flpdf".to_string())
}
fn diagnostic_location(input: &Path, offset: Option<u64>) -> String {
match offset {
Some(offset) => format!("{} (offset {offset})", input.display()),
None => input.display().to_string(),
}
}
fn finish_operation_warnings<R: Read + Seek>(pdf: &Pdf<R>, creates_output: bool) -> CliResult<()> {
finish_operation_warnings_with_prior(pdf, creates_output, false)
}
fn finish_operation_warnings_with_prior<R: Read + Seek>(
pdf: &Pdf<R>,
creates_output: bool,
prior_warnings: bool,
) -> CliResult<()> {
finish_warning_state(
prior_warnings || !pdf.repair_diagnostics().entries().is_empty(),
creates_output,
pdf.suppress_warnings(),
)
}
fn finish_job_exit_status(status: JobExitCode) -> CliResult<()> {
match status {
JobExitCode::Success => Ok(()),
JobExitCode::Error => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
JobExitCode::Warning => Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
})),
}
}
fn finish_check_job(result: std::result::Result<JobExitCode, CheckError>) -> CliResult<()> {
match result {
Ok(status) => finish_job_exit_status(status),
Err(CheckError::ErrorsDetected) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
Err(CheckError::Operation(error)) => Err(Box::new(error)),
}
}
fn finish_warning_state(has_warnings: bool, creates_output: bool, no_warn: bool) -> CliResult<()> {
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(no_warn);
if has_warnings {
job.record_warnings();
}
job.complete(creates_output)?;
finish_job_exit_status(job.get_exit_code())
}
fn emit_content_normalization_warnings(
input: &Path,
warning: ContentNormalizationWarning,
) -> CliResult<()> {
let location = diagnostic_location(input, warning.parsed_offset);
let mut message =
format!("WARNING: {location}: content normalization encountered bad tokens\n");
if warning.last_token_was_bad {
message.push_str(&format!(
"WARNING: {location}: normalized content ended with a bad token; \
you may be able to resolve this by coalescing content streams in \
combination with normalizing content. From the command line, \
specify --coalesce-contents\n"
));
}
message.push_str(&format!(
"WARNING: {location}: Resulting stream data may be corrupted but is may \
still useful for manual inspection. For more information on this \
warning, search for content normalization in the manual.\n"
));
logger_warn(message)
}
fn error_with_file(input: &Path, error: Box<dyn std::error::Error>) -> Box<dyn std::error::Error> {
let message = qpdf_path_error_message(error.as_ref());
Box::new(CliPathError {
path: path_description(input),
operation: None,
message,
source: error,
})
}
fn qpdf_path_error_message(error: &(dyn std::error::Error + 'static)) -> String {
let Some(flpdf_error) = error.downcast_ref::<flpdf::Error>() else {
return error.to_string();
};
let terminal = flpdf_error
.open_failure()
.map_or(flpdf_error, |(source, _)| source);
match terminal {
flpdf::Error::Parse { offset: 0, message }
if message == "unable to find trailer dictionary while recovering damaged file" =>
{
message.clone()
}
_ => error.to_string(),
}
}
fn open_error_with_file(
input: &Path,
error: Box<dyn std::error::Error>,
) -> Box<dyn std::error::Error> {
let io_error = error.downcast_ref::<std::io::Error>().or_else(|| {
match error.downcast_ref::<flpdf::Error>() {
Some(flpdf::Error::FileIo {
operation: "open",
source,
..
}) => Some(source),
_ => None,
}
});
let Some(io_error) = io_error else {
return error_with_file(input, error);
};
let message = qpdf_open_io_error_message(io_error);
Box::new(CliPathError {
path: path_description(input),
operation: Some("open"),
message,
source: error,
})
}
fn qpdf_open_io_error_message(error: &std::io::Error) -> String {
let message = match error.kind() {
std::io::ErrorKind::NotFound => Some("No such file or directory"),
std::io::ErrorKind::PermissionDenied => Some("Permission denied"),
std::io::ErrorKind::AlreadyExists => Some("File exists"),
std::io::ErrorKind::InvalidInput => Some("Invalid argument"),
std::io::ErrorKind::IsADirectory => Some("Is a directory"),
std::io::ErrorKind::NotADirectory => Some("Not a directory"),
_ => None,
};
if let Some(message) = message {
return message.to_owned();
}
let rendered = error.to_string();
error
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered)
.to_owned()
}
fn json_error_with_file(
input: &Path,
error: Box<dyn std::error::Error>,
) -> Box<dyn std::error::Error> {
let path = path_description(input);
let lossy_path = String::from_utf8_lossy(&path);
let message = error
.to_string()
.strip_prefix(&format!("{lossy_path}: "))
.map_or_else(|| error.to_string(), str::to_owned);
Box::new(CliPathError {
path,
operation: None,
message,
source: error,
})
}
fn actionable_password_error(error: flpdf::Error) -> Box<dyn std::error::Error> {
if is_bad_password_error(&error) {
return "invalid password".into();
}
error.into()
}
fn parse_pdf_date_arg(value: &str) -> CliResult<Vec<u8>> {
let bytes = value.as_bytes();
let valid_body =
bytes.len() >= 16 && bytes[..2] == *b"D:" && bytes[2..16].iter().all(u8::is_ascii_digit);
let valid_suffix = match bytes.len() {
16 => true,
17 => bytes[16] == b'Z',
23 => {
matches!(bytes[16], b'+' | b'-')
&& bytes[17].is_ascii_digit()
&& bytes[18].is_ascii_digit()
&& bytes[19] == b'\''
&& bytes[20].is_ascii_digit()
&& bytes[21].is_ascii_digit()
&& bytes[22] == b'\''
}
_ => false,
};
if !valid_body || !valid_suffix {
return Err(format!("{value} is not a valid PDF timestamp").into());
}
Ok(bytes.to_vec())
}
struct AddAttachmentArgs {
file: PathBuf,
key: Option<Vec<u8>>,
filename: Option<Vec<u8>>,
mimetype: Option<Vec<u8>>,
description: Option<Vec<u8>>,
creation_date: Option<Vec<u8>>,
mod_date: Option<Vec<u8>>,
replace: bool,
}
fn parse_add_attachment_segment<T: RawCliArg>(tokens: Vec<T>) -> CliResult<AddAttachmentArgs> {
let mut iter = tokens.into_iter();
let file: PathBuf = iter
.next()
.ok_or("add attachment: no file specified")?
.os_string()
.into();
let mut key: Option<Vec<u8>> = None;
let mut filename: Option<Vec<u8>> = None;
let mut mimetype: Option<Vec<u8>> = None;
let mut description: Option<Vec<u8>> = None;
let mut creation_date: Option<Vec<u8>> = None;
let mut mod_date: Option<Vec<u8>> = None;
let mut replace = false;
for token in iter {
let token_bytes = token.raw_bytes();
if let Some(v) = token_bytes.strip_prefix(b"--key=") {
key = Some(v.to_vec());
} else if let Some(v) = token_bytes.strip_prefix(b"--filename=") {
filename = Some(v.to_vec());
} else if let Some(v) = token_bytes.strip_prefix(b"--mimetype=") {
let bytes = v.to_vec();
if !bytes.contains(&b'/') {
return Err("mime type should be specified as type/subtype".into());
}
mimetype = Some(bytes);
} else if let Some(v) = token_bytes.strip_prefix(b"--description=") {
description = Some(v.to_vec());
} else if let Some(v) = token_bytes.strip_prefix(b"--creationdate=") {
let value = std::str::from_utf8(v)
.map_err(|_| "--add-attachment --creationdate must be valid UTF-8")?;
creation_date = Some(parse_pdf_date_arg(value)?);
} else if let Some(v) = token_bytes.strip_prefix(b"--moddate=") {
let value = std::str::from_utf8(v)
.map_err(|_| "--add-attachment --moddate must be valid UTF-8")?;
mod_date = Some(parse_pdf_date_arg(value)?);
} else if token_bytes == b"--replace" {
replace = true;
} else {
return Err(format!(
"--add-attachment: unknown sub-flag or unexpected token {:?}",
token.os_string()
)
.into());
}
}
Ok(AddAttachmentArgs {
file,
key,
filename,
mimetype,
description,
creation_date,
mod_date,
replace,
})
}
struct CopyAttachmentsArgs {
file: PathBuf,
password: Vec<u8>,
prefix: Option<Vec<u8>>,
}
fn parse_copy_attachments_segment<T: RawCliArg>(tokens: Vec<T>) -> CliResult<CopyAttachmentsArgs> {
let mut iter = tokens.into_iter();
let file: PathBuf = iter
.next()
.ok_or("--copy-attachments-from: missing FILE argument")?
.os_string()
.into();
let mut password: Vec<u8> = Vec::new();
let mut prefix: Option<Vec<u8>> = None;
for token in iter {
let token_bytes = token.raw_bytes();
if let Some(v) = token_bytes.strip_prefix(b"--password=") {
password = v.to_vec();
} else if let Some(v) = token_bytes.strip_prefix(b"--prefix=") {
prefix = Some(v.to_vec());
} else {
return Err(format!(
"--copy-attachments-from: unknown sub-flag or unexpected token {:?}",
token.os_string()
)
.into());
}
}
Ok(CopyAttachmentsArgs {
file,
password,
prefix,
})
}
fn path_basename(path: &std::path::Path) -> CliResult<Vec<u8>> {
path.file_name()
.ok_or_else(|| format!("cannot determine filename from path {:?}", path).into())
.map(arg_parser::os_bytes)
}
#[allow(clippy::too_many_arguments)]
fn configure_attachment_job(
input: &Path,
output: Option<&Path>,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
verbose: bool,
suppress_warnings: bool,
remove_restrictions: bool,
linearize: bool,
linearize_pass1: Option<&Path>,
writer_options: &WriterOptions,
transform_options: InspectionTransformOptions,
) -> CliResult<QPDFJob> {
let mut job = new_cli_job(suppress_warnings);
job.set_input_file(input.to_path_buf())?;
if replace_input {
if output.is_some() {
return Err(UsageError::new(
"replace-input can't be used since output file has already been given",
)
.into());
}
job.config().replace_input()?;
} else {
job.set_output_file(output.ok_or_else(missing_output_usage_error)?.to_path_buf())?;
}
let input_options = pdf_open_options(repair, password)?;
job.set_password(input_options.password);
job.set_password_mode(password.password_mode.into());
job.set_password_is_hex_key(password.password_is_hex_key);
job.set_suppress_password_recovery(password.suppress_password_recovery);
job.set_suppress_recovery(password.recovery.suppress_recovery);
job.set_ignore_xref_streams(password.recovery.ignore_xref_streams);
job.set_allow_weak_crypto(writer_options.allow_weak_crypto);
job.set_progress(writer_options.progress);
job.set_verbose(verbose);
job.set_linearization(linearize, linearize_pass1.map(Path::to_path_buf));
configure_top_level_inspection_transformations(
&mut job,
transform_options,
verbose,
remove_restrictions,
false,
);
Ok(job)
}
fn run_configured_attachment_job(
mut job: QPDFJob,
writer_options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<()> {
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
job.set_writer_configuration(writer_configuration_unnormalized(
writer_options,
linearize,
linearize_pass1,
)?);
match job.write_qpdf(&mut pdf) {
Ok(()) => finish_job_exit_status(job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
#[allow(clippy::too_many_arguments)]
fn run_add_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
segments: Vec<Vec<Vec<u8>>>,
verbose: bool,
suppress_warnings: bool,
remove_restrictions: bool,
linearize: bool,
linearize_pass1: Option<&Path>,
writer_options: WriterOptions,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
let input = input.ok_or_else(missing_input_usage_error)?;
let attachment_options = segments
.into_iter()
.map(|tokens| {
let args = parse_add_attachment_segment(tokens)?;
let basename = path_basename(&args.file)?;
let key = args.key.unwrap_or_else(|| basename.clone());
let filename = args.filename.unwrap_or_else(|| basename.clone());
Ok(AttachmentAddOptions {
path: args.file,
key,
filename,
mimetype: args.mimetype,
description: args.description,
creation_date: args.creation_date,
modification_date: args.mod_date,
replace: args.replace,
verbose,
})
})
.collect::<CliResult<Vec<_>>>()?;
if let Some(output) = output.as_deref() {
let _ = prepare_pdf_standard_output(output)?;
}
let mut job = configure_attachment_job(
&input,
output.as_deref(),
replace_input,
repair,
password,
verbose,
suppress_warnings,
remove_restrictions,
linearize,
linearize_pass1,
&writer_options,
transform_options,
)?;
{
let mut configuration = job.config();
for option in attachment_options {
configuration.add_attachment(option);
}
}
run_configured_attachment_job(job, &writer_options, linearize, linearize_pass1)
}
#[allow(clippy::too_many_arguments)]
fn run_remove_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
keys: &[OsString],
verbose: bool,
suppress_warnings: bool,
remove_restrictions: bool,
linearize: bool,
linearize_pass1: Option<&Path>,
writer_options: WriterOptions,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
let input = input.ok_or_else(missing_input_usage_error)?;
if let Some(output) = output.as_deref() {
let _ = prepare_pdf_standard_output(output)?;
}
let mut job = configure_attachment_job(
&input,
output.as_deref(),
replace_input,
repair,
password,
verbose,
suppress_warnings,
remove_restrictions,
linearize,
linearize_pass1,
&writer_options,
transform_options,
)?;
{
let mut configuration = job.config();
for key in keys {
configuration.remove_attachment(arg_parser::os_bytes(key));
}
}
run_configured_attachment_job(job, &writer_options, linearize, linearize_pass1)
}
fn run_list_attachments(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
verbose: bool,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let status = job.list_attachments(&mut pdf, verbose)?;
return finish_job_exit_status(status);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
job.set_input_name_bytes(path_description(&input));
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let status = job.list_attachments(&mut pdf, verbose)?;
finish_job_exit_status(status)
}
fn reserve_show_attachment_output() -> CliResult<()> {
cli_logger().save_to_standard_output(true)?;
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn run_show_attachment(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
key: &OsStr,
verbose: bool,
suppress_warnings: bool,
empty: bool,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
reserve_show_attachment_output()?;
if empty {
reject_empty_inspection_output(input.as_deref())?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = create_empty_primary_document(&mut job, None)?;
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let key = arg_parser::os_bytes(key);
let status = job.show_attachment(&mut pdf, &key)?;
return finish_job_exit_status(status);
}
let input = input.ok_or_else(missing_input_usage_error)?;
let mut job = new_cli_job(suppress_warnings);
let mut pdf = open_pdf_with_suppression(&input, repair, password, suppress_warnings)?;
job.set_input_name_bytes(path_description(&input));
apply_inspection_transformations(&mut job, &mut pdf, transform_options, verbose)?;
let key = arg_parser::os_bytes(key);
let status = job.show_attachment(&mut pdf, &key)?;
finish_job_exit_status(status)
}
#[allow(clippy::too_many_arguments)]
fn run_copy_attachments_from(
input: Option<PathBuf>,
output: Option<PathBuf>,
replace_input: bool,
repair: bool,
password: &PasswordArgs,
groups: Vec<Vec<Vec<u8>>>,
verbose: bool,
suppress_warnings: bool,
remove_restrictions: bool,
linearize: bool,
linearize_pass1: Option<&Path>,
writer_options: WriterOptions,
transform_options: InspectionTransformOptions,
) -> CliResult<()> {
let input = input.ok_or_else(missing_input_usage_error)?;
let donor_args = groups
.into_iter()
.map(parse_copy_attachments_segment)
.collect::<CliResult<Vec<_>>>()?;
if let Some(output) = output.as_deref() {
let _ = prepare_pdf_standard_output(output)?;
}
let mut job = configure_attachment_job(
&input,
output.as_deref(),
replace_input,
repair,
password,
verbose,
suppress_warnings,
remove_restrictions,
linearize,
linearize_pass1,
&writer_options,
transform_options,
)?;
{
let mut configuration = job.config();
for args in donor_args {
configuration.copy_attachments_from(
args.file,
args.password,
args.prefix.unwrap_or_default(),
);
}
}
run_configured_attachment_job(job, &writer_options, linearize, linearize_pass1)
}
#[cfg(test)]
mod tests {
use super::*;
use flpdf::pipeline::{Pipeline, PipelineResult};
use std::sync::{Arc, Mutex};
struct ChunkRecordingSink {
chunks: Arc<Mutex<Vec<Vec<u8>>>>,
}
impl Pipeline for ChunkRecordingSink {
fn identifier(&self) -> &str {
"chunk recording sink"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
self.chunks.lock().unwrap().push(data.to_vec());
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
struct FailingPasswordNoticeSink;
impl Pipeline for FailingPasswordNoticeSink {
fn identifier(&self) -> &str {
"failing password notice sink"
}
fn write(&mut self, _data: &[u8]) -> PipelineResult<()> {
Err(flpdf::PipelineError::runtime(
"password notice sink failure",
))
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
#[test]
fn direct_password_notice_logging_propagates_info_sink_failure() {
let logger = QPDFLogger::create();
logger.set_info(Some(PipelineHandle::new(FailingPasswordNoticeSink)));
let error =
emit_password_write_notices(&logger, "flpdf", [PasswordWriteNotice::Info], true)
.expect_err("direct CLI password notice logging must be fallible");
assert_eq!(error.to_string(), "password notice sink failure");
}
#[test]
fn direct_password_notice_logging_propagates_warning_sink_failure() {
let logger = QPDFLogger::create();
logger.set_error(Some(PipelineHandle::new(FailingPasswordNoticeSink)));
let error =
emit_password_write_notices(&logger, "flpdf", [PasswordWriteNotice::Warning], true)
.expect_err("direct CLI warning logging must be fallible");
assert_eq!(error.to_string(), "password notice sink failure");
}
#[test]
fn direct_password_notice_logging_routes_warning_to_error_sink() {
let chunks = Arc::new(Mutex::new(Vec::<Vec<u8>>::new()));
let logger = QPDFLogger::create();
logger.set_error(Some(PipelineHandle::new(ChunkRecordingSink {
chunks: Arc::clone(&chunks),
})));
emit_password_write_notices(&logger, "flpdf", [PasswordWriteNotice::Warning], true)
.expect("warning notice must be written to the error sink");
assert_eq!(
chunks.lock().unwrap().concat(),
b"flpdf: WARNING: supplied password looks like a Unicode password with characters not allowed in passwords for 40-bit and 128-bit encryption; most readers will not be able to open this file with the supplied password. (Use --password-mode=bytes to suppress this warning and use the password anyway.)\n"
);
}
fn strs(v: &[&str]) -> Vec<String> {
v.iter().map(|s| s.to_string()).collect()
}
fn os_strs(v: &[&str]) -> Vec<OsString> {
v.iter().map(|s| OsString::from(*s)).collect()
}
#[test]
fn cli_flatten_modes_use_the_canonical_job_masks() {
assert_eq!(
CliFlattenMode::All.flags(),
FlattenAnnotationsMode::All.qpdf_flags()
);
assert_eq!(
CliFlattenMode::Screen.flags(),
FlattenAnnotationsMode::Screen.qpdf_flags()
);
assert_eq!(
CliFlattenMode::Print.flags(),
FlattenAnnotationsMode::Print.qpdf_flags()
);
}
#[test]
fn preprocess_qpdf_args_routes_raw_segments_through_arg_parser() {
let PreprocessedArgs {
residual_args: residual,
overlay_specs,
attachment_segments,
..
} = preprocess_qpdf_args(strs(&["flpdf", "--overlay", "source.pdf", "--to=1", "--"]))
.expect("qpdf preprocessing should succeed");
assert_eq!(residual, os_strs(&["flpdf"]));
assert_eq!(overlay_specs.len(), 1);
assert_eq!(overlay_specs[0].file, "source.pdf");
assert_eq!(overlay_specs[0].to.as_deref(), Some("1"));
assert!(attachment_segments.is_empty());
}
#[test]
fn preprocess_qpdf_args_keeps_raw_top_level_password_for_clap_override() {
let directory = tempfile::tempdir().expect("create argument-file directory");
let path = directory.path().join("args");
std::fs::write(&path, b"--password=top-\xff\ninput.pdf\n").expect("write argument file");
let preprocessed = preprocess_qpdf_args(vec![
OsString::from("flpdf"),
OsString::from(format!("@{}", path.display())),
])
.expect("qpdf preprocessing should preserve raw password bytes");
let expected = b"top-\xff".to_vec();
assert_eq!(
preprocessed.raw_overrides.password.as_deref(),
Some(expected.as_slice())
);
let mut args = cli_parse_from(preprocessed.residual_args);
apply_raw_overrides(&mut args, preprocessed.raw_overrides);
assert_eq!(args.password.password_bytes(), Some(expected));
}
#[test]
fn raw_password_override_reaches_pdf_open_options_without_projection() {
let mut password = PasswordArgs {
password: Some(OsString::from("replacement")),
..PasswordArgs::default()
};
password.raw_password = Some(b"raw-\xff".to_vec());
let options = pdf_open_options(false, &password).expect("password options should build");
assert_eq!(options.password, b"raw-\xff");
}
#[test]
fn preprocess_qpdf_args_keeps_raw_encrypt_and_donor_passwords() {
let directory = tempfile::tempdir().expect("create argument-file directory");
let encrypt_path = directory.path().join("encrypt-args");
std::fs::write(
&encrypt_path,
b"--encrypt\nuser-\xff\nowner\n128\n--\ninput.pdf\noutput.pdf\n",
)
.expect("write encryption argument file");
let preprocessed = preprocess_qpdf_args(vec![
OsString::from("flpdf"),
OsString::from(format!("@{}", encrypt_path.display())),
])
.expect("qpdf encryption segment should be expanded");
assert_eq!(
preprocessed.raw_overrides.raw_encrypt.as_ref().unwrap()[0],
b"user-\xff"
);
let parsed_encrypt =
parse_encrypt_segment(preprocessed.raw_overrides.raw_encrypt.as_ref().unwrap())
.expect("raw encrypt passwords should reach the byte parser");
assert_eq!(parsed_encrypt.params.user_password, b"user-\xff");
let donor_path = directory.path().join("donor-args");
std::fs::write(
&donor_path,
b"--encryption-file-password=donor-\xff\ninput.pdf\noutput.pdf\n",
)
.expect("write donor argument file");
let donor = preprocess_qpdf_args(vec![
OsString::from("flpdf"),
OsString::from(format!("@{}", donor_path.display())),
])
.expect("qpdf donor password should be expanded");
assert_eq!(
donor.raw_overrides.encryption_file_password.as_deref(),
Some(b"donor-\xff".as_slice())
);
}
#[test]
fn preprocess_qpdf_args_rejects_a_second_pages_group_like_qpdf() {
let error = match preprocess_qpdf_args(strs(&[
"flpdf", "--pages", "a.pdf", "1", "--", "--pages", "a.pdf", "2", "--", "in.pdf",
"out.pdf",
])) {
Ok(_) => panic!("qpdf rejects a second --pages group"),
Err(error) => error,
};
let usage = find_usage_error(error.as_ref()).expect("a qpdf usage error");
assert_eq!(usage.to_string(), "--pages may only be specified one time");
}
#[test]
fn preprocess_qpdf_args_preserves_every_copy_attachments_group() {
let preprocessed = preprocess_qpdf_args(strs(&[
"flpdf",
"--copy-attachments-from",
"don0.pdf",
"--",
"--copy-attachments-from",
"don1.pdf",
"--",
"in.pdf",
"out.pdf",
]))
.expect("qpdf accepts repeated donor groups");
assert_eq!(
preprocessed.raw_overrides.raw_copy_attachments_from,
Some(vec![vec![b"don0.pdf".to_vec()], vec![b"don1.pdf".to_vec()],])
);
}
#[test]
fn preprocess_qpdf_args_does_not_promote_segment_password_to_top_level() {
let directory = tempfile::tempdir().expect("create argument-file directory");
let path = directory.path().join("pages-args");
std::fs::write(
&path,
b"--pages\nsource.pdf\n--password=page-\xff\n--\ninput.pdf\noutput.pdf\n",
)
.expect("write page argument file");
let preprocessed = preprocess_qpdf_args(vec![
OsString::from("flpdf"),
OsString::from(format!("@{}", path.display())),
])
.expect("qpdf page segment should be expanded");
assert!(preprocessed.raw_overrides.password.is_none());
assert_eq!(
preprocessed.raw_overrides.raw_pages.as_ref().unwrap()[1],
b"--password=page-\xff"
);
}
#[test]
fn raw_passwords_reach_pages_overlay_and_copy_segment_parsers() {
let page_tokens = vec![b"source.pdf".to_vec(), b"--password=page-\xff".to_vec()];
let pages = parse_pages_segment(&page_tokens).expect("page segment should parse");
assert_eq!(pages[0].raw_password, Some(b"page-\xff".to_vec()));
let overlay = parse_overlay_segment(
OverlayKind::Overlay,
&[b"source.pdf".to_vec(), b"--password=overlay-\xff".to_vec()],
)
.expect("overlay segment should parse");
assert_eq!(overlay.raw_password, Some(b"overlay-\xff".to_vec()));
let copy = parse_copy_attachments_segment(vec![
b"source.pdf".to_vec(),
b"--password=copy-\xff".to_vec(),
])
.expect("copy-attachments segment should parse");
assert_eq!(copy.password, b"copy-\xff".to_vec());
}
#[test]
fn pages_empty_range_can_be_replaced_before_a_nonempty_range() {
let pages = parse_pages_segment(&[
b"source.pdf".to_vec(),
b"--range=".to_vec(),
b"--range=1".to_vec(),
])
.expect("qpdf permits an empty range sentinel before a replacement");
assert_eq!(pages[0].range, "1");
}
#[test]
fn standard_save_writer_rejects_stdout_after_info_use() {
let logger = QPDFLogger::create();
logger.info([]).unwrap();
let error = standard_save_writer_for(&logger).err().unwrap();
assert_eq!(
error.to_string(),
"QPDFLogger: called setSave on standard output after standard output has already been used"
);
}
#[test]
fn json_input_open_error_uses_qpdf_not_found_wording() {
let error = qpdf_json_input_open_error(
Path::new("missing.json"),
std::io::Error::from(std::io::ErrorKind::NotFound),
);
assert_eq!(
error.to_string(),
"open missing.json: No such file or directory"
);
}
#[test]
fn open_error_with_file_keeps_non_io_errors_outside_open_prefix() {
let error = open_error_with_file(
Path::new("bad.pdf"),
flpdf::Error::parse(0, "malformed PDF").into(),
);
assert_eq!(
error.to_string(),
"bad.pdf: parse error at byte 0: malformed PDF"
);
}
#[test]
fn qpdf_open_io_error_uses_portable_permission_text() {
let error = std::io::Error::from(std::io::ErrorKind::PermissionDenied);
assert_eq!(qpdf_open_io_error_message(&error), "Permission denied");
let error = std::io::Error::from(std::io::ErrorKind::AlreadyExists);
assert_eq!(qpdf_open_io_error_message(&error), "File exists");
let error = std::io::Error::other("native fallback");
assert_eq!(qpdf_open_io_error_message(&error), "native fallback");
}
#[test]
fn parse_add_attachment_rejects_mimetype_without_type_subtype_separator() {
let Err(error) =
parse_add_attachment_segment(strs(&["payload.txt", "--mimetype=textplain"]))
else {
panic!("the CLI parser must reject a mimetype without a slash"); };
assert_eq!(
error.to_string(),
"mime type should be specified as type/subtype"
);
}
#[cfg(unix)]
#[test]
fn attachment_segment_paths_preserve_non_utf8_bytes() {
use std::os::unix::ffi::{OsStrExt, OsStringExt};
let add =
parse_add_attachment_segment(vec![OsString::from_vec(b"payload-\xff.bin".to_vec())])
.expect("raw attachment path should parse");
assert_eq!(add.file.as_os_str().as_bytes(), b"payload-\xff.bin");
let copy =
parse_copy_attachments_segment(vec![OsString::from_vec(b"source-\xff.pdf".to_vec())])
.expect("raw copy source path should parse");
assert_eq!(copy.file.as_os_str().as_bytes(), b"source-\xff.pdf");
}
#[cfg(unix)]
#[test]
fn overlay_file_option_preserves_non_utf8_bytes() {
use std::os::unix::ffi::{OsStrExt, OsStringExt};
let token = OsString::from_vec(b"--file=overlay-\xff.pdf".to_vec());
let spec = parse_overlay_segment(OverlayKind::Overlay, &[token])
.expect("raw overlay path should parse");
assert_eq!(spec.file.as_bytes(), b"overlay-\xff.pdf");
}
#[test]
fn cli_command_builds_on_a_small_stack() {
let command = std::thread::Builder::new()
.name("small-stack-cli-command".to_owned())
.stack_size(512 * 1024)
.spawn(cli_command)
.expect("small-stack thread should start")
.join()
.expect("Cli::command must not overflow a small stack");
assert_eq!(command.get_name(), "flpdf");
}
#[test]
fn cli_parse_from_builds_on_a_small_stack() {
let args = std::thread::Builder::new()
.name("small-stack-cli-parse".to_owned())
.stack_size(512 * 1024)
.spawn(|| cli_parse_from(vec![OsString::from("flpdf")]))
.expect("small-stack thread should start")
.join()
.expect("Cli::parse_from must not overflow a small stack");
assert!(args.command.is_none());
}
#[test]
fn show_pages_writes_each_logical_line_incrementally() {
let chunks = Arc::new(Mutex::new(Vec::<Vec<u8>>::new()));
let logger = QPDFLogger::create();
let mut sink = ChunkRecordingSink {
chunks: Arc::clone(&chunks),
};
assert_eq!(sink.identifier(), "chunk recording sink");
sink.finish().unwrap();
logger.set_info(Some(PipelineHandle::new(sink)));
let mut pdf = Pdf::open_mem_owned(
include_bytes!("../../../tests/fixtures/compat/one-page.pdf").to_vec(),
)
.unwrap();
let mut job = QPDFJob::new();
job.set_logger(logger);
assert_eq!(job.show_pages(&mut pdf).unwrap(), JobExitCode::Success);
let chunks = chunks.lock().unwrap();
assert_eq!(chunks.len(), 3);
assert_eq!(chunks.concat(), b"page 1: 3 0 R\n content:\n 7 0 R\n");
}
#[test]
fn probe_encryption_classifies_bad_password_after_repair_warnings() {
let mut input =
include_bytes!("../../../tests/fixtures/compat/encrypted-r4-three-page.pdf").to_vec();
let xref = input
.windows(4)
.position(|window| window == b"xref")
.expect("encrypted fixture should contain an xref keyword");
input[xref + 2] = b'X';
let directory = tempfile::tempdir().expect("temporary directory");
let path = directory.path().join("damaged-encrypted.pdf");
std::fs::write(&path, input).expect("write damaged encrypted fixture");
let outcome = probe_encryption(
&path,
true,
&PasswordArgs {
password: Some("wrong".to_owned().into()),
..PasswordArgs::default()
},
false,
);
assert!(matches!(outcome, Ok(EncryptionProbe::EncryptedAuthFailed)));
}
#[test]
fn probe_encryption_prefixes_a_dangling_root_error_with_the_input_path() {
let input = b"%PDF-1.4\nxref\n0 1\n0000000000 65535 f \ntrailer\n<< /Size 1 >>\nstartxref\n9\n%%EOF\n";
let directory = tempfile::tempdir().expect("temporary directory");
let path = directory.path().join("missing-root.pdf");
std::fs::write(&path, input).expect("write missing-root fixture");
let Err(error) = probe_encryption(&path, false, &PasswordArgs::default(), false) else {
panic!("a missing /Root must be a hard error");
};
assert!(
error.to_string().contains(&path.display().to_string()),
"error should carry the input path like other open boundaries: {error}"
);
assert!(error
.to_string()
.contains("unable to find /Root dictionary"));
}
#[cfg(unix)]
#[test]
fn verified_json_output_rejects_hardlink_swapped_after_path_check() {
let temp = tempfile::tempdir().unwrap();
let input_path = temp.path().join("input.pdf");
let output_path = temp.path().join("output.json");
let original = b"input bytes must survive".to_vec();
std::fs::write(&input_path, &original).unwrap();
std::fs::write(&output_path, b"distinct output").unwrap();
reject_same_json_output(&input_path, &output_path).unwrap();
std::fs::remove_file(&output_path).unwrap();
std::fs::hard_link(&input_path, &output_path).unwrap();
let input_file = File::open(&input_path).unwrap();
let error = open_verified_json_output(Some(&input_file), &output_path).unwrap_err();
assert!(error
.to_string()
.contains("input file and output file are the same"));
assert_eq!(std::fs::read(&input_path).unwrap(), original);
}
#[test]
fn overlay_bare_file() {
let spec = parse_overlay_segment(OverlayKind::Overlay, &strs(&["over.pdf"])).unwrap();
assert_eq!(
spec,
OverlaySpec {
kind: OverlayKind::Overlay,
file: "over.pdf".into(),
password: None,
raw_password: None,
from: None,
to: None,
repeat: None,
}
);
}
#[test]
fn underlay_bare_file() {
let spec = parse_overlay_segment(OverlayKind::Underlay, &strs(&["under.pdf"])).unwrap();
assert_eq!(spec.kind, OverlayKind::Underlay);
assert_eq!(spec.file, "under.pdf");
}
#[test]
fn overlay_file_flag_form() {
let spec =
parse_overlay_segment(OverlayKind::Overlay, &strs(&["--file=over.pdf"])).unwrap();
assert_eq!(spec.file, "over.pdf");
assert_eq!(spec.password, None);
}
#[test]
fn overlay_password() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["over.pdf", "--password=secret"]),
)
.unwrap();
assert_eq!(spec.file, "over.pdf");
assert_eq!(spec.password, Some("secret".into()));
}
#[test]
fn overlay_from_to_repeat() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--from=1-3", "--to=2-4", "--repeat=1"]),
)
.unwrap();
assert_eq!(spec.from, Some("1-3".into()));
assert_eq!(spec.to, Some("2-4".into()));
assert_eq!(spec.repeat, Some("1".into()));
}
#[test]
fn overlay_all_flags_via_file_flag() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&[
"--file=src.pdf",
"--password=pw",
"--to=1",
"--from=1-z",
"--repeat=z",
]),
)
.unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.password, Some("pw".into()));
assert_eq!(spec.to, Some("1".into()));
assert_eq!(spec.from, Some("1-z".into()));
assert_eq!(spec.repeat, Some("z".into()));
}
#[test]
fn overlay_empty_tokens_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &[] as &[String])
.unwrap_err()
.to_string();
assert_eq!(err, "overlay file not specified");
}
#[test]
fn overlay_missing_file_with_only_sub_options_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["--password=pw"]))
.unwrap_err()
.to_string();
assert_eq!(err, "overlay file not specified");
}
#[test]
fn overlay_duplicate_file_bare_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["a.pdf", "b.pdf"]))
.unwrap_err()
.to_string();
assert_eq!(err, "overlay file already specified");
}
#[test]
fn overlay_duplicate_file_flag_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["--file=a.pdf", "--file=b.pdf"]),
)
.unwrap_err()
.to_string();
assert_eq!(err, "overlay file already specified");
}
#[test]
fn overlay_duplicate_file_mixed_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["a.pdf", "--file=b.pdf"]))
.unwrap_err()
.to_string();
assert_eq!(err, "overlay file already specified");
}
#[test]
fn overlay_repeated_to_uses_last_value() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--to=1", "--to=2"]),
)
.unwrap();
assert_eq!(spec.to.as_deref(), Some("2"));
}
#[test]
fn overlay_repeated_from_uses_last_value() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--from=1", "--from=2"]),
)
.unwrap();
assert_eq!(spec.from.as_deref(), Some("2"));
}
#[test]
fn overlay_repeated_repeat_uses_last_value() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--repeat=1", "--repeat=z"]),
)
.unwrap();
assert_eq!(spec.repeat.as_deref(), Some("z"));
}
#[test]
fn overlay_unknown_flag_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["src.pdf", "--bogus=x"]))
.unwrap_err()
.to_string();
assert_eq!(
err,
"unrecognized argument --bogus=x (underlay/overlay options must be terminated with --)"
);
}
#[test]
fn underlay_unknown_flag_error_prefix() {
let err = parse_overlay_segment(OverlayKind::Underlay, &strs(&["src.pdf", "--unknown"]))
.unwrap_err()
.to_string();
assert_eq!(
err,
"unrecognized argument --unknown (underlay/overlay options must be terminated with --)"
);
}
#[test]
fn overlay_invalid_range_to_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["src.pdf", "--to=abc!"]))
.unwrap_err()
.to_string();
assert!(err.contains("invalid --to="), "got: {err}");
}
#[test]
fn overlay_invalid_range_from_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["src.pdf", "--from=abc!"]))
.unwrap_err()
.to_string();
assert!(err.contains("invalid --from="), "got: {err}");
}
#[test]
fn overlay_invalid_range_repeat_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["src.pdf", "--repeat=abc!"]))
.unwrap_err()
.to_string();
assert!(err.contains("invalid --repeat="), "got: {err}");
}
#[test]
fn overlay_option_before_file_to_ok() {
let spec =
parse_overlay_segment(OverlayKind::Overlay, &strs(&["--to=1", "src.pdf"])).unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.to, Some("1".into()));
assert_eq!(spec.from, None);
assert_eq!(spec.repeat, None);
assert_eq!(spec.password, None);
}
#[test]
fn overlay_option_before_file_from_ok() {
let spec =
parse_overlay_segment(OverlayKind::Overlay, &strs(&["--from=1", "src.pdf"])).unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.from, Some("1".into()));
}
#[test]
fn overlay_option_before_file_repeat_ok() {
let spec =
parse_overlay_segment(OverlayKind::Overlay, &strs(&["--repeat=1", "src.pdf"])).unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.repeat, Some("1".into()));
}
#[test]
fn overlay_option_before_file_password_ok() {
let spec =
parse_overlay_segment(OverlayKind::Overlay, &strs(&["--password=pw", "src.pdf"]))
.unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.password, Some("pw".into()));
}
#[test]
fn overlay_options_mixed_around_file_ok() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&[
"--password=pw",
"--from=1",
"src.pdf",
"--to=2",
"--repeat=z",
]),
)
.unwrap();
assert_eq!(spec.file, "src.pdf");
assert_eq!(spec.password, Some("pw".into()));
assert_eq!(spec.from, Some("1".into()));
assert_eq!(spec.to, Some("2".into()));
assert_eq!(spec.repeat, Some("z".into()));
}
#[test]
fn underlay_option_before_file_ok() {
let spec = parse_overlay_segment(
OverlayKind::Underlay,
&strs(&["--to=1", "--from=2", "under.pdf"]),
)
.unwrap();
assert_eq!(spec.kind, OverlayKind::Underlay);
assert_eq!(spec.file, "under.pdf");
assert_eq!(spec.to, Some("1".into()));
assert_eq!(spec.from, Some("2".into()));
}
#[test]
fn overlay_repeated_to_before_file_uses_last_value() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["--to=1", "src.pdf", "--to=2"]),
)
.unwrap();
assert_eq!(spec.to.as_deref(), Some("2"));
}
#[test]
fn overlay_invalid_range_before_file_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["--to=abc!", "src.pdf"]))
.unwrap_err()
.to_string();
assert!(err.contains("invalid --to="), "got: {err}");
}
#[test]
fn overlay_repeated_password_uses_last_value() {
let spec = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--password=a", "--password=b"]),
)
.unwrap();
assert_eq!(spec.password.as_deref(), Some(OsStr::new("b")));
}
#[test]
fn single_dash_long_becomes_double_dash() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-qdf", "-static-id", "in.pdf"]));
assert_eq!(out, strs(&["flpdf", "--qdf", "--static-id", "in.pdf"]));
}
#[test]
fn single_dash_long_with_equals_becomes_double_dash() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-object-streams=generate"]));
assert_eq!(out, strs(&["flpdf", "--object-streams=generate"]));
}
#[test]
fn single_dash_bare_equals_value_is_discarded_after_rewriting() {
let out =
normalize_qpdf_bare_equals(rewrite_qpdf_single_dash(strs(&["flpdf", "-qdf=ignored"])));
assert_eq!(out, strs(&["flpdf", "--qdf"]));
}
#[test]
fn qpdf_bare_boolean_equals_values_are_discarded() {
let out = normalize_qpdf_bare_equals(strs(&[
"flpdf",
"--check=ignored",
"--qdf=ignored",
"--static-id=ignored",
"--verbose=ignored",
"--preserve-unreferenced=ignored",
]));
assert_eq!(
out,
strs(&[
"flpdf",
"--check",
"--qdf",
"--static-id",
"--verbose",
"--preserve-unreferenced",
])
);
}
#[test]
fn qpdf_bare_normalization_preserves_value_options() {
let args = strs(&[
"flpdf",
"--json=2",
"--object-streams=generate",
"--normalize-content=y",
"--newline-before-endstream=never",
]);
assert_eq!(normalize_qpdf_bare_equals(args.clone()), args);
}
#[test]
fn newline_before_endstream_discards_an_unrecognized_equals_value() {
let args = strs(&["flpdf", "--newline-before-endstream=garbage"]);
assert_eq!(
normalize_qpdf_bare_equals(args),
strs(&["flpdf", "--newline-before-endstream"])
);
}
#[test]
fn qpdf_bare_normalization_preserves_value_terminated_segments() {
let args = strs(&[
"flpdf",
"--encrypt",
"user",
"owner",
"256",
"--qdf=an-encrypt-suboption-value",
"--",
"--check=after-segment",
]);
assert_eq!(
normalize_qpdf_bare_equals(args),
strs(&[
"flpdf",
"--encrypt",
"user",
"owner",
"256",
"--qdf=an-encrypt-suboption-value",
"--",
"--check",
])
);
}
#[test]
fn double_dash_long_is_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "--qdf", "--static-id"]));
assert_eq!(out, strs(&["flpdf", "--qdf", "--static-id"]));
}
#[test]
fn known_short_flags_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-o", "path", "-h"]));
assert_eq!(out, strs(&["flpdf", "-o", "path", "-h"]));
}
#[test]
fn stdin_sentinel_survives_top_level_section_reset() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-", "--"]));
assert_eq!(out, strs(&["flpdf", "-"]));
}
#[test]
fn single_dash_long_after_section_terminator_is_rewritten() {
let out = rewrite_qpdf_single_dash(strs(&[
"flpdf",
"-pages",
".",
"--",
"-qdf",
"-not-an-option",
]));
assert_eq!(
out,
strs(&["flpdf", "--pages", ".", "--", "--qdf", "-not-an-option",])
);
}
#[test]
fn top_level_terminator_resets_to_main_parser() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "--", "-in.pdf", "-qdf"]));
assert_eq!(out, strs(&["flpdf", "-in.pdf", "--qdf"]));
}
#[test]
fn attached_short_output_is_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-o/tmp/out"]));
assert_eq!(out, strs(&["flpdf", "-o/tmp/out"]));
}
#[test]
fn hyphenated_segment_operand_is_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-add-attachment", "-note.txt", "--"]));
assert_eq!(out, strs(&["flpdf", "--add-attachment", "-note.txt", "--"]));
}
#[test]
fn single_dash_segment_sub_option_is_rewritten() {
let parsed = arg_parser::ArgParser::from_command(cli_command())
.parse(strs(&["flpdf", "-overlay", "stamp.pdf", "-to=1", "--"]))
.unwrap();
assert_eq!(parsed.residual_args, os_strs(&["flpdf"]));
assert_eq!(parsed.named_segments[0].option, "overlay");
assert_eq!(
parsed.named_segments[0].tokens,
os_strs(&["stamp.pdf", "--to=1"])
);
}
#[test]
fn each_segment_kind_recognizes_its_sub_options() {
let parsed = arg_parser::ArgParser::from_command(cli_command())
.parse(strs(&[
"flpdf",
"--encrypt",
"-use-aes",
"--",
"--pages",
"-range=1",
"--",
"--add-attachment",
"-replace",
"--",
"--copy-attachments-from",
"-prefix=copy-",
"--",
]))
.unwrap();
assert_eq!(parsed.named_segments[0].tokens, ["--use-aes"]);
assert_eq!(parsed.named_segments[1].tokens, ["--range=1"]);
assert_eq!(parsed.named_segments[2].tokens, ["--replace"]);
assert_eq!(parsed.named_segments[3].tokens, ["--prefix=copy-"]);
}
#[test]
fn collect_clap_long_options_includes_aliases() {
let command = clap::Command::new("test")
.arg(clap::Arg::new("mode").long("mode").alias("legacy-mode"));
let parsed = arg_parser::ArgParser::from_command(command)
.parse(strs(&["test", "-legacy-mode"]))
.unwrap();
assert_eq!(parsed.residual_args, os_strs(&["test", "--legacy-mode"]));
}
#[test]
fn legacy_encrypt_password_is_not_rewritten() {
let out =
rewrite_qpdf_single_dash(strs(&["flpdf", "-encrypt", "-user", "owner", "128", "--"]));
assert_eq!(
out,
strs(&["flpdf", "--encrypt", "-user", "owner", "128", "--",])
);
}
#[test]
fn non_bare_hyphen_encrypt_password_is_rejected() {
let err = parse_encrypt_segment(&strs(&["-user", "owner", "128"]))
.unwrap_err()
.to_string();
assert!(err.contains("unrecognized argument -user"), "got: {err}");
}
#[test]
fn bare_hyphen_encrypt_password_is_accepted() {
let params = parse_encrypt_segment(&strs(&["-", "-", "128"]))
.unwrap()
.params;
assert_eq!(params.user_password, b"-");
assert_eq!(params.owner_password, b"-");
}
#[test]
fn encrypt_parser_accepts_dashed_passwords_and_bits_before_the_terminator() {
let params = parse_encrypt_segment(&strs(&[
"--user-password=u",
"--bits=256",
"--allow-insecure",
]))
.expect("qpdf dashed encryption form")
.params;
assert_eq!(params.method, EncryptMethod::V5R6Aes256);
assert_eq!(params.user_password, b"u");
assert!(params.owner_password.is_empty());
}
#[test]
fn encrypt_parser_rejects_mixed_positional_and_dashed_passwords() {
let error = parse_encrypt_segment(&strs(&["user", "--owner-password=owner", "128"]))
.expect_err("mixed encryption form");
assert!(error
.to_string()
.contains("positional and dashed encryption arguments may not be mixed"));
}
#[test]
fn encrypt_parser_keeps_r2_permissions_separate_from_r3_permissions() {
let parsed = parse_encrypt_segment(&strs(&[
"user",
"owner",
"40",
"-print=n",
"-modify=y",
"-extract=n",
"-annotate=y",
]))
.expect("R=2 encryption options");
assert_eq!(parsed.params.method, EncryptMethod::V1Rc440);
assert!(!parsed.params.r2_permissions.print);
assert!(parsed.params.r2_permissions.modify);
assert!(!parsed.params.r2_permissions.extract);
assert!(parsed.params.r2_permissions.annotate);
assert_eq!(parsed.params.permissions, PermissionsConfig::default());
}
#[test]
fn encrypt_parser_reports_ignored_accessibility_for_modern_revisions() {
let parsed = parse_encrypt_segment(&strs(&[
"user",
"owner",
"128",
"--force-V4",
"--accessibility=n",
]))
.expect("modern encryption options");
assert!(parsed.accessibility_warning);
assert_eq!(parsed.params.method, EncryptMethod::V4Rc4128);
assert!(parsed.params.permissions.accessibility);
}
#[test]
fn negative_number_positional_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-1", "-0.5"]));
assert_eq!(out, strs(&["flpdf", "-1", "-0.5"]));
}
#[test]
fn extract_no_overlay_leaves_args_untouched() {
let argv = strs(&["flpdf", "rewrite", "--static-id", "in.pdf", "out.pdf"]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert_eq!(residual, argv);
assert!(specs.is_empty());
}
#[test]
fn extract_single_attachment_group_leaves_a_clap_dispatch_marker() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(
residual,
strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
])
);
assert_eq!(groups, vec![strs(&["one.txt", "--key=one"])]);
}
#[test]
fn extract_repeated_attachment_groups_preserves_order_and_boundaries() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"--add-attachment",
"two.txt",
"--key=two",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(
residual,
strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
])
);
assert_eq!(
groups,
vec![
strs(&["one.txt", "--key=one"]),
strs(&["two.txt", "--key=two"]),
]
);
}
#[test]
fn extract_attachment_groups_leaves_opaque_sibling_values_untouched() {
let argv = strs(&[
"flpdf",
"--pages",
"--add-attachment",
"one.txt",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv.clone()).unwrap();
assert_eq!(residual, argv);
assert!(groups.is_empty());
}
#[test]
fn extract_attachment_groups_rejects_an_unterminated_group() {
let error = extract_attachment_groups(strs(&["flpdf", "--add-attachment", "one.txt"]))
.expect_err("an attachment group must have a terminator");
assert_eq!(error.to_string(), "missing -- at end of attachment options");
}
#[test]
fn extract_attachment_groups_discards_the_equals_value_like_qpdfs_bare_option() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment=bogus.txt",
"payload.txt",
"--",
"out.pdf",
]);
let (_, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(groups, vec![strs(&["payload.txt"])]);
}
#[test]
fn extract_attachment_groups_equals_form_with_no_positional_yields_an_empty_segment() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment=payload.txt",
"--",
"out.pdf",
]);
let (_, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(groups, vec![Vec::<String>::new()]);
}
#[test]
fn extract_single_overlay_group() {
let argv = strs(&[
"flpdf",
"rewrite",
"in.pdf",
"--overlay",
"over.pdf",
"--",
"out.pdf",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(residual, strs(&["flpdf", "rewrite", "in.pdf", "out.pdf"]));
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].kind, OverlayKind::Overlay);
assert_eq!(specs[0].file, "over.pdf");
}
#[test]
fn extract_two_overlay_groups_preserves_boundaries_and_order() {
let argv = strs(&["--overlay", "a.pdf", "--", "--overlay", "b.pdf", "--"]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert!(
residual.is_empty(),
"all overlay tokens stripped: {residual:?}"
);
assert_eq!(
specs.len(),
2,
"two distinct groups, not one flattened list"
);
assert_eq!(specs[0].file, "a.pdf");
assert_eq!(specs[1].file, "b.pdf");
}
#[test]
fn extract_mixed_overlay_underlay_preserves_declaration_order() {
let argv = strs(&[
"in.pdf",
"--overlay",
"one.pdf",
"--",
"--underlay",
"two.pdf",
"--",
"out.pdf",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(residual, strs(&["in.pdf", "out.pdf"]));
assert_eq!(specs.len(), 2);
assert_eq!(specs[0].kind, OverlayKind::Overlay);
assert_eq!(specs[0].file, "one.pdf");
assert_eq!(specs[1].kind, OverlayKind::Underlay);
assert_eq!(specs[1].file, "two.pdf");
}
#[test]
fn extract_captures_sub_flags_per_group() {
let argv = strs(&[
"--overlay",
"--file=src.pdf",
"--password=pw",
"--from=1",
"--to=2-3",
"--repeat=1",
"--",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert!(residual.is_empty());
assert_eq!(specs.len(), 1);
let s = &specs[0];
assert_eq!(s.file, "src.pdf");
assert_eq!(s.password.as_deref(), Some(OsStr::new("pw")));
assert_eq!(s.from.as_deref(), Some("1"));
assert_eq!(s.to.as_deref(), Some("2-3"));
assert_eq!(s.repeat.as_deref(), Some("1"));
}
#[test]
fn extract_leaves_trailing_top_level_flag_after_group_terminator() {
let argv = strs(&[
"flpdf",
"in.pdf",
"out.pdf",
"--overlay",
"src.pdf",
"--",
"--coalesce-contents",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(
residual,
strs(&["flpdf", "in.pdf", "out.pdf", "--coalesce-contents"])
);
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].file, "src.pdf");
}
#[test]
fn extract_unterminated_group_errors() {
let argv = strs(&["--overlay", "over.pdf", "out.pdf"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert_eq!(err, "missing -- at end of underlay/overlay options");
}
#[test]
fn extract_propagates_segment_parse_errors() {
let argv = strs(&["--overlay", "over.pdf", "--to=abc!", "--"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert!(err.contains("invalid --to="), "got: {err}");
}
#[test]
fn extract_sub_options_before_file_within_group() {
let argv = strs(&[
"flpdf",
"rewrite",
"in.pdf",
"--overlay",
"--to=1",
"src.pdf",
"--",
"out.pdf",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(residual, strs(&["flpdf", "rewrite", "in.pdf", "out.pdf"]));
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].kind, OverlayKind::Overlay);
assert_eq!(specs[0].file, "src.pdf");
assert_eq!(specs[0].to.as_deref(), Some("1"));
}
#[test]
fn extract_overlay_equals_form_without_positional_file_is_rejected() {
let argv = strs(&["flpdf", "--overlay=discarded", "--"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert_eq!(err, "overlay file not specified");
}
#[test]
fn extract_underlay_equals_form_without_positional_file_is_rejected() {
let argv = strs(&["flpdf", "--underlay=discarded", "--"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert_eq!(err, "underlay file not specified");
}
#[test]
fn extract_overlay_equals_form_discards_value_when_positional_source_follows() {
let argv = strs(&["flpdf", "--overlay=discarded", "src.pdf", "--"]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(residual, strs(&["flpdf"]));
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].file, "src.pdf");
}
#[test]
fn extract_underlay_equals_form_discards_value_when_positional_source_follows() {
let argv = strs(&["flpdf", "--underlay=discarded", "src.pdf", "--"]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(residual, strs(&["flpdf"]));
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].file, "src.pdf");
}
#[test]
fn extract_password_sub_flag_not_mistaken_for_terminator() {
let argv = strs(&["--overlay", "src.pdf", "--password=--weird", "--"]);
let (_residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].password.as_deref(), Some(OsStr::new("--weird")));
}
#[test]
fn extract_overlay_token_inside_encrypt_segment_is_not_a_group() {
let argv = strs(&[
"flpdf",
"rewrite",
"--encrypt",
"--overlay",
"owner",
"128",
"--use-aes=y",
"--",
"in.pdf",
"out.pdf",
]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert!(specs.is_empty(), "no overlay group, got: {specs:?}");
assert_eq!(residual, argv, "encrypt segment copied verbatim");
}
#[test]
fn extract_underlay_token_inside_pages_segment_is_not_a_group() {
let argv = strs(&["--pages", "a.pdf", "--underlay", "b.pdf", "--", "out.pdf"]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert!(specs.is_empty(), "got: {specs:?}");
assert_eq!(residual, argv);
}
#[test]
fn extract_real_overlay_after_encrypt_segment_still_extracted() {
let argv = strs(&[
"--encrypt",
"u",
"o",
"128",
"--",
"--overlay",
"src.pdf",
"--",
"in.pdf",
"out.pdf",
]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert_eq!(specs.len(), 1);
assert_eq!(specs[0].file, "src.pdf");
assert_eq!(
residual,
strs(&["--encrypt", "u", "o", "128", "--", "in.pdf", "out.pdf"])
);
}
#[test]
fn extract_unterminated_sibling_segment_errors_at_parser_boundary() {
let argv = strs(&["--encrypt", "u", "o", "128", "--overlay", "x"]);
let error = extract_overlay_groups(argv).unwrap_err().to_string();
assert_eq!(error, "missing -- at end of encryption options");
}
#[test]
fn extract_overlay_token_inside_equals_form_attachment_segment_is_not_a_group() {
let argv = strs(&["--add-attachment=discarded", "--overlay", "--", "out.pdf"]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert!(specs.is_empty(), "no overlay group, got: {specs:?}");
assert_eq!(
residual,
strs(&["--add-attachment", "--overlay", "--", "out.pdf"]),
"qpdf discards the equals value on a bare segment option"
);
}
#[test]
fn extract_overlay_groups_normalizes_equals_form_sibling_segments() {
for (equals_form, bare_form) in [
("--encrypt=discarded", "--encrypt"),
("--pages=discarded", "--pages"),
(
"--copy-attachments-from=discarded",
"--copy-attachments-from",
),
] {
let argv = strs(&["in.pdf", equals_form, "--overlay", "--", "out.pdf"]);
let (residual, specs) = extract_overlay_groups(argv).unwrap();
assert!(specs.is_empty(), "no overlay group, got: {specs:?}");
assert_eq!(
residual,
strs(&["in.pdf", bare_form, "--overlay", "--", "out.pdf"]),
"equals value must be discarded like qpdf for {equals_form}"
);
}
}
#[test]
fn extract_attachment_groups_normalizes_equals_form_sibling_segments() {
for (equals_form, bare_form) in [
("--encrypt=discarded", "--encrypt"),
("--pages=discarded", "--pages"),
(
"--copy-attachments-from=discarded",
"--copy-attachments-from",
),
] {
let argv = strs(&[
"flpdf",
"in.pdf",
equals_form,
"source.pdf",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv).unwrap();
assert!(
groups.is_empty(),
"sibling segment must not become attachment groups"
);
assert_eq!(
residual,
strs(&["flpdf", "in.pdf", bare_form, "source.pdf", "--", "out.pdf"]),
"equals value must be discarded like qpdf for {equals_form}"
);
}
}
fn compat_fixture(name: &str) -> String {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(name)
.to_str()
.expect("utf-8 path")
.to_string()
}
#[test]
fn build_overlay_specs_opens_source_and_maps_fields() {
let cli_specs = vec![OverlaySpec {
kind: OverlayKind::Underlay,
file: compat_fixture("one-page.pdf").into(),
password: None,
raw_password: None,
from: Some("1".into()),
to: Some("1-2".into()),
repeat: Some("1".into()),
}];
let built = build_overlay_specs(&cli_specs, false, &PasswordArgs::default()).unwrap();
assert_eq!(built.len(), 1);
assert_eq!(built[0].kind, flpdf::OverlayKind::Underlay);
assert!(built[0].repeat.is_some());
}
#[test]
fn build_overlay_specs_defaults_ranges_when_absent() {
let cli_specs = vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: compat_fixture("one-page.pdf").into(),
password: None,
raw_password: None,
from: None,
to: None,
repeat: None,
}];
let built = build_overlay_specs(&cli_specs, false, &PasswordArgs::default()).unwrap();
assert_eq!(built[0].kind, flpdf::OverlayKind::Overlay);
assert!(
built[0].repeat.is_none(),
"repeat None when --repeat absent"
);
}
#[test]
fn build_overlay_specs_missing_file_errors() {
let cli_specs = vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: "/nonexistent/overlay/source.pdf".into(),
password: None,
raw_password: None,
from: None,
to: None,
repeat: None,
}];
let err = match build_overlay_specs(&cli_specs, false, &PasswordArgs::default()) {
Ok(_) => panic!("expected error for a missing source file"),
Err(e) => e.to_string(),
};
assert!(
err.contains("source.pdf"),
"error should name the unreadable file: {err}"
);
}
fn encrypted_fixture(name: &str) -> String {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/encrypted")
.join(name)
.to_str()
.expect("utf-8 path")
.to_string()
}
#[test]
fn build_overlay_specs_distinguishes_absent_and_empty_from() {
let file = compat_fixture("three-page.pdf");
let spec = |from: Option<&str>| {
vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: file.clone().into(),
password: None,
raw_password: None,
from: from.map(str::to_string),
to: None,
repeat: None,
}]
};
let absent = build_overlay_specs(&spec(None), false, &PasswordArgs::default()).unwrap();
assert_eq!(absent[0].from.resolve(3).unwrap(), vec![1, 2, 3]);
let empty = build_overlay_specs(&spec(Some("")), false, &PasswordArgs::default()).unwrap();
assert_eq!(empty[0].from.resolve(3).unwrap(), Vec::<u32>::new());
let explicit =
build_overlay_specs(&spec(Some("2")), false, &PasswordArgs::default()).unwrap();
assert_eq!(explicit[0].from.resolve(3).unwrap(), vec![2]);
}
#[test]
fn build_overlay_specs_distinguishes_absent_and_empty_to() {
let file = compat_fixture("three-page.pdf");
let spec = |to: Option<&str>| {
vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: file.clone().into(),
password: None,
raw_password: None,
from: None,
to: to.map(str::to_string),
repeat: None,
}]
};
let absent = build_overlay_specs(&spec(None), false, &PasswordArgs::default()).unwrap();
assert_eq!(absent[0].to.resolve(3).unwrap(), vec![1, 2, 3]);
let empty = build_overlay_specs(&spec(Some("")), false, &PasswordArgs::default()).unwrap();
assert_eq!(empty[0].to.resolve(3).unwrap(), Vec::<u32>::new());
let explicit =
build_overlay_specs(&spec(Some("2-3")), false, &PasswordArgs::default()).unwrap();
assert_eq!(explicit[0].to.resolve(3).unwrap(), vec![2, 3]);
}
#[test]
fn build_overlay_specs_distinguishes_absent_and_empty_repeat() {
let file = compat_fixture("three-page.pdf");
let spec = |repeat: Option<&str>| {
vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: file.clone().into(),
password: None,
raw_password: None,
from: None,
to: None,
repeat: repeat.map(str::to_string),
}]
};
let absent = build_overlay_specs(&spec(None), false, &PasswordArgs::default()).unwrap();
assert!(absent[0].repeat.is_none(), "absent --repeat -> None");
let empty = build_overlay_specs(&spec(Some("")), false, &PasswordArgs::default()).unwrap();
assert!(
empty[0].repeat.is_none(),
"explicit empty --repeat= -> None (no repeat), same as absent"
);
let explicit =
build_overlay_specs(&spec(Some("2")), false, &PasswordArgs::default()).unwrap();
assert_eq!(
explicit[0].repeat.as_ref().unwrap().resolve(3).unwrap(),
vec![2]
);
}
#[test]
fn build_overlay_specs_opens_rc4_source_without_allow_weak_crypto() {
let cli_specs = vec![OverlaySpec {
kind: OverlayKind::Overlay,
file: encrypted_fixture("v2-rc4-128-r3.pdf").into(),
password: Some("user-v2".into()),
raw_password: None,
from: None,
to: None,
repeat: None,
}];
let built = build_overlay_specs(&cli_specs, false, &PasswordArgs::default()).unwrap();
assert_eq!(built.len(), 1);
assert_eq!(built[0].kind, flpdf::OverlayKind::Overlay);
}
#[test]
fn show_object_selector_defaults_generation_like_qpdf() {
assert!(matches!(
parse_show_object_selector("1"),
Ok(ShowObjectSelector::Object {
number: 1,
generation: 0,
})
));
assert!(matches!(
parse_show_object_selector("1,"),
Ok(ShowObjectSelector::Object {
number: 1,
generation: 0,
})
));
}
#[test]
fn show_object_selector_integer_errors_match_qpdf() {
let overflow = qpdf_selector_integer("9223372036854775808").expect_err("i64 overflow");
assert_eq!(
overflow.to_string(),
"overflow/underflow converting 9223372036854775808 to 64-bit integer"
);
assert!(
overflow.downcast_ref::<UsageError>().is_some(),
"qpdf reports this as a QPDFUsage-class error (thrown from argv parsing, \
before the input file is opened), so it must route through \
flpdf-cli's usage_exit path rather than the generic error path"
);
let huge = qpdf_selector_integer("99999999999999999999999999999999999999999999999999")
.expect_err("digit run exceeding i128");
assert_eq!(
huge.to_string(),
"overflow/underflow converting 99999999999999999999999999999999999999999999999999 to 64-bit integer"
);
assert!(huge.downcast_ref::<UsageError>().is_some());
let narrowing = qpdf_selector_integer("2147483648").expect_err("i32 narrowing overflow");
assert_eq!(
narrowing.to_string(),
"integer out of range converting 2147483648 from a 8-byte signed type to a 4-byte signed type"
);
assert!(narrowing.downcast_ref::<UsageError>().is_some());
}
#[test]
fn show_object_selector_parses_before_checking_for_an_input_file() {
let error = run_show_object(
None,
false,
&PasswordArgs::default(),
"2147483648",
false,
false,
false,
false,
false,
InspectionTransformOptions::new(ImageTransformOptions::default(), false, None),
false,
)
.expect_err("overflow selector with no input file");
assert!(
error.downcast_ref::<UsageError>().is_some(),
"got {error} instead of a UsageError -- the missing-input-file check must not \
run before selector parsing"
);
}
}