#![forbid(unsafe_code)]
mod arg_parser;
mod qpdf_help;
use clap::{Args as ClapArgs, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum};
use flpdf::fix_qdf;
use flpdf::job::{
AttachmentAddOptions, CheckError, FlattenAnnotationsMode, ImageOptimizationOptions,
JobExitCode, JsonStreamData, QPDFJob, RemoveUnreferencedResources,
};
use flpdf::pipeline::{FlateAction, Pipeline, PipelineHandle, PlFlate, PlStdioFile};
use flpdf::qutil::same_file as qpdf_same_file;
use flpdf::writer::DecodeLevel as StreamDecodeLevel;
#[cfg(test)]
use flpdf::PasswordWriteNotice;
use flpdf::{
json_inspect::{DecodeLevel, JsonKey},
normalize_content_stream, pages, parse_pdf_version, CompressStreams, CopyEncryptionSource,
EncryptMethod, EncryptParams, Error, Matrix, NewlineBeforeEndstream, ObjectHandle,
ObjectKeyAlg, ObjectRef, ObjectStreamMode, PageObjectHelper, PasswordMode, Pdf, PdfOpenOptions,
PdfVersion, PermissionsConfig, PrintPermission, QPDFLogger, R2PermissionsConfig,
StreamDataMode, UsageError, WriterConfiguration,
};
use flpdf::{
pages::tree_rebuild::{rebuild_page_tree_with_duplicate_hook, RebuildResult},
qutil::parse_numrange,
PageRange,
};
use std::collections::HashSet;
use std::ffi::{OsStr, OsString};
use std::fs::File;
use std::io::{BufReader, Read, Seek, Write};
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
type CliResult<T> = Result<T, Box<dyn std::error::Error>>;
struct CliInputSpec {
path: PathBuf,
}
impl CliInputSpec {
fn new(path: impl Into<PathBuf>) -> Self {
Self { path: path.into() }
}
}
struct PipelineWriter {
pipeline: PipelineHandle,
}
impl PipelineWriter {
fn new(pipeline: PipelineHandle) -> Self {
Self { pipeline }
}
}
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(())
}
}
#[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,
report_memory_usage: 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,
allow_insecure: bool,
accessibility_disabled: 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<'a> {
image: ImageTransformOptions,
generate_appearances: bool,
flatten_annotations: Option<CliFlattenMode>,
flatten_rotation: bool,
rotations: &'a [OsString],
}
impl<'a> InspectionTransformOptions<'a> {
fn new(
image: ImageTransformOptions,
generate_appearances: bool,
flatten_annotations: Option<CliFlattenMode>,
) -> Self {
Self {
image,
generate_appearances,
flatten_annotations,
flatten_rotation: false,
rotations: &[],
}
}
fn with_rotations(mut self, rotations: &'a [OsString]) -> Self {
self.rotations = rotations;
self
}
fn is_empty(self) -> bool {
!self.generate_appearances
&& self.flatten_annotations.is_none()
&& !self.flatten_rotation
&& self.rotations.is_empty()
&& !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,
report_memory_usage: 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,
allow_insecure: false,
accessibility_disabled: 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(),
i64::from(pdf.get_extension_level()?),
);
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,
report_memory_usage: args.report_memory_usage,
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: newline_before_endstream_setting(args.newline_before_endstream),
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 = parse_qpdf_unsigned_option(value.as_bytes())?;
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,
) -> CliResult<()> {
if options.is_empty() && !remove_restrictions && !coalesce_contents {
return Ok(());
}
job.set_verbose(verbose);
{
let mut configuration = job.config();
for parameter in options.rotations {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
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);
}
}
Ok(())
}
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)
}
#[cfg(test)]
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(())
}
#[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 CliRawExitError {
code: ExitCode,
message: Vec<u8>,
}
impl std::fmt::Display for CliRawExitError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.message))
}
}
impl std::error::Error for CliRawExitError {}
#[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)]
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 = [
"json",
"json_output",
]
)]
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",
"show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"is_encrypted", "requires_password",
"list_attachments", "show_attachment",
],
help = "Generate JSON v2 output (qpdf --json compatible)")]
json: Option<String>,
#[arg(
long = "json-input",
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,
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",
"show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"is_encrypted", "requires_password",
"list_attachments", "show_attachment",
],
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")]
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 = "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",
overrides_with = "newline_before_endstream"
)]
newline_before_endstream: bool,
#[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")]
coalesce_contents: bool,
#[arg(
long = "flatten-annotations",
value_enum,
value_name = "MODE",
require_equals = true,
overrides_with = "flatten_annotations",
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 = "report-memory-usage")]
report_memory_usage: 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]",
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,
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",
help = "For an extra newline before endstream",
overrides_with = "newline_before_endstream"
)]
newline_before_endstream: bool,
#[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,
#[arg(long = "report-memory-usage")]
report_memory_usage: 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,
}
}
fn newline_before_endstream_setting(flag: bool) -> NewlineBeforeEndstream {
if flag {
NewlineBeforeEndstream::Yes
} else {
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)]
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();
let password_file_is_last = password_file_is_last(&raw_residual_args);
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,
raw_residual_args: raw_residual_args.clone(),
original_residual_args,
native_subcommand_mode,
expanded_arg_count,
first_unknown_option,
overlay_specs,
attachment_segments,
raw_overrides: RawCliOverrides {
password: (!password_file_is_last)
.then(|| raw_option_value(&raw_residual_args, "password"))
.flatten(),
password_file_is_last,
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 password_file_is_last(args: &[arg_parser::RawArg]) -> bool {
let mut last_is_file = false;
let mut seen = false;
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 bytes == b"--password" || bytes.starts_with(b"--password=") {
seen = true;
last_is_file = false;
} else if bytes == b"--password-file" || bytes.starts_with(b"--password-file=") {
seen = true;
last_is_file = true;
}
index += 1;
}
seen && last_is_file
}
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 {
arg_parser::is_named_segment_option(bytes)
}
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,
password_file_is_last,
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();
if password_file_is_last {
args.password.password = None;
}
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();
if password_file_is_last {
command.password.password = None;
}
}
Commands::Pages(command) => {
command.password.raw_password = password.clone();
if password_file_is_last {
command.password.password = None;
}
}
Commands::Qdf(command) => {
command.password.raw_password = password.clone();
if password_file_is_last {
command.password.password = None;
}
}
Commands::ShowEncryption(command)
| Commands::RequiresPassword(command)
| Commands::ShowEncryptionKey(command) => {
command.password.raw_password = password.clone();
if password_file_is_last {
command.password.password = None;
}
}
Commands::Rewrite(command) => {
command.password.raw_password = password.clone();
if password_file_is_last {
command.password.password = None;
}
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,
|| arg_parser::configure_qpdf_repeatable_bare_options(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,
|| {
let command = if native_subcommand_mode {
cli_command()
} else {
let mut disabled_index = 0;
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 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 => {
emit_logger_info(qpdf_help::render_top(&progname()));
return;
}
Some(topic) => {
if let Some(body) = qpdf_help::render(&topic, &progname()) {
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,
raw_residual_args,
native_subcommand_mode,
overlay_specs,
attachment_segments,
raw_overrides,
..
} = preprocessed;
let qpdf_preflight = if native_subcommand_mode {
None
} else {
Some(match preflight_qpdf_cli_events(&raw_residual_args) {
Ok(preflight) => preflight,
Err(error) => exit_qpdf_parse_error(error),
})
};
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);
let _ = CLI_REPORT_MEMORY_USAGE.set(args.report_memory_usage);
args.password.verbose = args.verbose;
if let Err(error) = validate_keep_files_open_threshold(&args.page_ops) {
qpdf_usage_exit(error);
}
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) => qpdf_usage_exit(error),
};
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) => qpdf_usage_exit(error),
};
let top_level_image_transform_options = ImageTransformOptions::new(
args.externalize_inline_images,
args.optimize_images,
top_level_image_options,
);
let top_level_rotation_parameters = args.page_ops.rotate.clone();
let mut top_level_inspection_transform_options = InspectionTransformOptions::new(
top_level_image_transform_options,
args.generate_appearances,
args.flatten_annotations,
)
.with_rotations(&top_level_rotation_parameters);
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()
}
};
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();
let target_is_json_output = args.json.is_some() || args.json_output.is_some();
if !target_is_rewrite && !target_is_inspection && !target_is_json_output {
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_object.is_some()
|| args.check_linearization
|| args.show_linearization
|| args.show_encryption
|| args.list_attachments
|| args.show_attachment.is_some());
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(
qpdf_preflight.expect("flat qpdf job-json route requires its preflight"),
args.no_warn,
)
} else if json_input_inspection {
run_json_input_inspection(
&args,
top_level_inspection_transform_options,
&overlay_specs,
&attachment_segments,
)
} else if (args.json.is_some() || args.json_output.is_some())
&& !split_pages_active(args.page_ops.split_pages.as_deref())
{
run_json(
&args,
top_level_inspection_transform_options,
&attachment_segments,
&overlay_specs,
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 attachment_mutation_requested {
let options = top_level_writer_options(
&args,
normalize_content,
top_level_compression_level,
&top_level_version_options,
);
run_all_attachment_mutations(
&args,
&overlay_specs,
&attachment_segments,
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,
report_memory_usage: args.report_memory_usage,
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: newline_before_endstream_setting(
args.newline_before_endstream,
),
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 {
exit_with_cli_error(error);
}
}
fn exit_with_cli_error(error: Box<dyn std::error::Error>) -> ! {
let _ = cli_logger().flush();
if let Some(exit_err) = error.downcast_ref::<CliRawExitError>() {
if !exit_err.message.is_empty() {
let mut line = format!("\n{}: ", progname()).into_bytes();
line.extend_from_slice(&exit_err.message);
line.push(b'\n');
emit_logger_error(line);
}
std::process::exit(exit_err.code.as_i32());
}
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 exit_qpdf_parse_error(error: Box<dyn std::error::Error>) -> ! {
if let Some(exit_error) = error.downcast_ref::<CliRawExitError>() {
if !exit_error.message.is_empty() {
let mut line = format!("\n{}: ", progname()).into_bytes();
line.extend_from_slice(&exit_error.message);
line.push(b'\n');
emit_logger_error(line);
}
std::process::exit(exit_error.code.as_i32());
}
if let Some(exit_error) = error.downcast_ref::<CliExitError>() {
if !exit_error.message.is_empty() {
emit_logger_error(format!("\n{}: {}\n", progname(), exit_error.message));
}
std::process::exit(exit_error.code.as_i32());
}
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 qpdf_usage_exit(error: Box<dyn std::error::Error>) -> ! {
if let Some(usage_error) = find_usage_error(error.as_ref()) {
usage_exit(usage_error);
}
let usage_error = UsageError::new(error.to_string());
usage_exit(&usage_error);
}
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.set_report_memory_usage(cli_report_memory_usage());
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();
let migrated_flag_selected = 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();
if migrated_flag_selected {
return true;
}
if overlay_requested && inspection_count > 0 {
return true;
}
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)
}
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)
}
struct QpdfCliPreflight {
job: QPDFJob,
}
fn qpdf_argv_usage_error(error: Box<dyn std::error::Error>) -> Box<dyn std::error::Error> {
if let Some(usage_error) = find_usage_error(error.as_ref()) {
return Box::new(UsageError::new(usage_error.what_bytes()));
}
Box::new(UsageError::new(error.to_string()))
}
fn parse_qpdf_unsigned_option(value: &[u8]) -> CliResult<usize> {
let value = String::from_utf8_lossy(value);
QPDFJob::parse_keep_files_open_threshold(&value)
.map_err(|error| qpdf_argv_usage_error(Box::new(error)))
}
fn preflight_qpdf_cli_events(args: &[arg_parser::RawArg]) -> CliResult<QpdfCliPreflight> {
let has_job_json = args.iter().any(arg_parser::is_job_json_file_argument);
let mut in_segment = false;
let mut filtered: Vec<Vec<u8>> = args
.iter()
.filter(|argument| {
let bytes = argument.as_bytes();
if in_segment {
if bytes == b"--" {
in_segment = false;
}
return true;
}
if is_named_segment_option(bytes) {
in_segment = true;
return true;
}
bytes != b"--repair" && (has_job_json || !bytes.starts_with(b"--password-file="))
})
.map(|argument| argument.as_bytes().to_vec())
.collect();
if let Some(program) = filtered.first_mut() {
*program = progname().into_bytes();
}
let mut job = QPDFJob::new();
job.initialize_from_expanded_raw_argv(&filtered)
.map_err(|error| qpdf_argv_usage_error(Box::new(error)))?;
Ok(QpdfCliPreflight { job })
}
fn run_job_json_files(preflight: QpdfCliPreflight, suppress_warnings: bool) -> CliResult<()> {
let QpdfCliPreflight { mut job } = preflight;
if cli_warning_exit_zero() {
job.set_warnings_exit_zero(true);
}
job.set_logger(cli_logger());
if suppress_warnings {
job.set_suppress_warnings(true);
}
job.set_message_prefix(progname());
finish_job_exit_status(job.run()?)
}
fn run_json(
cli: &Cli,
transform_options: InspectionTransformOptions<'_>,
attachment_segments: &[Vec<Vec<u8>>],
overlay_specs: &[OverlaySpec],
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") {
usage_exit(&UsageError::new(
"json keys \"objects\" and \"objectinfo\" are only valid for json version 1",
));
}
if json_version == 1 && raw == "qpdf" {
usage_exit(&UsageError::new(
"json key \"qpdf\" is only valid for json version > 1",
));
}
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 && json_version == 1 {
emit_logger_error("flpdf: --json-output requires JSON version 2\n");
std::process::exit(2);
}
let json_objects = cli.json_object.clone();
let stream_data = cli.json_stream_data.as_deref().map(|value| match value {
"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()
};
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_report_memory_usage(cli_report_memory_usage());
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);
let input_options = pdf_open_options(cli.repair, &cli.password)?;
job.set_password(input_options.password);
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)?;
configure_cli_overlay_specs(&mut job, overlay_specs)?;
configure_keep_files_open(&mut job, &cli.page_ops)?;
{
let mut configuration = job.config();
if !cli.page_ops.pages.is_empty() {
let raw_specs = configured_page_specs(&cli.page_ops)?;
for spec in &raw_specs {
let password = spec.raw_password.clone().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 &cli.page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
for parameter in &cli.page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
configuration.remove_unreferenced_resources(cli.remove_unreferenced_resources.into());
if let Some(path) = cli.copy_encryption.as_ref() {
let password = cli
.raw_encryption_file_password
.clone()
.or_else(|| {
cli.encryption_file_password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
})
.unwrap_or_default();
configuration.copy_encryption(path.clone(), password);
}
if empty {
configuration.empty_input()?;
} else {
configuration.input_file(
input
.expect("a non-empty JSON job has an input")
.to_path_buf(),
)?;
}
if cli.json_input {
configuration.json_input();
}
if let Some(update_from_json) = cli.update_from_json.as_deref() {
configuration.update_from_json(update_from_json.to_path_buf());
}
if let Some(path) = output_path {
configuration.output_file(path.to_path_buf())?;
}
if json_output_mode {
configuration.json_output(json_version);
} else {
configuration.json(json_version);
}
for key in &json_keys {
configuration.json_key(*key);
}
for object in &json_objects {
configuration.json_object(object.clone());
}
if let Some(stream_data) = stream_data {
configuration.json_stream_data(stream_data);
}
if let Some(prefix) = cli.json_stream_prefix.as_deref() {
configuration.json_stream_prefix(arg_parser::os_bytes(prefix));
}
if cli.test_json_schema {
configuration.test_json_schema();
}
if let Some(decode_level) = cli.decode_level {
configuration.decode_level(StreamDecodeLevel::from(decode_level));
}
}
configure_top_level_inspection_transformations(
&mut job,
transform_options,
cli.verbose,
cli.remove_restrictions,
cli.coalesce_contents,
)?;
job.set_show_encryption_key(cli.show_encryption_key);
job.check_configuration()?;
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
run_json_document(&mut job, &mut pdf)
}
fn run_json_input_inspection(
cli: &Cli,
transform_options: InspectionTransformOptions<'_>,
overlay_specs: &[OverlaySpec],
attachment_segments: &[Vec<Vec<u8>>],
) -> CliResult<()> {
if cli.page_ops.empty {
reject_empty_inspection_output(cli.input.as_deref())?;
let mut job = new_cli_job(cli.no_warn);
configure_top_level_inspection_job(&mut job, cli)?;
configure_cli_overlay_specs(&mut job, overlay_specs)?;
configure_top_level_inspection_transformations(
&mut job,
transform_options,
cli.verbose,
cli.remove_restrictions,
cli.coalesce_contents,
)?;
if cli.show_attachment.is_some() {
job.logger().save_to_standard_output(true)?;
}
configure_top_level_attachment_mutations(&mut job, cli, attachment_segments)?;
let mut pdf = create_empty_primary_document(&mut job, cli.update_from_json.as_deref())?;
job.apply_transformations(&mut pdf)?;
return run_job_inspection_on_pdf(cli, &mut job, &mut pdf);
}
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_report_memory_usage(cli_report_memory_usage());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(cli.no_warn);
configure_top_level_inspection_job(&mut job, cli)?;
configure_cli_overlay_specs(&mut job, overlay_specs)?;
configure_top_level_inspection_transformations(
&mut job,
transform_options,
cli.verbose,
cli.remove_restrictions,
cli.coalesce_contents,
)?;
if cli.show_attachment.is_some() {
job.logger().save_to_standard_output(true)?;
}
configure_top_level_attachment_mutations(&mut job, cli, attachment_segments)?;
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())?;
job.apply_transformations(&mut pdf)?;
return run_job_inspection_on_pdf(cli, &mut job, &mut pdf);
}
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())?;
job.apply_transformations(&mut pdf)?;
run_job_inspection_on_pdf(cli, &mut job, &mut pdf)
}
fn run_job_inspection_on_pdf<R: Read + Seek + 'static>(
cli: &Cli,
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
) -> CliResult<()> {
configure_top_level_inspection_job(job, cli)?;
match job.inspect_configured(pdf) {
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 run_json_document<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
) -> CliResult<()> {
match job.write_qpdf(pdf) {
Ok(()) => finish_job_exit_status(job.get_exit_code()),
Err(Error::Usage(error)) => Err(Box::new(error)),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
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,
report_memory_usage: cmd.report_memory_usage,
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: newline_before_endstream_setting(
cmd.newline_before_endstream,
),
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.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,
&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<()> {
let mut job = new_cli_job(no_warn);
job.set_show_encryption_key(show_encryption_key);
job.set_verbose(verbose);
configure_top_level_inspection_transformations(
&mut job,
transform_options,
verbose,
false,
false,
)?;
{
let mut configuration = job.config();
configuration.check();
}
if empty {
reject_empty_inspection_output(input.as_deref())?;
job.config().empty_input()?;
} else {
let input = input.ok_or_else(missing_input_usage_error)?;
let input_options = pdf_open_options(repair, password)?;
job.set_input_file(input)?;
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);
}
finish_job_exit_status(job.run()?)
}
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 {
options.accessibility_disabled = parsed.accessibility_warning;
options.allow_insecure = parsed.allow_insecure;
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(error) => exit_with_cli_error(error),
}
}
}
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(|error| open_error_with_file(path, error.into()))?;
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)?;
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(|error| error_with_file(path, actionable_password_error(error)))?;
donor
.root_handle()
.map_err(|error| error_with_file(path, actionable_password_error(error)))?;
let Some(version) = donor.encryption_version() else {
return Ok(None);
};
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,
allow_insecure: 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" => "{128,256,40}",
_ => 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_dashed_encrypt_bits(&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,
allow_insecure,
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()),
}
}
fn parse_dashed_encrypt_bits(value: &str) -> CliResult<u32> {
match value {
"40" => Ok(40),
"128" => Ok(128),
"256" => Ok(256),
_ => Err(UsageError::new("--bits must be given as --bits={128,256,40}").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_allow_insecure(options.allow_insecure);
job.set_accessibility_disabled(options.accessibility_disabled);
job.set_verbose(verbose);
job.set_progress(options.progress);
job.set_report_memory_usage(options.report_memory_usage);
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)
};
if !s.range.is_empty() {
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));
}
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>,
raw_residual_args: Vec<arg_parser::RawArg>,
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>>,
password_file_is_last: bool,
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,
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)?;
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 raw_specs = configured_page_specs(page_ops)?;
let inputs = resolve_page_specs(&raw_specs, primary_input)?;
let has_external_source = inputs
.iter()
.any(|spec| spec.path.as_os_str() != primary_input.as_os_str());
if has_external_source {
return run_page_extraction_from_multiple_sources(
primary_input,
output,
repair,
password,
page_ops,
raw_specs,
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,
);
}
run_page_extraction_from_single_source(
primary_input,
output,
repair,
password,
page_ops,
raw_specs,
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,
)
}
#[allow(clippy::too_many_arguments)]
fn run_empty_page_extraction(
output: &Path,
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 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 _validated_inputs = resolve_page_specs(&raw_specs, Path::new("<empty>"))?;
let _validated_collate = parse_collate_values(&page_ops.collate)?;
let mut job = new_cli_job(no_warn);
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_allow_insecure(options.allow_insecure);
job.set_accessibility_disabled(options.accessibility_disabled);
job.set_verbose(verbose);
configure_keep_files_open(&mut job, page_ops)?;
{
let mut configuration = job.config();
configuration.empty_input()?;
if let Some(update_from_json) = update_from_json {
configuration.update_from_json(update_from_json.to_path_buf());
}
for spec in &raw_specs {
let source_password = spec.raw_password.clone().or_else(|| {
spec.password
.as_ref()
.map(|password| arg_parser::os_bytes(password))
});
configuration.add_page_spec(
PathBuf::from(&spec.file_token),
&spec.range,
source_password,
)?;
}
for parameter in &page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
configuration.remove_unreferenced_resources(remove_unref.into());
}
job.set_writer_configuration(writer_configuration_unnormalized(
&options,
linearize,
linearize_pass1,
)?);
job.set_allow_insecure(options.allow_insecure);
job.set_accessibility_disabled(options.accessibility_disabled);
let mut merged = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
let source_warnings = job.has_warnings();
let mut options = options;
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 selected_pages = pages::page_refs(&mut merged)?;
let result = 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,
source_warnings,
None,
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
);
drop(job);
result
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_multiple_sources(
primary_input: &Path,
output: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
raw_specs: Vec<PageSegmentSpec>,
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>,
) -> CliResult<()> {
let mut job = new_cli_job(no_warn);
job.set_input_file(primary_input.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_verbose(verbose);
let input_options = pdf_open_options(repair, password)?;
job.set_password(input_options.password);
configure_keep_files_open(&mut job, page_ops)?;
{
let mut configuration = job.config();
for spec in raw_specs {
let spec_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,
spec_password,
)?;
}
for parameter in &page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
configuration.remove_unreferenced_resources(remove_unref.into());
}
let mut create_stage_writer =
writer_configuration_unnormalized(&options, linearize, linearize_pass1)?;
if split_pages_active(page_ops.split_pages.as_deref()) {
create_stage_writer.set_preserve_unreferenced_objects(false);
}
job.set_writer_configuration(create_stage_writer);
job.set_allow_insecure(options.allow_insecure);
job.set_accessibility_disabled(options.accessibility_disabled);
let mut merged = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
let source_warnings = job.has_warnings();
let mut options = options;
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 selected_pages = pages::page_refs(&mut merged)?;
let result = 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,
source_warnings,
None,
selected_pages,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
);
drop(job);
result
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_single_source(
primary_input: &Path,
output: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
raw_specs: Vec<PageSegmentSpec>,
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 mut job = new_cli_job(no_warn);
job.set_input_file(primary_input.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_verbose(verbose);
let input_options = pdf_open_options(repair, password)?;
job.set_password(input_options.password);
configure_keep_files_open(&mut job, page_ops)?;
{
let mut configuration = job.config();
for spec in raw_specs {
let spec_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,
spec_password,
)?;
}
for parameter in &page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
configuration.remove_unreferenced_resources(remove_unref.into());
}
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
pdf.set_suppress_warnings(no_warn);
let source_warnings = job.has_warnings();
finish_page_extraction(
&mut pdf,
output,
primary_input,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
source_warnings,
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,
_standard_output: Option<PipelineWriter>,
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 mut copy_duplicate_annotations = |pdf: &mut Pdf<R>,
source_page_ref: ObjectRef,
new_page: ObjectRef|
-> flpdf::Result<()> {
let source_page = pdf.get_object_handle(source_page_ref);
let destination_page = pdf.get_object_handle(new_page);
destination_page.remove_key(b"/Annots");
PageObjectHelper::new(new_page, pdf).copy_annotations(source_page, Matrix::default())
};
let result =
rebuild_page_tree_with_duplicate_hook(pdf, &selected, &mut copy_duplicate_annotations)?;
(result, RemoveUnreferencedResources::No)
};
QPDFJob::complete_in_place_page_selection(pdf, &result, prune_mode)?;
finish_page_extraction(
pdf,
output,
input_path,
password,
page_ops,
overlay_specs,
remove_unref,
remove_restrictions,
decrypt,
options,
linearize,
linearize_pass1,
verbose,
prior_warnings,
image_options,
coalesce_contents,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
no_warn,
)
}
#[allow(clippy::too_many_arguments)]
fn finish_page_extraction<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,
prior_warnings: bool,
image_options: ImageTransformOptions,
coalesce_contents: bool,
generate_appearances: bool,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
no_warn: bool,
) -> CliResult<()> {
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 && pdf.is_encrypted() && !split_pages_active && !decrypt;
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_pages.is_some_and(|size| size > 0) {
let mut split_job = new_cli_job(no_warn);
split_job.set_input_file(input_path.to_path_buf())?;
split_job.set_output_file(output.to_path_buf())?;
split_job.set_verbose(verbose);
split_job.set_progress(split_progress);
split_job.set_report_memory_usage(options.report_memory_usage);
split_job.set_password_mode(options.password_mode);
split_job.set_allow_weak_crypto(options.allow_weak_crypto);
split_job.set_allow_insecure(options.allow_insecure);
split_job.set_accessibility_disabled(options.accessibility_disabled);
split_job.set_linearization(linearize, linearize_pass1.map(std::path::Path::to_path_buf));
{
let mut configuration = split_job.config();
configuration.split_pages(
page_ops
.split_pages
.as_deref()
.expect("positive split_pages has a raw CLI value")
.as_bytes(),
)?;
configuration.remove_unreferenced_resources(remove_unref.into());
}
split_job.set_writer_configuration(writer_configuration_unnormalized(
&options,
linearize,
linearize_pass1,
)?);
if prior_warnings {
split_job.record_warnings();
}
match split_job.write_qpdf(pdf) {
Ok(()) => finish_job_exit_status(split_job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
} else {
let mut write_job = new_cli_job(no_warn);
write_job.set_input_file(input_path.to_path_buf())?;
write_job.set_output_file(output.to_path_buf())?;
write_job.set_verbose(verbose);
write_job.set_progress(options.progress);
write_job.set_report_memory_usage(options.report_memory_usage);
write_job.set_password_mode(options.password_mode);
write_job.set_allow_weak_crypto(options.allow_weak_crypto);
write_job.set_allow_insecure(options.allow_insecure);
write_job.set_accessibility_disabled(options.accessibility_disabled);
write_job.set_linearization(linearize, linearize_pass1.map(std::path::Path::to_path_buf));
write_job.set_writer_configuration(writer_configuration_unnormalized(
&options,
linearize,
linearize_pass1,
)?);
if prior_warnings {
write_job.record_warnings();
}
match write_job.write_qpdf(pdf) {
Ok(()) => finish_job_exit_status(write_job.get_exit_code()),
Err(_) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
}
}
}
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| {
if value.is_empty() {
return true;
}
qpdf_selector_integer(value).map_or(true, |size| size != 0)
})
}
#[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 options = WriterOptions {
qdf: true,
preserve_unreferenced_objects: preserve_unreferenced,
password_mode: password.password_mode.into(),
..WriterOptions::default()
};
run_rewrite(
Some(input),
Some(output),
false,
repair,
password,
false,
None,
false,
None,
false,
false,
false,
false,
CliRemoveUnreferencedResources::Auto,
false,
ImageTransformOptions::default(),
None,
false,
PageLabelOptions::default(),
&[],
false,
false,
options,
false,
)?;
Ok(())
}
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_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 qpdf_json_input_open_error(input: &Path, error: std::io::Error) -> Box<dyn std::error::Error> {
let message = qpdf_open_io_error_message(&error);
let mut raw_message = b"open ".to_vec();
raw_message.extend_from_slice(&path_description(input));
raw_message.extend_from_slice(b": ");
raw_message.extend_from_slice(message.as_bytes());
Box::new(flpdf::Error::SystemBytes(raw_message))
}
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"
))
})?)
}
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)?)
}
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)
}
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<()> {
let authentication_failed = pdf.is_encrypted() && pdf.encryption_file_key().is_none();
job.show_encryption(pdf, password_is_hex_key)?;
if !authentication_failed {
job.record_document_warnings(pdf);
}
finish_job_exit_status(job.complete_report()?)
}
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
}
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_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_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_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) -> CliResult<Vec<u8>> {
let open_usage_error = |error: std::io::Error| {
let mut message = b"open ".to_vec();
message.extend_from_slice(&path_description(path));
message.extend_from_slice(b": ");
message.extend_from_slice(qpdf_open_io_error_message(&error).as_bytes());
Box::new(UsageError::new(message)) as Box<dyn std::error::Error>
};
let bytes = if path == Path::new("-") {
let mut bytes = Vec::new();
std::io::stdin()
.read_to_end(&mut bytes)
.map_err(open_usage_error)?;
bytes
} else {
let mut file = File::open(path).map_err(open_usage_error)?;
let mut bytes = Vec::new();
file.read_to_end(&mut bytes).map_err(|_error| {
Box::new(UsageError::new("failure reading character from file"))
as Box<dyn std::error::Error>
})?;
bytes
};
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)
}
static CLI_REPORT_MEMORY_USAGE: OnceLock<bool> = OnceLock::new();
fn cli_report_memory_usage() -> bool {
CLI_REPORT_MEMORY_USAGE.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::new(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}"); }
}
#[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 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>) -> CliResult<()> {
finish_operation_warnings_with_prior(pdf, false)
}
fn finish_operation_warnings_with_prior<R: Read + Seek>(
pdf: &Pdf<R>,
prior_warnings: bool,
) -> CliResult<()> {
finish_warning_state(
prior_warnings || !pdf.repair_diagnostics().entries().is_empty(),
pdf.suppress_warnings(),
)
}
fn finish_job_exit_status(status: JobExitCode) -> CliResult<()> {
cli_logger().flush()?;
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_warning_state(has_warnings: bool, no_warn: bool) -> CliResult<()> {
let mut job = QPDFJob::new();
job.set_warnings_exit_zero(cli_warning_exit_zero());
job.set_report_memory_usage(cli_report_memory_usage());
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(no_warn);
if has_warnings {
job.record_warnings();
}
finish_job_exit_status(job.complete_report()?)
}
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 {
#[cfg(unix)]
if error.raw_os_error().is_some() {
return strerror_from_display(error);
}
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();
}
strerror_from_display(error)
}
fn strerror_from_display(error: &std::io::Error) -> String {
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: Option<&Path>,
output: Option<&Path>,
page_ops: &PageOpArgs,
copy_encryption: Option<(&Path, Vec<u8>)>,
remove_unreferenced_resources: CliRemoveUnreferencedResources,
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);
if page_ops.empty {
job.config().empty_input()?;
} else {
let input = input.ok_or_else(missing_input_usage_error)?;
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())?;
}
configure_keep_files_open(&mut job, page_ops)?;
{
let raw_specs = if page_ops.parsed_page_specs.is_none() {
Vec::new()
} else {
configured_page_specs(page_ops)?
};
let mut configuration = job.config();
if let Some((path, password)) = copy_encryption {
configuration.copy_encryption(path.to_path_buf(), password);
configuration.clear_copy_encryption_for_writer();
}
configuration.remove_unreferenced_resources(remove_unreferenced_resources.into());
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 &page_ops.rotate {
configuration.rotate(arg_parser::os_bytes(parameter.as_os_str()))?;
}
for parameter in &page_ops.collate {
configuration.collate(parameter.as_bytes())?;
}
if let Some(parameter) = page_ops.split_pages.as_deref() {
configuration.split_pages(parameter.as_bytes())?;
}
}
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_allow_insecure(writer_options.allow_insecure);
job.set_accessibility_disabled(writer_options.accessibility_disabled);
job.set_progress(writer_options.progress);
job.set_report_memory_usage(writer_options.report_memory_usage);
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<()> {
job.set_writer_configuration(writer_configuration_unnormalized(
writer_options,
linearize,
linearize_pass1,
)?);
let mut pdf = match job.create_qpdf()? {
Some(pdf) => pdf,
None => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
};
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 cli_copy_encryption(args: &Cli) -> Option<(&Path, Vec<u8>)> {
let path = args.copy_encryption.as_deref()?;
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();
Some((path, password))
}
fn attachment_input_output(
input: Option<PathBuf>,
output: Option<PathBuf>,
page_ops: &PageOpArgs,
replace_input: bool,
) -> CliResult<(Option<PathBuf>, Option<PathBuf>)> {
if !page_ops.empty {
return Ok((input, output));
}
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());
}
match (input, output) {
(Some(output), None) | (None, Some(output)) => Ok((None, Some(output))),
(Some(_), Some(_)) => Err(UsageError::new(
"empty input can't be used since input file has already been given",
)
.into()),
(None, None) => Err(missing_output_usage_error().into()),
}
}
fn run_all_attachment_mutations(
args: &Cli,
overlay_specs: &[OverlaySpec],
attachment_segments: &[Vec<Vec<u8>>],
writer_options: WriterOptions,
transform_options: InspectionTransformOptions<'_>,
) -> CliResult<()> {
let (input, output) = attachment_input_output(
args.input.clone(),
args.output.clone(),
&args.page_ops,
args.replace_input,
)?;
if let Some(output) = output.as_deref() {
let _ = prepare_pdf_standard_output(output)?;
}
let copy_encryption_storage =
cli_copy_encryption(args).map(|(path, password)| (path.to_path_buf(), password));
let copy_encryption = copy_encryption_storage
.as_ref()
.map(|(path, password)| (path.as_path(), password.clone()));
let mut job = configure_attachment_job(
input.as_deref(),
output.as_deref(),
&args.page_ops,
copy_encryption,
args.remove_unreferenced_resources,
args.replace_input,
args.repair,
&args.password,
args.verbose,
args.no_warn,
args.remove_restrictions,
args.linearize,
args.linearize_pass1.as_deref(),
&writer_options,
transform_options,
)?;
{
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());
}
if args.coalesce_contents {
configuration.coalesce_contents();
}
if args.remove_page_labels {
configuration.remove_page_labels();
}
if let Some(specs) = args.set_page_labels.as_ref() {
configuration.set_page_labels(
specs
.iter()
.map(|spec| arg_parser::os_bytes(spec.as_os_str())),
)?;
}
}
configure_cli_overlay_specs(&mut job, overlay_specs)?;
configure_top_level_attachment_mutations(&mut job, args, attachment_segments)?;
run_configured_attachment_job(
job,
&writer_options,
args.linearize,
args.linearize_pass1.as_deref(),
)
}
#[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()
}
fn empty_page_ops() -> PageOpArgs {
PageOpArgs {
empty: true,
..PageOpArgs::default()
}
}
#[test]
fn attachment_input_output_maps_empty_positional_to_output() {
let page_ops = empty_page_ops();
let output = PathBuf::from("out.pdf");
assert_eq!(
attachment_input_output(Some(output.clone()), None, &page_ops, false).unwrap(),
(None, Some(output.clone()))
);
assert_eq!(
attachment_input_output(None, Some(output.clone()), &page_ops, false).unwrap(),
(None, Some(output))
);
}
#[test]
fn attachment_input_output_preserves_nonempty_input_and_output() {
let page_ops = PageOpArgs::default();
let input = PathBuf::from("in.pdf");
let output = PathBuf::from("out.pdf");
assert_eq!(
attachment_input_output(Some(input.clone()), Some(output.clone()), &page_ops, false,)
.unwrap(),
(Some(input), Some(output))
);
}
#[test]
fn attachment_input_output_matches_empty_usage_errors() {
let page_ops = empty_page_ops();
let error = attachment_input_output(
Some(PathBuf::from("in.pdf")),
Some(PathBuf::from("out.pdf")),
&page_ops,
false,
)
.err()
.unwrap()
.to_string();
assert_eq!(
error,
"empty input can't be used since input file has already been given"
);
let error = attachment_input_output(Some(PathBuf::from("out.pdf")), None, &page_ops, true)
.err()
.unwrap()
.to_string();
assert_eq!(
error,
"replace-input can't be used since output file has already been given"
);
let error = attachment_input_output(None, None, &page_ops, true)
.err()
.unwrap()
.to_string();
assert_eq!(error, "--replace-input may not be used with --empty");
let error = attachment_input_output(None, None, &page_ops, false)
.err()
.unwrap()
.to_string();
assert_eq!(
error,
"an output file name is required; use - for standard output"
);
}
#[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_preserves_every_add_attachment_group_in_raw_residual_args() {
let preprocessed = preprocess_qpdf_args(strs(&[
"flpdf",
"--job-json-file=job.json",
"--add-attachment",
"a1.txt",
"--",
"--add-attachment",
"a2.txt",
"--",
]))
.expect("qpdf accepts repeated add-attachment groups");
let count = preprocessed
.raw_residual_args
.iter()
.filter(|argument| argument.as_bytes() == b"--add-attachment")
.count();
assert_eq!(
count, 2,
"raw_residual_args must retain every --add-attachment group"
);
}
#[test]
fn preprocess_qpdf_args_retains_overlay_group_in_raw_residual_args_under_job_json() {
let preprocessed = preprocess_qpdf_args(strs(&[
"flpdf",
"--job-json-file=job.json",
"--overlay",
"src.pdf",
"--",
"in.pdf",
"out.pdf",
]))
.expect("qpdf accepts an overlay group under --job-json-file");
let count = preprocessed
.raw_residual_args
.iter()
.filter(|argument| argument.as_bytes() == b"--overlay")
.count();
assert_eq!(
count, 1,
"raw_residual_args must retain the --overlay group under --job-json-file"
);
}
#[test]
fn preprocess_qpdf_args_retains_overlay_group_under_the_single_dash_job_json_spelling() {
for spelling in ["--job-json-file=job.json", "-job-json-file=job.json"] {
let preprocessed = preprocess_qpdf_args(strs(&[
"flpdf",
spelling,
"--overlay",
"src.pdf",
"--",
"in.pdf",
"out.pdf",
]))
.expect("qpdf accepts an overlay group under either spelling");
let count = preprocessed
.raw_residual_args
.iter()
.filter(|argument| argument.as_bytes() == b"--overlay")
.count();
assert_eq!(
count, 1,
"raw_residual_args must retain the --overlay group under `{spelling}`"
);
}
}
#[test]
fn preprocess_qpdf_args_drops_overlay_group_from_raw_residual_args_without_job_json() {
let preprocessed = preprocess_qpdf_args(strs(&[
"flpdf",
"--overlay",
"src.pdf",
"--",
"in.pdf",
"out.pdf",
]))
.expect("qpdf accepts a bare overlay group");
let count = preprocessed
.raw_residual_args
.iter()
.filter(|argument| argument.as_bytes() == b"--overlay")
.count();
assert_eq!(
count, 0,
"raw_residual_args must not retain --overlay outside job-json mode"
);
}
#[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 json_input_open_error_uses_qpdf_wording_for_every_kind() {
for (kind, expected) in [
(std::io::ErrorKind::PermissionDenied, "Permission denied"),
(std::io::ErrorKind::AlreadyExists, "File exists"),
(std::io::ErrorKind::InvalidInput, "Invalid argument"),
(std::io::ErrorKind::NotADirectory, "Not a directory"),
] {
let error =
qpdf_json_input_open_error(Path::new("in.json"), std::io::Error::from(kind));
assert_eq!(
error.to_string(),
format!("open in.json: {expected}"),
"{kind:?}"
);
}
}
#[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"
);
}
#[cfg(unix)]
#[test]
fn qpdf_open_io_error_keeps_errno_wording_error_kind_cannot_distinguish() {
for (code, expected) in [(1, "Operation not permitted"), (13, "Permission denied")] {
let error = std::io::Error::from_raw_os_error(code);
assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
assert_eq!(qpdf_open_io_error_message(&error), expected, "errno {code}");
}
}
#[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 every_migrated_inspection_flag_requests_the_combined_route_on_its_own() {
for flag in [
"--check",
"--show-npages",
"--show-pages",
"--show-xref",
"--check-linearization",
"--show-linearization",
"--show-encryption",
"--list-attachments",
"--show-attachment=attachment.txt",
"--show-object=1",
] {
let args = cli_parse_from(vec![
OsString::from("flpdf"),
OsString::from(flag),
OsString::from("in.pdf"),
]);
assert!(
top_level_inspection_combination_requested(&args, false, false),
"{flag} alone must route through the combined job lifecycle"
);
}
}
#[test]
fn a_bare_invocation_does_not_request_the_combined_route() {
let args = cli_parse_from(vec![
OsString::from("flpdf"),
OsString::from("in.pdf"),
OsString::from("out.pdf"),
]);
assert!(!top_level_inspection_combination_requested(
&args, false, false
));
}
#[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 update_input_version_floor_clamps_an_overflow_extension_level() {
let mut body = b"%PDF-1.7\n".to_vec();
let mut offsets = Vec::new();
offsets.push(body.len());
body.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Extensions << /ADBE << /ExtensionLevel 5000000000 >> >> >>\nendobj\n",
);
offsets.push(body.len());
body.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
let xref_offset = body.len();
let n = offsets.len() + 1;
let mut xref = format!("xref\n0 {n}\n0000000000 65535 f \n").into_bytes();
for offset in &offsets {
xref.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
body.extend_from_slice(&xref);
body.extend_from_slice(
format!("trailer\n<< /Size {n} /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open_mem_owned(body).expect("well-formed overflow fixture must parse");
let mut floor = None;
update_input_version_floor(&mut floor, &mut pdf).expect("floor update should succeed");
assert_eq!(floor, Some(PdfVersion::new(1, 7, i64::from(i32::MAX))));
assert!(pdf.repair_diagnostics().entries().iter().any(|entry| {
String::from_utf8_lossy(entry.what_bytes())
.contains("requested value of integer is too big; returning INT_MAX")
}));
}
#[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"));
}
#[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",
]);
assert_eq!(normalize_qpdf_bare_equals(args.clone()), args);
}
#[test]
fn newline_before_endstream_discards_every_equals_value_spelling() {
for value in ["y", "n", "never", "garbage", ""] {
let args = strs(&["flpdf", &format!("--newline-before-endstream={value}")]);
assert_eq!(
normalize_qpdf_bare_equals(args),
strs(&["flpdf", "--newline-before-endstream"]),
"`=({value})` should normalize to the bare flag"
);
}
}
#[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 auxiliary_named_segment_classifier_covers_every_segment_kind() {
let openers: &[&[u8]] = &[
b"--encrypt",
b"--pages",
b"--add-attachment",
b"--copy-attachments-from",
b"--overlay",
b"--underlay",
b"--set-page-labels",
];
for opener in openers {
assert!(
is_named_segment_option(opener),
"every SegmentKind opener must be recognized by auxiliary scans"
);
}
assert!(!is_named_segment_option(b"--ordinary-option"));
assert!(!is_named_segment_option(b"--pages=value"));
}
#[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",
"--",
"--add-attachment",
"two.txt",
"--key=two",
"--",
"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_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 args = cli_parse_from(vec![
OsString::from("flpdf"),
OsString::from("--show-object=2147483648"),
]);
assert!(args.input.is_none());
let mut job = new_cli_job(false);
let error = configure_top_level_inspection_job(&mut job, &args)
.expect_err("overflow selector with no input file");
assert!(
find_usage_error(error.as_ref()).is_some(),
"got {error} instead of a UsageError -- the missing-input-file check must not \
run before selector parsing"
);
}
}