#![forbid(unsafe_code)]
mod arg_parser;
use clap::{ArgGroup, Args as ClapArgs, CommandFactory, Parser, Subcommand, ValueEnum};
use flpdf::fix_qdf;
use flpdf::job::{
apply_rotate_to_pages, flatten_rotation_on_pages, remap_outline_and_dests,
should_remove_unreferenced_resources, AttachmentAddOptions, AttachmentCopyOptions, CheckError,
JobExitCode, JsonJobError, JsonJobOptions, JsonJobOutput, JsonStreamData, PageSpecInput,
QPDFJob, RemoveUnreferencedResources, SplitPageOptions,
};
use flpdf::pipeline::PipelineHandle;
use flpdf::qutil::same_file as qpdf_same_file;
use flpdf::writer::DecodeLevel as StreamDecodeLevel;
use flpdf::{
collate,
objr_obj_annot_p::drop_objr_obj_annot_dangling_p,
pages::tree_rebuild::{rebuild_page_tree, RebuildResult},
struct_tree_pg::drop_struct_elem_dangling_pg,
thread_bead_p::drop_thread_bead_dangling_p,
CombinedPage, CombinedPlan, InputSpec, PageRange, RotateSpec,
};
use flpdf::{
json_inspect::{DecodeLevel, JsonKey, JsonObjectSelector},
linearization::{show_linearization_path_with_warnings, ShowLinearizationError},
normalize_content_stream, pages, parse_pdf_version, AcroFormDocumentHelper, CompressStreams,
CopyEncryptionSource, EncryptMethod, EncryptParams, Error, NewlineBeforeEndstream,
ObjectHandle, ObjectKeyAlg, ObjectRef, ObjectStreamMode, PageDocumentHelper, PageObjectHelper,
PasswordMode, Pdf, PdfOpenOptions, PdfVersion, PdfWriter, PermissionsConfig, PrintPermission,
QPDFLogger, StreamDataMode, UsageError, WriterConfiguration,
};
use std::collections::{BTreeMap, HashSet};
use std::fs::{File, OpenOptions};
use std::io::{BufReader, Cursor, Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
type CliResult<T> = Result<T, Box<dyn std::error::Error>>;
struct PipelineWriter {
pipeline: PipelineHandle,
}
impl Write for PipelineWriter {
fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
self.pipeline.write(data).map_err(std::io::Error::other)?;
Ok(data.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
#[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,
static_id: bool,
deterministic_id: bool,
static_aes_iv: bool,
no_original_object_ids: bool,
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,
}
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,
static_id: false,
deterministic_id: false,
static_aes_iv: false,
no_original_object_ids: false,
min_version: None,
min_extension_level: None,
force_version: None,
force_extension_level: None,
encrypt: None,
copy_encryption: None,
preserve_encryption: true,
}
}
}
#[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 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 writer_configuration(options: &WriterOptions, linearize: bool) -> 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);
configuration.set_qdf_mode(options.qdf && !linearize);
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.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);
}
configuration
}
fn configure_pdf_writer<R: Read + Seek + 'static>(
writer: &mut PdfWriter<'_, R>,
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<()> {
writer_configuration(options, linearize).apply_to(writer);
writer.set_linearization(linearize);
if let Some(path) = linearize_pass1 {
writer.set_linearization_pass1_filename(path.to_path_buf());
}
Ok(())
}
fn write_with_pdf_writer<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
output: &Path,
standard_output: &mut Option<PipelineWriter>,
options: &WriterOptions,
linearize: bool,
linearize_pass1: Option<&Path>,
) -> CliResult<()> {
let mut writer = PdfWriter::new(pdf);
configure_pdf_writer(&mut writer, options, linearize, linearize_pass1)?;
if let Some(sink) = standard_output.take() {
writer.set_output_writer(sink)?;
} else {
writer.set_output_file(output)?;
}
writer.write()?;
Ok(())
}
fn write_qpdf_to_memory<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
) -> CliResult<Vec<u8>> {
let mut writer = PdfWriter::new(pdf);
configure_pdf_writer(&mut writer, options, false, None)?;
writer.set_output_memory()?;
writer.write()?;
Ok(writer.get_buffer()?)
}
#[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, Parser)]
#[command(name = "flpdf")]
#[command(about = "Pure Rust qpdf-style PDF tool")]
#[command(args_conflicts_with_subcommands = true)]
#[command(group(
ArgGroup::new("attachment_op")
.multiple(false)
.args([
"add_attachment",
"remove_attachment",
"list_attachments",
"show_attachment",
"copy_attachments_from",
])
))]
struct Cli {
#[command(subcommand)]
command: Option<Commands>,
#[arg(long, conflicts_with = "output")]
check: bool,
#[arg(long)]
no_warn: bool,
#[arg(
long = "check-linearization",
conflicts_with_all = [
"check",
"show_object",
"show_npages",
"show_pages",
"show_xref",
"show_linearization",
"show_encryption",
"job_json_file",
"json",
"json_input",
"update_from_json",
"json_output",
"json_key",
"json_object",
"json_stream_data",
"json_stream_prefix",
"linearize",
"static_id",
"deterministic_id",
"static_aes_iv",
"remove_restrictions",
"decrypt",
"qdf",
"preserve_unreferenced",
"coalesce_contents",
"pages",
"rotate",
"split_pages",
"collate",
"empty",
"overlay",
"underlay",
"add_attachment",
"remove_attachment",
"list_attachments",
"show_attachment",
"copy_attachments_from",
"encrypt",
"copy_encryption",
"encryption_file_password",
"output",
]
)]
check_linearization: bool,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(long, conflicts_with = "output")]
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")]
show_npages: bool,
#[arg(long, conflicts_with = "output")]
show_pages: bool,
#[arg(long, conflicts_with = "output")]
show_xref: bool,
#[arg(long, conflicts_with = "output")]
show_linearization: bool,
#[arg(long = "show-encryption", conflicts_with = "output")]
show_encryption: bool,
#[arg(long = "show-encryption-key")]
show_encryption_key: bool,
#[arg(long = "job-json-file", value_name = "PATH", require_equals = true)]
job_json_file: Option<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", "linearize", "static_id", "deterministic_id", "static_aes_iv",
"show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"compress_streams", "linearize_pass1", "remove_restrictions",
"decrypt", "encrypt", "copy_encryption",
"add_attachment", "remove_attachment", "list_attachments",
"show_attachment", "copy_attachments_from",
"no_original_object_ids", "qdf", "coalesce_contents",
"preserve_unreferenced",
],
help = "Generate JSON v2 output (qpdf --json compatible)")]
json: Option<String>,
#[arg(
long = "json-input",
conflicts_with_all = [
"show_object",
"show_linearization", "list_attachments", "show_attachment",
"remove_attachment", "add_attachment", "copy_attachments_from",
],
help = "Treat INPUT as qpdf JSON v2 (qpdf --json-input)"
)]
json_input: bool,
#[arg(
long = "update-from-json",
value_name = "QPDF-JSON",
require_equals = true,
conflicts_with_all = [
"show_object",
"show_linearization", "list_attachments", "show_attachment",
"remove_attachment", "add_attachment", "copy_attachments_from",
],
help = "Apply a qpdf JSON update before processing (qpdf --update-from-json)"
)]
update_from_json: Option<PathBuf>,
#[arg(
long = "json-output",
num_args = 0..=1,
default_missing_value = "2",
require_equals = true,
value_name = "VERSION",
value_parser = ["1", "2", "latest"],
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",
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",
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",
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",
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<String>,
#[arg(long)]
linearize: bool,
#[arg(long = "min-version")]
min_version: Option<String>,
#[arg(long = "force-version")]
force_version: Option<String>,
#[arg(long = "static-id")]
static_id: bool,
#[arg(long = "deterministic-id", conflicts_with = "static_id")]
deterministic_id: bool,
#[arg(long = "static-aes-iv", hide = true)]
static_aes_iv: bool,
#[arg(long = "remove-restrictions",
conflicts_with_all = [
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
])]
remove_restrictions: bool,
#[arg(long = "decrypt",
conflicts_with_all = [
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
])]
decrypt: bool,
#[arg(long = "compress-streams")]
compress_streams: Option<String>,
#[arg(long = "decode-level", value_enum)]
decode_level: Option<CliDecodeLevel>,
#[arg(
long = "object-streams",
value_enum,
default_value_t = CliObjectStreamMode::Preserve
)]
object_streams: CliObjectStreamMode,
#[arg(long = "stream-data", value_enum)]
stream_data: Option<CliStreamDataMode>,
#[arg(long = "linearize-pass1")]
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 = "normalize-content",
value_enum,
help = "Normalize page content streams (qpdf default: n; --qdf default: y)"
)]
normalize_content: Option<CliYesNo>,
#[arg(long = "coalesce-contents",
conflicts_with_all = [
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"list_attachments", "show_attachment", "remove_attachment",
"add_attachment", "copy_attachments_from",
"linearize", "pages", "rotate", "split_pages", "empty",
])]
coalesce_contents: 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<String>,
#[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<String>,
#[arg(
long = "add-attachment",
num_args = 1..,
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<String>,
#[arg(
long = "remove-attachment",
value_name = "KEY",
help = "Remove the embedded file with the given key (qpdf --remove-attachment)"
)]
remove_attachment: Option<String>,
#[arg(
long = "list-attachments",
conflicts_with = "output",
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 = "show-attachment",
conflicts_with = "output",
value_name = "KEY",
help = "Extract the embedded file with the given key to stdout \
(qpdf --show-attachment)"
)]
show_attachment: Option<String>,
#[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<String>,
#[arg(
long = "encrypt",
num_args = 3..,
value_terminator = "--",
allow_hyphen_values = true,
value_name = "USER-PW OWNER-PW KEY-LEN [sub-flags]",
// Reject combinations that don't make sense on the rewrite path.
// --remove-restrictions / --decrypt overlap with --encrypt and are
// rejected because they imply contradictory output forms; --check /
// --show-object / --show-* are inspection paths that don't produce an
// output file at all. --linearize is NOT rejected: qpdf itself
// supports `--linearize --encrypt ...` (verified: `qpdf --linearize
// --encrypt "" "" 128 --use-aes=y --` produces a valid,
// `qpdf --check`-clean linearized+encrypted file), and
// `write_linearized` threads `options.encrypt` through correctly.
conflicts_with_all = [
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"remove_restrictions", "decrypt",
"copy_encryption",
],
help = "Encrypt output (qpdf --encrypt compatible): \
USER-PW OWNER-PW KEY-LEN [sub-flags] --"
)]
encrypt: Vec<String>,
#[arg(
long = "copy-encryption",
value_name = "FILE",
conflicts_with_all = [
"encrypt",
"check", "show_object",
"show_npages", "show_pages", "show_xref", "show_linearization",
"show_encryption",
"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",
requires = "copy_encryption",
help = "User password to open the donor PDF for --copy-encryption"
)]
encryption_file_password: Option<String>,
input: Option<PathBuf>,
output: Option<PathBuf>,
}
#[derive(Debug, Clone, Default, ClapArgs)]
struct PageOpArgs {
#[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<String>,
#[arg(
long = "rotate",
action = clap::ArgAction::Append,
value_name = "[+|-]angle[:range]",
help = "Rotate pages by 0/90/180/270 degrees (qpdf --rotate); repeatable"
)]
rotate: Vec<String>,
#[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,
default_missing_value = "1",
require_equals = true,
value_name = "N",
help = "Collate --pages selections in groups of N (qpdf --collate[=n], default 1)"
)]
collate: Option<String>,
#[arg(
long = "empty",
help = "(qpdf --empty) start from an empty document — NOT yet implemented"
)]
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(name = "dump-object", about = "Dump one indirect object as PDF syntax")]
DumpObject(DumpObjectCommand),
#[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(about = "Rewrite the input PDF to a normalized output")]
Rewrite(RewriteCommand),
#[command(
name = "show-stream",
about = "Show a stream object's decoded (or raw) data"
)]
ShowStream(ShowStreamCommand),
#[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 DumpObjectCommand {
object_ref: String,
input: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[derive(Debug, ClapArgs)]
struct ShowStreamCommand {
object_ref: String,
input: PathBuf,
#[arg(long = "raw-stream-data")]
raw_stream_data: bool,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[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 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", conflicts_with = "static_id")]
deterministic_id: bool,
#[arg(long = "static-aes-iv", hide = true)]
static_aes_iv: bool,
#[arg(long = "remove-restrictions")]
remove_restrictions: bool,
#[arg(long = "decrypt")]
decrypt: bool,
#[arg(
long = "encrypt",
num_args = 3..,
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: Vec<String>,
#[arg(
long = "copy-encryption",
value_name = "FILE",
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",
requires = "copy_encryption",
help = "User password to open the donor PDF for --copy-encryption"
)]
encryption_file_password: Option<String>,
#[arg(long = "min-version")]
min_version: Option<String>,
#[arg(long = "force-version")]
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, default_value_t = CliObjectStreamMode::Preserve)]
object_streams: CliObjectStreamMode,
#[arg(
long = "compress-streams",
value_enum,
help = "Compress output streams with FlateDecode (qpdf default: y)"
)]
compress_streams: Option<CliYesNo>,
#[arg(long = "decode-level", value_enum)]
decode_level: Option<CliDecodeLevel>,
#[arg(
long = "normalize-content",
value_enum,
help = "Normalize page content streams (qpdf default: n)"
)]
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,
default_value_t = CliRemoveUnreferencedResources::Auto,
help = "Remove unreferenced /Resources entries (qpdf default: auto)")]
remove_unreferenced_resources: CliRemoveUnreferencedResources,
#[arg(long = "newline-before-endstream", value_enum, num_args = 0..=1,
require_equals = true, default_missing_value = "y",
default_value_t = CliNewlineBeforeEndstream::Never,
help = "Insert newline before endstream keyword (qpdf default: never)")]
newline_before_endstream: CliNewlineBeforeEndstream,
#[arg(long = "stream-data", value_enum)]
stream_data: Option<CliStreamDataMode>,
#[arg(long = "recompress-flate")]
recompress_flate: bool,
#[arg(
long = "flatten-annotations",
value_enum,
value_name = "MODE",
help = "Flatten annotations into page content; MODE is all, screen, or print"
)]
flatten_annotations: Option<CliFlattenMode>,
#[arg(
long = "generate-appearances",
help = "Generate appearance streams for form fields that lack them"
)]
generate_appearances: bool,
#[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<String>,
#[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<String>,
#[arg(
long = "verbose",
help = "Print verbose progress and diagnostic messages \
(mirrors qpdf --verbose)"
)]
verbose: 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 {
fn flags(self) -> (i64, i64) {
match self {
CliFlattenMode::All => (0, 0x3),
CliFlattenMode::Screen => (0, 0x3 | 0x20),
CliFlattenMode::Print => (0x4, 0x3),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliYesNo {
#[clap(name = "y")]
Yes,
#[clap(name = "n")]
No,
}
fn normalize_content_enabled(setting: Option<CliYesNo>, qdf: bool) -> bool {
match setting {
Some(CliYesNo::Yes) => true,
Some(CliYesNo::No) => false,
None => qdf,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliNewlineBeforeEndstream {
#[clap(name = "y")]
Yes,
#[clap(name = "n")]
No,
#[clap(name = "never")]
Never,
}
#[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(long, conflicts_with = "password_file")]
password: Option<String>,
#[arg(long = "password-file", value_name = "PATH")]
password_file: Option<PathBuf>,
#[arg(long = "password-mode", value_enum, default_value_t = CliPasswordMode::Auto)]
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,
}
#[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;
}
eprintln!(
"flpdf: warning: --static-id is for testing only and must not be \
used for production output"
);
}
fn preprocess_qpdf_args(args: Vec<String>) -> CliResult<PreprocessedArgs> {
let parsed = arg_parser::ArgParser::from_command(Cli::command()).parse(args)?;
let mut overlay_specs = Vec::new();
let mut attachment_segments = Vec::new();
for segment in parsed.named_segments {
match segment.option.as_str() {
"overlay" => overlay_specs.push(parse_overlay_segment(
OverlayKind::Overlay,
&segment.tokens,
)?),
"underlay" => overlay_specs.push(parse_overlay_segment(
OverlayKind::Underlay,
&segment.tokens,
)?),
"add-attachment" => attachment_segments.push(segment.tokens),
_ => {}
}
}
Ok(PreprocessedArgs {
residual_args: parsed.residual_args,
overlay_specs,
attachment_segments,
})
}
fn print_qpdf_version() {
println!(
"qpdf version {}\nRun qpdf --copyright to see copyright and license information.",
flpdf::qpdf_version()
);
}
fn print_qpdf_copyright() {
println!(
"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.",
flpdf::qpdf_version()
);
}
fn main() {
let _ = cli_logger();
let raw_args: Vec<String> = std::env::args().collect();
if raw_args.len() == 2 {
match raw_args[1].as_str() {
"--version" | "-version" => {
print_qpdf_version();
return;
}
"--copyright" | "-copyright" => {
print_qpdf_copyright();
return;
}
_ => {}
}
}
let PreprocessedArgs {
residual_args,
overlay_specs,
attachment_segments,
} = match preprocess_qpdf_args(raw_args) {
Ok(parsed) => parsed,
Err(error) => {
eprintln!("flpdf: {error}");
std::process::exit(2);
}
};
let args = Cli::parse_from(residual_args);
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) => {
eprintln!("flpdf: {error}");
std::process::exit(1);
}
};
let normalize_content = normalize_content_enabled(args.normalize_content, args.qdf);
warn_if_static_id(&args);
if args.qdf && args.linearize {
eprintln!("flpdf: --qdf and --linearize cannot be used together");
std::process::exit(1);
}
if normalize_content
&& (args.remove_attachment.is_some()
|| !args.add_attachment.is_empty()
|| !args.copy_attachments_from.is_empty())
{
eprintln!(
"flpdf: --normalize-content is not applied by attachment mutation operations; \
rerun with --normalize-content=n or without the attachment operation"
);
std::process::exit(1);
}
if matches!(args.decode_level, Some(level) if level != CliDecodeLevel::None)
&& (args.remove_attachment.is_some()
|| !args.add_attachment.is_empty()
|| !args.copy_attachments_from.is_empty())
{
eprintln!(
"flpdf: --decode-level is not applied by attachment mutation operations; \
rerun with --decode-level=none or without the attachment operation"
);
std::process::exit(1);
}
if !overlay_specs.is_empty() {
let target_is_rewrite = match &args.command {
Some(Commands::Rewrite(_)) => true,
Some(_) => false,
None => {
args.json.is_none()
&& args.show_object.is_none()
&& !args.show_npages
&& !args.show_pages
&& !args.show_xref
&& !args.check_linearization
&& !args.show_linearization
&& !args.show_encryption
&& !args.check
&& !args.list_attachments
&& args.show_attachment.is_none()
&& args.remove_attachment.is_none()
&& args.add_attachment.is_empty()
&& args.copy_attachments_from.is_empty()
}
};
if !target_is_rewrite {
eprintln!(
"flpdf: --overlay/--underlay can only be used with rewrite output, \
not with inspection or other commands"
);
std::process::exit(2);
}
}
let json_input_inspection = (args.json_input || args.update_from_json.is_some())
&& (args.check
|| args.show_npages
|| args.show_pages
|| args.show_xref
|| args.show_encryption);
let result = if let Some(path) = args.job_json_file.as_deref() {
run_job_json_file(
path,
args.input.as_deref(),
args.output.as_deref(),
&args.password,
)
} else if json_input_inspection {
run_json_input_inspection(&args)
} else if args.json.is_some() || args.json_output.is_some() {
run_json(&args)
} else if let Some(command) = args.command {
run_command(command, &overlay_specs)
} else if let Some(object_ref) = args.show_object.as_deref() {
run_show_object(
args.input,
args.repair,
&args.password,
object_ref,
args.raw_stream_data,
args.filtered_stream_data,
)
} else if args.show_npages {
run_show_npages(args.input, args.repair, &args.password)
} else if args.show_pages {
run_show_pages(args.input, args.repair, &args.password)
} else if args.show_xref {
run_show_xref(args.input, args.repair, &args.password)
} else if args.check_linearization {
run_check_linearization(args.input, args.repair, &args.password, args.no_warn)
} else if args.show_linearization {
run_show_linearization(args.input)
} else if args.show_encryption {
match args.input.as_ref() {
Some(input) => run_show_encryption(input, args.repair, &args.password, args.no_warn),
None => Err("--show-encryption requires an input file".into()),
}
} else if args.check {
run_check(args.input, args.repair, &args.password, args.no_warn)
} else if args.list_attachments {
run_list_attachments(args.input, args.repair, &args.password, args.verbose)
} else if let Some(key) = args.show_attachment {
run_show_attachment(args.input, args.repair, &args.password, &key)
} else if let Some(key) = args.remove_attachment {
run_remove_attachment(
args.input,
args.output,
args.repair,
&args.password,
&key,
args.deterministic_id,
args.static_id,
args.preserve_unreferenced,
&top_level_version_options,
)
} else if !args.add_attachment.is_empty() {
run_add_attachment(
args.input,
args.output,
args.repair,
&args.password,
attachment_segments,
args.deterministic_id,
args.static_id,
args.preserve_unreferenced,
args.verbose,
&top_level_version_options,
)
} else if !args.copy_attachments_from.is_empty() {
run_copy_attachments_from(
args.input,
args.output,
args.repair,
&args.password,
args.copy_attachments_from,
args.deterministic_id,
args.static_id,
args.preserve_unreferenced,
args.verbose,
&top_level_version_options,
)
} else if args.linearize {
if page_ops_active(&args.page_ops) {
eprintln!("flpdf: --linearize cannot be combined with --pages/--rotate/--split-pages");
std::process::exit(1);
}
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,
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(),
..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 => {
eprintln!("flpdf: --compress-streams must be y or n, got: {:?}", other);
std::process::exit(2);
}
}
}
apply_encryption_options(
&mut options,
&args.encrypt,
args.copy_encryption.as_deref(),
args.encryption_file_password.as_deref(),
&args.password,
);
let result = run_rewrite(
args.input,
args.output.clone(),
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,
CliRemoveUnreferencedResources::No, false, None, false, &overlay_specs,
args.verbose,
options,
);
result
} else if page_ops_active(&args.page_ops) {
if !args.encrypt.is_empty() {
eprintln!(
"flpdf: --encrypt is not applied in the \
--pages/--rotate/--split-pages/--collate pipeline; \
rerun without --encrypt or without the page operation"
);
std::process::exit(1);
}
if args.copy_encryption.is_some() {
eprintln!(
"flpdf: --copy-encryption is not applied in the \
--pages/--rotate/--split-pages/--collate pipeline; \
rerun without --copy-encryption or without the page operation"
);
std::process::exit(1);
}
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,
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,
..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 => {
eprintln!("flpdf: --compress-streams must be y or n, got: {:?}", other);
std::process::exit(2);
}
}
}
let dispatch = |input: PathBuf, output: PathBuf| -> CliResult<()> {
if !args.page_ops.pages.is_empty() {
run_page_extraction(
&input,
&output,
args.repair,
&args.password,
args.json_input,
args.update_from_json.as_deref(),
&args.page_ops,
&overlay_specs,
CliRemoveUnreferencedResources::Auto,
options.clone(),
args.verbose,
)
} else {
if !overlay_specs.is_empty() {
eprintln!(
"flpdf: --overlay/--underlay is not applied with \
--rotate/--split-pages alone (no --pages); \
rerun with --pages or without the overlay"
);
std::process::exit(1);
}
run_rewrite_with_page_ops(
&input,
&output,
args.repair,
&args.password,
args.json_input,
args.update_from_json.as_deref(),
&args.page_ops,
options.clone(),
args.verbose,
)
}
};
match (args.input.clone(), args.output.clone()) {
(Some(i), Some(o)) => dispatch(i, o),
_ => Err("page operations require both an input and an output file".into()),
}
} else {
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,
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,
..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 => {
eprintln!("flpdf: --compress-streams must be y or n, got: {:?}", other);
std::process::exit(2);
}
}
}
apply_encryption_options(
&mut options,
&args.encrypt,
args.copy_encryption.as_deref(),
args.encryption_file_password.as_deref(),
&args.password,
);
run_rewrite(
args.input,
args.output,
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,
CliRemoveUnreferencedResources::No, false, None, false, &overlay_specs,
args.verbose,
options,
)
};
if let Err(error) = result {
if let Some(exit_err) = error.downcast_ref::<CliExitError>() {
if !exit_err.message.is_empty() {
emit_logger_error(format!("\n{}: {}\n", progname(), exit_err.message));
}
std::process::exit(exit_err.code.as_i32());
}
if let Some(usage_error) = find_usage_error(error.as_ref()) {
usage_exit(usage_error);
}
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 usage_exit(error: &UsageError) -> ! {
let who = progname();
emit_logger_error(format!(
"\n{who}: {error}\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"
));
std::process::exit(2);
}
fn run_job_json_file(
path: &Path,
input: Option<&Path>,
output: Option<&Path>,
password: &PasswordArgs,
) -> CliResult<()> {
let json = std::fs::read_to_string(path)
.map_err(|error| error_with_file(path, Box::new(error) as Box<dyn std::error::Error>))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.initialize_from_json_partial(&json).map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(path, error),
}) as Box<dyn std::error::Error>
})?;
if let Some(input) = input {
job.set_input_file(input.to_path_buf()).map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(path, error),
}) as Box<dyn std::error::Error>
})?;
}
if let Some(output) = output {
job.set_output_file(output.to_path_buf()).map_err(|error| {
Box::new(CliExitError {
code: ExitCode::Errors,
message: format_job_json_error(path, error),
}) as Box<dyn std::error::Error>
})?;
}
if let Some(password) = password.password.as_deref() {
job.set_password(password.as_bytes().to_vec());
}
job.set_message_prefix(progname());
finish_job_exit_status(job.run()?)
}
fn format_job_json_error(path: &Path, error: impl std::fmt::Display) -> String {
format!(
"error with job-json file {}: {error}\nRun {} --job-json-help for information on the file format.\n\nFor help:\n {} --help=usage usage information\n {} --help=topic help on a topic\n {} --help=--option help on an option\n {} --help general help and a topic list\n",
path.display(),
progname(),
progname(),
progname(),
progname(),
progname(),
)
}
fn run_json(cli: &Cli) -> 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") {
eprintln!(
"flpdf: json keys \"objects\" and \"objectinfo\" are only valid for json version 1"
);
std::process::exit(2);
}
if json_version == 1 && raw == "qpdf" {
eprintln!("flpdf: json key \"qpdf\" is only valid for json version > 1");
std::process::exit(2);
}
match JsonKey::from_str(raw.as_str()) {
Some(k) => json_keys.push(k),
None => {
let names = QPDF_JSON_KEY_NAMES.join(",");
eprintln!("flpdf: --json-key must be given as --json-key={{{names}}}");
std::process::exit(2);
}
}
}
if json_output_mode {
if json_version == 1 {
eprintln!("flpdf: --json-output requires JSON version 2");
std::process::exit(2);
}
if !json_keys.contains(&JsonKey::Qpdf) {
json_keys.push(JsonKey::Qpdf);
}
}
let mut json_objects: Vec<JsonObjectSelector> = Vec::new();
for raw in &cli.json_object {
match JsonObjectSelector::from_str(raw.as_str()) {
Some(s) => json_objects.push(s),
None => {
eprintln!(
"flpdf: --json-object selector \"{raw}\" must be 'trailer', 'N', or 'N,G'"
);
std::process::exit(2);
}
}
}
let stream_data = match cli
.json_stream_data
.as_deref()
.unwrap_or(if json_output_mode { "inline" } else { "none" })
{
"none" => JsonStreamData::None,
"inline" => JsonStreamData::Inline,
"file" => JsonStreamData::File,
other => {
eprintln!("flpdf: --json-stream-data must be none, inline, or file; got: {other}");
std::process::exit(2);
}
};
let input = cli.input.as_ref().ok_or("missing input file")?;
if let Some(output) = cli
.output
.as_ref()
.filter(|path| path.as_path() != Path::new("-"))
{
reject_same_json_output(input, output)?;
}
let mut standard_output = if cli
.output
.as_ref()
.is_none_or(|path| path.as_path() == Path::new("-"))
{
Some(standard_save_writer()?)
} else {
None
};
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
let input_file = File::open(input).map_err(|error| {
if cli.json_input {
qpdf_json_input_open_error(input, error)
} else {
json_input_open_error(input, error)
}
})?;
let input_identity = input_file
.try_clone()
.map_err(|error| error_with_file(input, error.into()))?;
if cli.json_input {
let mut pdf = job.create_from_json_document(input_file, input.display().to_string())?;
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
let mut runtime = JsonJobRuntime {
input_identity: &input_identity,
standard_output: &mut standard_output,
job: &mut job,
};
run_json_document(
cli,
&mut runtime,
&mut pdf,
json_version,
cli.test_json_schema,
cli.show_encryption_key,
json_output_mode,
stream_data,
&json_keys,
&json_objects,
)
} else {
let mut pdf = open_pdf_from_file(input, input_file, cli.repair, &cli.password)?;
job.record_document_warnings(&pdf);
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
let mut runtime = JsonJobRuntime {
input_identity: &input_identity,
standard_output: &mut standard_output,
job: &mut job,
};
run_json_document(
cli,
&mut runtime,
&mut pdf,
json_version,
cli.test_json_schema,
cli.show_encryption_key,
json_output_mode,
stream_data,
&json_keys,
&json_objects,
)
}
}
fn run_json_input_inspection(cli: &Cli) -> CliResult<()> {
let input = cli.input.as_ref().ok_or("missing input file")?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(cli.no_warn);
let file = File::open(input).map_err(|error| {
if cli.json_input {
qpdf_json_input_open_error(input, error)
} else {
error_with_file(input, error.into())
}
})?;
if cli.json_input {
let mut pdf = job.create_from_json_document(file, input.display().to_string())?;
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
return run_job_inspection_on_pdf(cli, &mut job, &mut pdf);
}
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(BufReader::new(file), input.display().to_string(), options) {
Ok(pdf) => pdf,
Err(error) => {
job.report_open_failure(&error)?;
return Err(error_with_file(input, actionable_password_error(error)));
}
};
apply_json_update_with_job(&mut job, &mut pdf, cli.update_from_json.as_deref())?;
run_job_inspection_on_pdf(cli, &mut job, &mut pdf)
}
fn run_job_inspection_on_pdf<R: Read + Seek + 'static>(
cli: &Cli,
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
) -> CliResult<()> {
if cli.check {
return finish_check_job(job.check(pdf));
}
if cli.show_npages {
return finish_job_exit_status(job.show_npages(pdf)?);
}
if cli.show_pages {
return finish_job_exit_status(job.show_pages(pdf)?);
}
if cli.show_xref {
return finish_job_exit_status(job.show_xref(pdf)?);
}
if cli.show_encryption {
return finish_show_encryption(job, pdf, cli.password.password_is_hex_key);
}
Err("JSON input/update inspection mode is missing a consumer".into())
}
#[allow(clippy::too_many_arguments)]
fn run_json_document<R: Read + Seek>(
cli: &Cli,
runtime: &mut JsonJobRuntime<'_>,
pdf: &mut Pdf<R>,
json_version: i32,
test_json_schema: bool,
show_encryption_key: bool,
json_output_mode: bool,
stream_data: JsonStreamData,
json_keys: &[JsonKey],
json_objects: &[JsonObjectSelector],
) -> CliResult<()> {
let json_decode_level =
cli.decode_level
.map(DecodeLevel::from)
.unwrap_or(if json_output_mode {
DecodeLevel::None
} else {
DecodeLevel::Generalized
});
let output_path = cli
.output
.as_ref()
.filter(|path| path.as_path() != Path::new("-"));
let json_result = if let Some(path) = output_path {
let mut file = open_verified_json_output(runtime.input_identity, path)?;
let options = JsonJobOptions {
decode_level: json_decode_level,
stream_data,
stream_prefix: cli.json_stream_prefix.as_deref(),
keys: json_keys,
objects: json_objects,
};
runtime.job.write_json_with_version(
pdf,
json_version,
test_json_schema,
json_output_mode,
show_encryption_key,
options,
JsonJobOutput::File {
filename: path,
writer: &mut file,
},
)
} else {
let options = JsonJobOptions {
decode_level: json_decode_level,
stream_data,
stream_prefix: cli.json_stream_prefix.as_deref(),
keys: json_keys,
objects: json_objects,
};
runtime.job.write_json_with_version(
pdf,
json_version,
test_json_schema,
json_output_mode,
show_encryption_key,
options,
JsonJobOutput::Stdout(
runtime
.standard_output
.as_mut()
.expect("stdout writer prepared for JSON stdout"),
),
)
};
match json_result {
Ok(JobExitCode::Success) => {}
Ok(JobExitCode::Error) => {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
Ok(JobExitCode::Warning) => {
return Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}))
}
Err(JsonJobError::Output(error)) => return Err(Box::new(error)),
Err(JsonJobError::Usage(error)) => return Err(Box::new(error)),
Err(JsonJobError::Completion(error)) => return Err(Box::new(error)),
}
Ok(())
}
fn run_command(command: Commands, overlay_specs: &[OverlaySpec]) -> CliResult<()> {
match command {
Commands::Check(cmd) => run_check(Some(cmd.input), cmd.repair, &cmd.password, false),
Commands::CheckLinearization(cmd) => {
run_check_linearization(Some(cmd.input), false, &PasswordArgs::default(), false)
}
Commands::DumpObject(cmd) => {
run_dump_object(Some(cmd.input), cmd.repair, &cmd.password, &cmd.object_ref)
}
Commands::Pages(cmd) => {
if cmd.show_npages {
run_show_npages(Some(cmd.input), cmd.repair, &cmd.password)
} else {
run_show_pages(Some(cmd.input), cmd.repair, &cmd.password)
}
}
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::ShowStream(cmd) => run_show_stream(cmd),
Commands::ShowEncryption(cmd) => {
run_show_encryption(&cmd.input, cmd.repair, &cmd.password, false)
}
Commands::IsEncrypted(cmd) => run_is_encrypted(&cmd.input, cmd.repair, cmd.recovery),
Commands::RequiresPassword(cmd) => {
run_requires_password(&cmd.input, cmd.repair, &cmd.password)
}
Commands::ShowEncryptionKey(cmd) => {
run_show_encryption_key(&cmd.input, cmd.repair, &cmd.password)
}
Commands::Rewrite(cmd) => {
let version_options = match parse_cli_version_options(
cmd.min_version.as_deref(),
cmd.force_version.as_deref(),
) {
Ok(options) => options,
Err(error) => {
eprintln!("flpdf: {error}");
std::process::exit(1);
}
};
if cmd.qdf && cmd.linearize {
eprintln!("flpdf: --qdf and --linearize cannot be used together");
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,
qdf: cmd.qdf,
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: match cmd.newline_before_endstream {
CliNewlineBeforeEndstream::Yes => NewlineBeforeEndstream::Yes,
CliNewlineBeforeEndstream::No => NewlineBeforeEndstream::Yes,
CliNewlineBeforeEndstream::Never => NewlineBeforeEndstream::Never,
},
stream_data: cmd.stream_data.map(Into::into),
recompress_flate: cmd.recompress_flate,
..WriterOptions::default()
};
apply_cli_decode_level(&mut options, cmd.decode_level);
apply_cli_version_options(&mut options, &version_options);
apply_encryption_options(
&mut options,
&cmd.encrypt,
cmd.copy_encryption.as_deref(),
cmd.encryption_file_password.as_deref(),
&cmd.password,
);
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;
if cmd.linearize
&& (cmd.generate_appearances
|| cmd.flatten_annotations.is_some()
|| cmd.flatten_rotation)
{
eprintln!(
"flpdf: --linearize cannot be combined with \
--flatten-annotations/--generate-appearances/--flatten-rotation"
);
std::process::exit(1);
}
if page_ops_active(&cmd.page_ops) {
if cmd.linearize {
eprintln!(
"flpdf: --linearize cannot be combined with --pages/--rotate/--split-pages"
);
std::process::exit(1);
}
if cmd.page_ops.pages.is_empty() && !overlay_specs.is_empty() {
eprintln!(
"flpdf: --overlay/--underlay is not applied with \
--rotate/--split-pages alone (no --pages); \
rerun with --pages or without the overlay"
);
std::process::exit(1);
}
if coalesce_contents
|| cmd.remove_restrictions
|| cmd.decrypt
|| !cmd.encrypt.is_empty()
|| cmd.copy_encryption.is_some()
|| cmd.generate_appearances
|| cmd.flatten_annotations.is_some()
|| cmd.flatten_rotation
{
eprintln!(
"flpdf: --coalesce-contents / --remove-restrictions / --decrypt / --encrypt / \
--copy-encryption / --flatten-annotations / \
--generate-appearances / --flatten-rotation are \
not applied in the --pages/--rotate/--split-pages/\
--collate pipeline; rerun without them or without \
the page operation"
);
std::process::exit(1);
}
if cmd.page_ops.pages.is_empty()
&& remove_unref != CliRemoveUnreferencedResources::Auto
{
eprintln!(
"flpdf: --remove-unreferenced-resources is not applied \
with --rotate/--split-pages alone; rerun without it \
or add --pages"
);
std::process::exit(1);
}
return if !cmd.page_ops.pages.is_empty() {
run_page_extraction(
&cmd.input,
&cmd.output,
cmd.repair,
&cmd.password,
false,
None,
&cmd.page_ops,
overlay_specs,
remove_unref,
options,
cmd.verbose,
)
} else {
run_rewrite_with_page_ops(
&cmd.input,
&cmd.output,
cmd.repair,
&cmd.password,
false,
None,
&cmd.page_ops,
options,
cmd.verbose,
)
};
}
run_rewrite(
Some(cmd.input),
Some(cmd.output),
cmd.repair,
&cmd.password,
false,
None,
cmd.linearize,
None,
cmd.remove_restrictions,
cmd.decrypt,
normalize_content,
coalesce_contents,
remove_unref,
cmd.generate_appearances,
cmd.flatten_annotations,
cmd.flatten_rotation,
overlay_specs,
cmd.verbose,
options,
)
}
}
}
fn run_check(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let file = File::open(&input).map_err(|error| error_with_file(&input, error.into()))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(no_warn);
let mut options = pdf_open_options(repair, password)?;
options.suppress_warnings = true;
let mut pdf = match job.open(BufReader::new(file), input.display().to_string(), options) {
Ok(pdf) => pdf,
Err(error) => {
job.report_open_failure(&error)?;
return Err(error_with_file(&input, actionable_password_error(error)));
}
};
finish_check_job(job.check(&mut pdf))
}
fn run_check_linearization(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let file = File::open(&input).map_err(|error| error_with_file(&input, error.into()))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(no_warn);
let options = pdf_open_options(repair, password)?;
let mut pdf = job
.open(BufReader::new(file), input.display().to_string(), options)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
finish_job_exit_status(job.check_linearization(&mut pdf)?)
}
fn apply_encryption_options(
options: &mut WriterOptions,
encrypt: &[String],
copy_encryption: Option<&std::path::Path>,
encryption_file_password: Option<&str>,
password_args: &PasswordArgs,
) {
if !encrypt.is_empty() {
match parse_encrypt_segment(encrypt, password_args.allow_weak_crypto) {
Ok(params) => {
options.encrypt = Some(params);
}
Err(e) => {
eprintln!("flpdf: {e}");
std::process::exit(2);
}
}
}
if let Some(donor_path) = copy_encryption {
match build_copy_encryption_source(donor_path, encryption_file_password, password_args) {
Ok(src) => {
options.copy_encryption = Some(src);
}
Err(e) => {
eprintln!("flpdf: {e}");
std::process::exit(2);
}
}
}
}
fn build_copy_encryption_source(
path: &std::path::Path,
password: Option<&str>,
password_args: &PasswordArgs,
) -> CliResult<CopyEncryptionSource> {
let file =
File::open(path).map_err(|e| format!("--copy-encryption: cannot open {:?}: {e}", path))?;
let reader = BufReader::new(file);
let mut donor_password = password_args.clone();
donor_password.password = Some(password.unwrap_or("").to_owned());
donor_password.password_file = None;
let mut opts = pdf_open_options(true, &donor_password)
.map_err(|error| format!("--copy-encryption: failed to configure {:?}: {error}", path))?;
configure_document_logger(&mut opts, path);
let mut donor = Pdf::open_with_options(reader, opts)
.map_err(|e| format!("--copy-encryption: failed to open {:?}: {e}", path))?;
donor
.root_handle()
.map_err(|e| format!("--copy-encryption: failed to open {:?}: {e}", path))?;
let info = donor
.encryption_info()
.map_err(|e| format!("--copy-encryption: failed to read encryption info: {e}"))?
.ok_or_else(|| format!("--copy-encryption: donor {:?} is not encrypted", path))?;
let is_v4_aes128 = info.v == 4
&& info.length_bits == 128
&& info.stream_method == "AESv2"
&& info.string_method == "AESv2";
if !is_v4_aes128 {
return Err(format!(
"--copy-encryption: donor {:?} uses V={} length={} \
stream={} string={} — only V=4 AES-128 donors are accepted",
path, info.v, info.length_bits, info.stream_method, info.string_method,
)
.into());
}
let file_key: Vec<u8> = donor.encryption_file_key().ok_or_else(|| {
format!(
"--copy-encryption: failed to recover donor file key for {:?} \
(wrong --encryption-file-password?)",
path
)
})?;
let mut source = donor
.writer_copy_encryption_source()?
.ok_or_else(|| format!("--copy-encryption: donor {:?} is not encrypted", path))?;
source.file_key = file_key;
source.object_key_alg = ObjectKeyAlg::Aes;
Ok(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()),
}
}
fn parse_encrypt_segment(tokens: &[String], allow_weak_crypto: bool) -> CliResult<EncryptParams> {
if tokens.len() < 3 {
return Err(format!(
"--encrypt requires USER-PW OWNER-PW KEY-LEN (got {} arg(s))",
tokens.len()
)
.into());
}
for token in &tokens[..3] {
if token.starts_with("-") && token != "-" {
return Err(format!(
"unrecognized argument {token} (encryption options must be terminated with --)"
)
.into());
}
}
let user_pw = tokens[0].as_bytes().to_vec();
let owner_pw = tokens[1].as_bytes().to_vec();
let key_len: u32 = tokens[2].parse().map_err(|_| {
format!(
"--encrypt KEY-LEN must be a positive integer (40 / 128 / 256), got: {:?}",
tokens[2]
)
})?;
if !matches!(key_len, 40 | 128 | 256) {
return Err(format!("--encrypt KEY-LEN must be 40, 128, or 256 (got {key_len})").into());
}
let mut use_aes: Option<bool> = None;
let mut force_v4 = false;
let mut force_r5 = false;
let mut allow_insecure = false;
let mut perms = PermissionsConfig::default();
let mut perm_flag_seen = false;
let mut cleartext_metadata = false;
for tok in &tokens[3..] {
let (flag, val) = tok.split_once('=').unwrap_or((tok.as_str(), ""));
match flag {
"--use-aes" => {
use_aes = Some(match val {
"y" => true,
"n" => false,
other => {
return Err(format!("--use-aes must be y or n (got {other:?})").into());
}
});
}
"--force-V4" => {
if tok.contains('=') {
return Err(format!("--force-V4 does not take a value (got {tok:?})").into());
}
force_v4 = true;
}
"--allow-insecure" => {
if tok.contains('=') {
return Err(
format!("--allow-insecure does not take a value (got {tok:?})").into(),
);
}
allow_insecure = true;
}
"--print" => {
perm_flag_seen = true;
perms.print = match val {
"full" => PrintPermission::High,
"low" => PrintPermission::Low,
"none" => PrintPermission::None,
other => {
return Err(
format!("--print must be full, low, or none (got {other:?})").into(),
);
}
};
}
"--modify" => {
perm_flag_seen = true;
let (other_, annot, forms, asm) = match val {
"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 = annot;
perms.fill_forms = forms;
perms.assemble = asm;
}
"--extract" => {
perm_flag_seen = true;
perms.extract = parse_perm_yn(flag, val)?;
}
"--annotate" => {
perm_flag_seen = true;
perms.annotate = parse_perm_yn(flag, val)?;
}
"--form" => {
perm_flag_seen = true;
perms.fill_forms = parse_perm_yn(flag, val)?;
}
"--assemble" => {
perm_flag_seen = true;
perms.assemble = parse_perm_yn(flag, val)?;
}
"--accessibility" => {
perm_flag_seen = true;
perms.accessibility = parse_perm_yn(flag, val)?;
}
"--cleartext-metadata" => {
if tok.contains('=') {
return Err(format!(
"--cleartext-metadata does not take a value (got {tok:?})"
)
.into());
}
cleartext_metadata = true;
}
"--force-R5" => {
if tok.contains('=') {
return Err(format!("--force-R5 does not take a value (got {tok:?})").into());
}
force_r5 = true;
}
other => {
return Err(format!(
"unknown --encrypt sub-flag {other:?}; supported in this release: \
--use-aes=y|n, --force-V4, --force-R5, --allow-insecure, --print, --modify, \
--extract, --annotate, --form, --assemble, --accessibility, \
--cleartext-metadata"
)
.into());
}
}
}
match key_len {
40 if use_aes.is_some() || force_v4 || force_r5 || allow_insecure || perm_flag_seen => {
return Err(
"--encrypt KEY-LEN=40 (V=1 RC4-40, R=2) does not accept --use-aes, \
--force-V4, --force-R5, --allow-insecure, or permission sub-flags; the R>=3 \
permission grammar needs a 128- or 256-bit key"
.into(),
);
}
128 if allow_insecure || force_r5 => {
return Err(
"--encrypt KEY-LEN=128 does not accept --allow-insecure or --force-R5 (256-bit only)".into(),
);
}
256 if use_aes.is_some() || force_v4 => {
return Err(
"--encrypt KEY-LEN=256 does not accept --use-aes or --force-V4 (128-bit only)"
.into(),
);
}
_ => {}
}
let guard_weak = |params: EncryptParams| -> CliResult<EncryptParams> {
if !allow_weak_crypto {
if params.is_weak_rc4() {
return Err(
"refusing to write a file with RC4, a weak cryptographic algorithm. \
Please use 256-bit keys for better security. Pass --allow-weak-crypto \
to enable writing insecure files."
.into(),
);
}
if params.is_deprecated_r5() {
return Err(
"refusing to write a deprecated revision 5 (R=5) encrypted file. \
256-bit revision 6 (the default without --force-R5) is preferred. \
Pass --allow-weak-crypto to enable writing R=5 files."
.into(),
);
}
}
Ok(params)
};
if cleartext_metadata {
let is_v4_or_v5 = key_len == 256 || (key_len == 128 && (use_aes == Some(true) || force_v4));
if !is_v4_or_v5 {
return Err(
"--cleartext-metadata requires V=4 or V=5 (256-bit, or 128-bit with \
--use-aes=y or --force-V4); V=1/V=2 have no /EncryptMetadata"
.into(),
);
}
}
match key_len {
40 => guard_weak(EncryptParams::rc4(
EncryptMethod::V1Rc440,
user_pw,
owner_pw,
)),
128 => {
let mut params = match use_aes {
Some(true) => EncryptParams::v4_aes128(user_pw, owner_pw),
Some(false) | None => {
let method = if force_v4 {
EncryptMethod::V4Rc4128
} else {
EncryptMethod::V2Rc4128
};
EncryptParams::rc4(method, user_pw, owner_pw)
}
};
params.permissions = perms;
if matches!(
params.method,
EncryptMethod::V4Aes128 | EncryptMethod::V4Rc4128
) {
params.permissions.accessibility = true;
}
if cleartext_metadata {
params.encrypt_metadata = false;
}
guard_weak(params)
}
256 => {
if owner_pw.is_empty() && !user_pw.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 force_r5 {
EncryptParams::v5_r5(user_pw, owner_pw)
} else {
EncryptParams::v5_r6(user_pw, owner_pw)
};
params.permissions = perms;
params.permissions.accessibility = true;
if cleartext_metadata {
params.encrypt_metadata = false;
}
guard_weak(params)
}
_ => unreachable!("key_len validated to 40/128/256 above"),
}
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite(
input: Option<PathBuf>,
output: Option<PathBuf>,
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,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
overlay_specs: &[OverlaySpec],
verbose: bool,
options: WriterOptions,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let output = output.ok_or("missing output file")?;
reject_same_job_output(&input, &output)?;
let opened = open_job_pdf(
&input,
repair,
password,
json_input,
update_from_json,
false,
)?;
match opened {
JobPdf::File(pdf) => run_rewrite_opened(
pdf,
&input,
&output,
repair,
password,
linearize,
linearize_pass1,
remove_restrictions,
decrypt,
normalize_content,
coalesce_contents,
_remove_unref,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
overlay_specs,
verbose,
options,
),
JobPdf::Json(pdf) => run_rewrite_opened(
pdf,
&input,
&output,
repair,
password,
linearize,
linearize_pass1,
remove_restrictions,
decrypt,
normalize_content,
coalesce_contents,
_remove_unref,
generate_appearances,
flatten_annotations_mode,
flatten_rotation,
overlay_specs,
verbose,
options,
),
}
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite_opened<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
input: &Path,
output: &Path,
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,
flatten_annotations_mode: Option<CliFlattenMode>,
flatten_rotation: bool,
overlay_specs: &[OverlaySpec],
verbose: bool,
options: WriterOptions,
) -> CliResult<()> {
let mut standard_output = prepare_pdf_standard_output(output)?;
if linearize && !overlay_specs.is_empty() {
return Err("--overlay/--underlay cannot be combined with --linearize".into());
}
if linearize {
let had_signatures = if remove_restrictions {
AcroFormDocumentHelper::new(&mut pdf)?.disable_digital_signatures()?
} else {
false
};
let mut options = options;
if decrypt || remove_restrictions {
options.preserve_encryption = false;
}
let normalization_last_bad = if normalize_content {
normalize_page_contents(&mut pdf)?
} else {
Vec::new()
};
let announce_file = standard_output.is_none();
write_with_pdf_writer(
&mut pdf,
output,
&mut standard_output,
&options,
true,
linearize_pass1,
)?;
if verbose && announce_file {
logger_info(format!("flpdf: wrote file {}\n", output.display()))?;
}
if had_signatures {
logger_warn("flpdf: warning: removed signatures; signatures are now invalidated\n")?;
}
finish_rewrite_warnings(input, &pdf, &normalization_last_bad, announce_file)?;
} else {
let was_encrypted = pdf.is_encrypted();
let had_signatures = if remove_restrictions {
AcroFormDocumentHelper::new(&mut pdf)?.disable_digital_signatures()?
} else {
false
};
let mut options = options;
if decrypt || remove_restrictions {
options.preserve_encryption = false;
}
if generate_appearances {
generate_missing_appearances(&mut pdf)?;
}
if let Some(mode) = flatten_annotations_mode {
let (required_flags, forbidden_flags) = mode.flags();
PageDocumentHelper::new(&mut pdf)
.flatten_annotations(required_flags, forbidden_flags)?;
}
if coalesce_contents {
let page_refs = pages::page_refs(&mut pdf)?;
for page_ref in page_refs {
PageObjectHelper::new(page_ref, &mut pdf).coalesce_content_streams()?;
}
}
if flatten_rotation {
let page_refs = pages::page_refs(&mut pdf)?;
flatten_rotation_on_pages(&mut pdf, &page_refs)?;
}
let _built_overlay_specs = if !overlay_specs.is_empty() {
let mut built = build_overlay_specs(overlay_specs, repair, password)?;
let initial_version =
parse_pdf_version(pdf.version()).unwrap_or(PdfVersion::new(1, 0, 0));
let mut max_version = PdfVersion::new(
initial_version.major(),
initial_version.minor(),
pdf.adobe_extension_level().unwrap_or(0),
);
for spec in built.iter_mut() {
let source_version =
parse_pdf_version(spec.source.version()).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
source_version.major(),
source_version.minor(),
spec.source.adobe_extension_level().unwrap_or(0),
));
}
if let Some(ref current) = options.min_version {
let current_version =
parse_pdf_version(current).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
current_version.major(),
current_version.minor(),
options.min_extension_level.unwrap_or(0),
));
}
let (version, max_ext) = max_version.get_version();
options.min_version = Some(version);
options.min_extension_level = (max_ext > 0).then_some(max_ext);
if verbose {
let report = flpdf::overlay_verbose_report(&mut pdf, &mut built)?;
let mut message = String::from("flpdf: processing underlay/overlay\n");
for page in &report {
message.push_str(&format!(" page {}\n", page.dest_page));
for src in &page.sources {
let file = &overlay_specs[src.spec_index].file;
let kind_str = match src.kind {
flpdf::OverlayKind::Underlay => "underlay",
flpdf::OverlayKind::Overlay => "overlay",
};
message.push_str(&format!(" {} {} {}\n", file, kind_str, src.src_page));
}
}
logger_info(message)?;
}
flpdf::apply_overlay_specs(&mut pdf, &mut built)?;
Some(built)
} else {
None
};
let normalization_last_bad = if normalize_content {
normalize_page_contents(&mut pdf)?
} else {
Vec::new()
};
let announce_file = standard_output.is_none();
write_with_pdf_writer(
&mut pdf,
output,
&mut standard_output,
&options,
false,
None,
)?;
if verbose && announce_file {
logger_info(format!("flpdf: wrote file {}\n", output.display()))?;
}
if remove_restrictions && was_encrypted {
eprintln!("flpdf: removed restrictions (encryption and advisory permissions stripped)");
}
if had_signatures {
logger_warn("flpdf: warning: removed signatures; signatures are now invalidated\n")?;
}
finish_rewrite_warnings(input, &pdf, &normalization_last_bad, announce_file)?;
}
Ok(())
}
fn generate_missing_appearances<R: Read + Seek>(pdf: &mut Pdf<R>) -> CliResult<()> {
AcroFormDocumentHelper::new(pdf)?.generate_appearances_if_needed()?;
Ok(())
}
struct PageSegmentSpec {
file_token: String,
password: Option<String>,
range: String,
}
fn parse_pages_segment(tokens: &[String]) -> CliResult<Vec<PageSegmentSpec>> {
let mut specs: Vec<PageSegmentSpec> = Vec::new();
for tok in tokens {
if let Some(path) = tok.strip_prefix("--file=") {
specs.push(PageSegmentSpec {
file_token: path.to_string(),
password: None,
range: String::new(),
});
continue;
}
if let Some(pw) = tok.strip_prefix("--password=") {
let cur = specs
.last_mut()
.ok_or("--pages: --password= must follow a file in the --pages segment")?;
cur.password = Some(pw.to_string());
continue;
}
if let Some(r) = tok.strip_prefix("--range=") {
let cur = specs
.last_mut()
.ok_or("--pages: --range= must follow a file in the --pages segment")?;
if !cur.range.is_empty() {
return Err("--pages: duplicate page-range for one input file".into());
}
cur.range = r.to_string();
continue;
}
if tok.starts_with("--") {
return Err(format!(
"--pages: unsupported token {tok:?} in the page-selection segment"
)
.into());
}
match specs.last_mut() {
Some(cur) if cur.range.is_empty() && PageRange::parse(tok).is_ok() => {
cur.range = tok.clone();
}
_ => specs.push(PageSegmentSpec {
file_token: tok.clone(),
password: None,
range: String::new(),
}),
}
}
if specs.is_empty() {
return Err("--pages: no input files given in the page-selection segment".into());
}
Ok(specs)
}
fn resolve_page_specs(
specs: &[PageSegmentSpec],
primary_input: &std::path::Path,
) -> CliResult<Vec<InputSpec>> {
let mut out = Vec::with_capacity(specs.len());
for s in specs {
let path: PathBuf = if s.file_token == "." {
primary_input.to_path_buf()
} else {
PathBuf::from(&s.file_token)
};
let range = PageRange::parse(&s.range).map_err(|e| {
Box::<dyn std::error::Error>::from(format!(
"--pages: invalid page range {:?}: {e}",
s.range
))
})?;
out.push(InputSpec::new(path, s.password.clone(), range));
}
Ok(out)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OverlayKind {
Overlay,
Underlay,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct OverlaySpec {
kind: OverlayKind,
file: String,
password: Option<String>,
from: Option<String>,
to: Option<String>,
repeat: Option<String>,
}
struct PreprocessedArgs {
residual_args: Vec<String>,
overlay_specs: Vec<OverlaySpec>,
attachment_segments: Vec<Vec<String>>,
}
fn parse_overlay_segment(kind: OverlayKind, tokens: &[String]) -> CliResult<OverlaySpec> {
let flag = match kind {
OverlayKind::Overlay => "--overlay",
OverlayKind::Underlay => "--underlay",
};
if tokens.is_empty() {
return Err(format!("{flag}: no source file given in the segment").into());
}
let mut file: Option<String> = None;
let mut password: Option<String> = None;
let mut from: Option<String> = None;
let mut to: Option<String> = None;
let mut repeat: Option<String> = None;
for tok in tokens {
if let Some(path) = tok.strip_prefix("--file=") {
if file.is_some() {
return Err(format!("{flag}: duplicate file in segment").into());
}
file = Some(path.to_string());
continue;
}
if let Some(pw) = tok.strip_prefix("--password=") {
if password.is_some() {
return Err(format!("{flag}: duplicate --password= in segment").into());
}
password = Some(pw.to_string());
continue;
}
if let Some(r) = tok.strip_prefix("--to=") {
if to.is_some() {
return Err(format!("{flag}: duplicate --to= in segment").into());
}
PageRange::parse(r)
.map_err(|e| format!("{flag}: invalid --to= page range {r:?}: {e}"))?;
to = Some(r.to_string());
continue;
}
if let Some(r) = tok.strip_prefix("--from=") {
if from.is_some() {
return Err(format!("{flag}: duplicate --from= in segment").into());
}
PageRange::parse(r)
.map_err(|e| format!("{flag}: invalid --from= page range {r:?}: {e}"))?;
from = Some(r.to_string());
continue;
}
if let Some(r) = tok.strip_prefix("--repeat=") {
if repeat.is_some() {
return Err(format!("{flag}: duplicate --repeat= in segment").into());
}
PageRange::parse(r)
.map_err(|e| format!("{flag}: invalid --repeat= page range {r:?}: {e}"))?;
repeat = Some(r.to_string());
continue;
}
if tok.starts_with("--") {
return Err(format!("{flag}: unsupported token {tok:?} in segment").into());
}
if file.is_some() {
return Err(format!("{flag}: duplicate file in segment").into());
}
file = Some(tok.clone());
}
let file = file.ok_or_else(|| format!("{flag}: no source file given in the segment"))?;
Ok(OverlaySpec {
kind,
file,
password,
from,
to,
repeat,
})
}
#[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
}
#[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)?);
}
Ok((parsed.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)
.collect();
Ok((parsed.residual_args, groups))
}
fn build_overlay_specs(
specs: &[OverlaySpec],
repair: bool,
password: &PasswordArgs,
) -> CliResult<Vec<flpdf::OverlaySpec<BufReader<File>>>> {
let mut built = Vec::with_capacity(specs.len());
for spec in specs {
let path = PathBuf::from(&spec.file);
let file = File::open(&path).map_err(|error| error_with_file(&path, error.into()))?;
let mut source_password = password.clone();
source_password.password = spec.password.clone();
source_password.password_file = None;
let mut options = pdf_open_options(repair, &source_password)?;
configure_document_logger(&mut options, &path);
let mut source = Pdf::open_with_options(BufReader::new(file), 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::parse("")?,
Some("") => PageRange::empty(),
Some(r) => PageRange::parse(r)?,
};
let to = match spec.to.as_deref() {
None => PageRange::parse("")?,
Some("") => PageRange::empty(),
Some(r) => PageRange::parse(r)?,
};
let repeat = match spec.repeat.as_deref() {
None | Some("") => None,
Some(r) => Some(PageRange::parse(r)?),
};
built.push(flpdf::OverlaySpec {
source,
kind,
from,
to,
repeat,
});
}
Ok(built)
}
fn parse_collate_n(raw: &str) -> CliResult<usize> {
let n: usize = raw.parse().map_err(|_| {
format!(
"--collate: expected a single positive integer, got {raw:?} \
(comma-separated group lists are not supported)"
)
})?;
if n == 0 {
return Err("--collate: group size must be >= 1".into());
}
Ok(n)
}
fn pages_progress_filename(p: &std::path::Path) -> String {
p.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| p.display().to_string())
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction(
primary_input: &std::path::Path,
output: &std::path::Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
options: WriterOptions,
verbose: bool,
) -> CliResult<()> {
if page_ops.split_pages.is_none() {
reject_same_job_output(primary_input, output)?;
}
let standard_output = prepare_page_operation_standard_output(output, page_ops)?;
let creates_output = standard_output.is_none();
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
let specs = parse_pages_segment(&page_ops.pages)?;
let mut inputs = resolve_page_specs(&specs, primary_input)?;
let has_external_source = inputs.iter().any(|spec| spec.path != primary_input);
if !has_external_source {
if let Some(top_pw) = &password.password {
for spec in &mut inputs {
if spec.password.is_none() {
spec.password = Some(top_pw.clone());
}
}
}
}
let mut distinct: Vec<std::path::PathBuf> = Vec::new();
for spec in &inputs {
let key = std::fs::canonicalize(&spec.path).unwrap_or_else(|_| spec.path.clone());
if !distinct.contains(&key) {
distinct.push(key);
}
}
if json_input || update_from_json.is_some() {
let primary_canonical =
std::fs::canonicalize(primary_input).unwrap_or_else(|_| primary_input.to_path_buf());
if distinct.iter().any(|path| *path != primary_canonical) {
return Err(
"--pages: cross-document page merge is not supported at this layer \
(an explicit --pages source differs from the --json-input/\
--update-from-json primary input). Single-document extraction \
('.' or the primary input's own path) is supported; cross-doc \
merge with a JSON-created/updated primary is tracked in a \
separate issue."
.into(),
);
}
let opened = open_job_pdf(
primary_input,
repair,
password,
json_input,
update_from_json,
false,
)?;
return match opened {
JobPdf::File(pdf) => run_page_extraction_from_repeated_pdf(
pdf,
primary_input,
output,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
options,
verbose,
standard_output,
creates_output,
&inputs,
&distinct,
),
JobPdf::Json(pdf) => run_page_extraction_from_repeated_pdf(
pdf,
primary_input,
output,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
options,
verbose,
standard_output,
creates_output,
&inputs,
&distinct,
),
};
}
if has_external_source {
return run_page_extraction_from_multiple_sources(
primary_input,
output,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
options,
verbose,
standard_output,
creates_output,
inputs,
);
}
let primary_encrypted =
open_pdf(&primary_input.to_path_buf(), repair, password)?.is_encrypted();
if verbose {
let mut message = String::from("flpdf: selecting --keep-open-files=y\n");
for path in &distinct {
let fname = pages_progress_filename(path);
message.push_str(&format!(
"flpdf: {fname}: checking for shared resources\nflpdf: no shared resources found\n"
));
}
logger_info(message)?;
}
let plan = CombinedPlan::from_specs(inputs.clone())?;
if verbose {
let mut message = String::from("flpdf: removing unreferenced pages from primary input\n");
for spec in &inputs {
message.push_str(&format!(
"flpdf: adding pages from {}\n",
pages_progress_filename(&spec.path)
));
}
logger_info(message)?;
}
let combined_pages = match page_ops.collate.as_deref() {
Some(raw) => {
let n = parse_collate_n(raw)?;
collate(&plan, n)?
}
None => plan.flat_pages().to_vec(),
};
let source_path = &inputs[0].path;
let source_password = inputs[0].password.clone();
let mut src_pw = password.clone();
if let Some(pw) = source_password {
src_pw.password = Some(pw);
src_pw.password_file = None;
}
let mut pdf = open_pdf(&source_path.to_path_buf(), repair, &src_pw)?;
let primary_copy_encryption = pdf.writer_copy_encryption_source()?;
run_page_extraction_after_plan(
pdf,
output,
source_path,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
options,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
false,
true,
combined_pages,
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_multiple_sources(
primary_input: &Path,
output: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
options: WriterOptions,
verbose: bool,
standard_output: Option<PipelineWriter>,
creates_output: bool,
inputs: Vec<InputSpec>,
) -> CliResult<()> {
let primary_encrypted =
open_pdf(&primary_input.to_path_buf(), repair, password)?.is_encrypted();
let mut source_paths = vec![primary_input.to_path_buf()];
let mut source_passwords: Vec<Option<String>> = vec![None];
let mut specs = Vec::with_capacity(inputs.len());
for input in inputs {
let source_index = if input.path == primary_input {
0
} else if let Some(index) = source_paths.iter().position(|path| path == &input.path) {
index
} else {
let index = source_paths.len();
source_paths.push(input.path.clone());
source_passwords.push(input.password.clone());
index
};
specs.push(PageSpecInput::new(source_index, input.range));
}
if verbose {
let mut message = String::from("flpdf: selecting --keep-open-files=y\n");
for path in &source_paths {
let fname = pages_progress_filename(path);
message.push_str(&format!(
"flpdf: {fname}: checking for shared resources\nflpdf: no shared resources found\n"
));
}
message.push_str("flpdf: removing unreferenced pages from primary input\n");
for path in &source_paths {
message.push_str(&format!(
"flpdf: adding pages from {}\n",
pages_progress_filename(path)
));
}
logger_info(message)?;
}
let mut sources = Vec::with_capacity(source_paths.len());
sources.push(open_pdf(&primary_input.to_path_buf(), repair, password)?);
for (source_index, path) in source_paths.iter().enumerate().skip(1) {
let mut source_password = password.clone();
source_password.password = source_passwords[source_index].clone();
source_password.password_file = None;
sources.push(open_pdf(path, repair, &source_password)?);
}
let mut options = options;
let mut max_version = PdfVersion::new(1, 0, 0);
for source in &mut sources {
let source_version =
parse_pdf_version(source.version()).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
source_version.major(),
source_version.minor(),
source.adobe_extension_level().unwrap_or(0),
));
}
if let Some(ref current) = options.min_version {
let current_version = parse_pdf_version(current).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
current_version.major(),
current_version.minor(),
options.min_extension_level.unwrap_or(0),
));
}
let (version, max_ext) = max_version.get_version();
options.min_version = Some(version);
options.min_extension_level = (max_ext > 0).then_some(max_ext);
let primary_copy_encryption = sources
.first_mut()
.ok_or("--pages: primary input was not opened")?
.writer_copy_encryption_source()?;
let collate = page_ops
.collate
.as_deref()
.map(parse_collate_n)
.transpose()?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
let source_warnings = job.has_warnings();
let mut merged = job.handle_page_specs(
&mut sources,
&specs,
collate,
remove_unref.into(),
options.preserve_unreferenced_objects,
)?;
let source_warnings = source_warnings || job.has_warnings();
let selected = pages::page_refs(&mut merged)?;
let combined_pages: Vec<CombinedPage> = selected
.iter()
.enumerate()
.map(|(index, &page_ref)| {
Ok(CombinedPage {
source_index: 0,
page: flpdf::SelectedPage {
index_1based: u32::try_from(index + 1)
.map_err(|_| "--pages: too many output pages")?,
page_ref,
},
})
})
.collect::<CliResult<Vec<_>>>()?;
run_page_extraction_after_plan(
merged,
output,
primary_input,
repair,
password,
page_ops,
overlay_specs,
CliRemoveUnreferencedResources::No,
options,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
source_warnings,
false,
combined_pages,
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_from_repeated_pdf<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
primary_input: &Path,
output: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
options: WriterOptions,
verbose: bool,
standard_output: Option<PipelineWriter>,
creates_output: bool,
inputs: &[InputSpec],
distinct: &[PathBuf],
) -> CliResult<()> {
let primary_encrypted = pdf.is_encrypted();
let primary_copy_encryption = pdf.writer_copy_encryption_source()?;
if verbose {
let mut message = String::from("flpdf: selecting --keep-open-files=y\n");
for path in distinct {
let fname = pages_progress_filename(path);
message.push_str(&format!(
"flpdf: {fname}: checking for shared resources\nflpdf: no shared resources found\n"
));
}
logger_info(message)?;
}
let ranges = inputs.iter().map(|spec| spec.range.clone()).collect();
let plan = CombinedPlan::build_repeated(&mut pdf, ranges)?;
if verbose {
let mut message = String::from("flpdf: removing unreferenced pages from primary input\n");
for spec in inputs {
message.push_str(&format!(
"flpdf: adding pages from {}\n",
pages_progress_filename(&spec.path)
));
}
logger_info(message)?;
}
let combined_pages = match page_ops.collate.as_deref() {
Some(raw) => {
let n = parse_collate_n(raw)?;
collate(&plan, n)?
}
None => plan.flat_pages().to_vec(),
};
run_page_extraction_after_plan(
pdf,
output,
primary_input,
repair,
password,
page_ops,
overlay_specs,
remove_unref,
options,
verbose,
standard_output,
creates_output,
primary_encrypted,
primary_copy_encryption,
false,
true,
combined_pages,
)
}
#[allow(clippy::too_many_arguments)]
fn run_page_extraction_after_plan<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
output: &Path,
input_path: &Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
options: WriterOptions,
verbose: bool,
mut standard_output: Option<PipelineWriter>,
creates_output: bool,
primary_encrypted: bool,
primary_copy_encryption: Option<CopyEncryptionSource>,
prior_warnings: bool,
reconstruct_labels: bool,
combined_pages: Vec<CombinedPage>,
) -> CliResult<()> {
let selected: Vec<ObjectRef> = combined_pages.iter().map(|cp| cp.page.page_ref).collect();
if selected.is_empty() {
return Err("--pages: page selection is empty".into());
}
let prune_mode = if remove_unref == CliRemoveUnreferencedResources::Auto
&& !should_remove_unreferenced_resources(&mut pdf)?
{
CliRemoveUnreferencedResources::No
} else {
remove_unref
};
let result = rebuild_page_tree(&mut pdf, &selected)?;
copy_duplicate_page_annotations(&mut pdf, &result)?;
apply_rotate_specs(&mut pdf, &page_ops.rotate, &result.new_kids)?;
if reconstruct_labels {
let mut labels = pdf.page_labels();
if labels.has_page_labels()? {
let src_indices: Vec<i64> = combined_pages
.iter()
.map(|cp| i64::from(cp.page.index_1based) - 1)
.collect();
let entries = labels.labels_for_selection_with_prefix_presence(&src_indices, 0)?;
let folded = flpdf::merge_adjacent_ranges_with_prefix_presence(entries);
labels.write_reconstructed_labels_with_prefix_presence(&folded)?;
}
}
remap_outline_and_dests(&mut pdf, &result)?;
let objr_obj_targets = drop_struct_elem_dangling_pg(&mut pdf, &result)?;
drop_thread_bead_dangling_p(&mut pdf, &result)?;
drop_objr_obj_annot_dangling_p(&mut pdf, &result, &objr_obj_targets)?;
QPDFJob::prune_after_subset(&mut pdf, prune_mode.into())?;
QPDFJob::prune_acroform_after_subset(&mut pdf, &result)?;
let mut options = options;
options.preserve_encryption = primary_encrypted && page_ops.split_pages.is_none();
if page_ops.split_pages.is_none()
&& options.copy_encryption.is_none()
&& !options.qdf
&& !options.content_normalization
&& !matches!(
options.stream_data,
Some(StreamDataMode::Uncompress) | Some(StreamDataMode::Compress)
)
&& !(options.decode_level_set && options.decode_level != StreamDecodeLevel::None)
{
options.copy_encryption = primary_copy_encryption;
}
let _built_overlay_specs = if !overlay_specs.is_empty() {
let mut built = build_overlay_specs(overlay_specs, repair, password)?;
let initial_version = parse_pdf_version(pdf.version()).unwrap_or(PdfVersion::new(1, 0, 0));
let mut max_version = PdfVersion::new(
initial_version.major(),
initial_version.minor(),
pdf.adobe_extension_level().unwrap_or(0),
);
for spec in built.iter_mut() {
let source_version =
parse_pdf_version(spec.source.version()).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
source_version.major(),
source_version.minor(),
spec.source.adobe_extension_level().unwrap_or(0),
));
}
if let Some(ref current) = options.min_version {
let current_version = parse_pdf_version(current).unwrap_or(PdfVersion::new(1, 0, 0));
max_version.update_if_greater(PdfVersion::new(
current_version.major(),
current_version.minor(),
options.min_extension_level.unwrap_or(0),
));
}
let (version, max_ext) = max_version.get_version();
options.min_version = Some(version);
options.min_extension_level = (max_ext > 0).then_some(max_ext);
if verbose {
let report = flpdf::overlay_verbose_report(&mut pdf, &mut built)?;
let mut message = String::from("flpdf: processing underlay/overlay\n");
for page in &report {
message.push_str(&format!(" page {}\n", page.dest_page));
for src in &page.sources {
let file = &overlay_specs[src.spec_index].file;
let kind_str = match src.kind {
flpdf::OverlayKind::Underlay => "underlay",
flpdf::OverlayKind::Overlay => "overlay",
};
message.push_str(&format!(" {} {} {}\n", file, kind_str, src.src_page));
}
}
logger_info(message)?;
}
flpdf::apply_overlay_specs(&mut pdf, &mut built)?;
Some(built)
} else {
None
};
let bytes = write_qpdf_to_memory(&mut pdf, &options)?;
if let Some(raw) = page_ops.split_pages.as_deref() {
let n = parse_split_n(raw)?;
let (written, mut split_job) = split_rewritten_pdf(
bytes,
n,
output,
input_path,
options.deterministic_id,
writer_configuration(&options, false),
)?;
if verbose {
for path in &written {
logger_info(format!("flpdf: wrote file {}\n", path.display()))?;
}
}
split_job.record_document_warnings(&pdf);
if prior_warnings {
split_job.record_warnings();
}
return finish_job_exit_status(split_job.complete(true)?);
} else if let Some(writer) = standard_output.as_mut() {
writer.write_all(&bytes)?;
} else {
std::fs::write(output, &bytes)?;
if verbose {
logger_info(format!("flpdf: wrote file {}\n", output.display()))?;
}
}
finish_operation_warnings_with_prior(&pdf, creates_output, prior_warnings)
}
fn copy_duplicate_page_annotations<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> flpdf::Result<()> {
let mut first_occurrence: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
for page_refs in result.ref_map.values() {
let Some(&first_page) = page_refs.first() else {
continue;
};
for &duplicate_page in page_refs.iter().skip(1) {
first_occurrence.insert(duplicate_page, first_page);
}
}
for &new_page in &result.new_kids {
let Some(&source_page_ref) = first_occurrence.get(&new_page) else {
continue;
};
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");
pdf.mark_object_handle_dirty(&destination_page)?;
PageObjectHelper::new(new_page, pdf)
.copy_annotations(source_page, flpdf::Matrix::default())?;
}
Ok(())
}
fn apply_rotate_specs<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
rotate_args: &[String],
target_pages: &[ObjectRef],
) -> CliResult<()> {
if rotate_args.is_empty() {
return Ok(());
}
let total = u32::try_from(target_pages.len())
.map_err(|_| "too many pages to apply --rotate".to_string())?;
for raw in rotate_args {
let spec =
RotateSpec::parse(raw).map_err(|e| format!("--rotate: invalid spec {raw:?}: {e}"))?;
let indices = spec
.range
.resolve(total)
.map_err(|e| format!("--rotate: page range out of bounds in {raw:?}: {e}"))?;
let pages: Vec<ObjectRef> = indices
.iter()
.filter_map(|&i| target_pages.get((i - 1) as usize).copied())
.collect();
apply_rotate_to_pages(pdf, &pages, &spec.op)?;
}
Ok(())
}
fn parse_split_n(raw: &str) -> CliResult<usize> {
let n: usize = raw
.parse()
.map_err(|_| format!("--split-pages: expected a positive integer, got {raw:?}"))?;
if n == 0 {
return Err("--split-pages: group size must be >= 1".into());
}
Ok(n)
}
fn split_rewritten_pdf(
bytes: Vec<u8>,
chunk_size: usize,
output: &Path,
input_path: &Path,
deterministic_id: bool,
writer_configuration: WriterConfiguration,
) -> CliResult<(Vec<PathBuf>, QPDFJob)> {
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
let input_name = input_path.to_string_lossy().into_owned();
let mut pdf = job.open(Cursor::new(bytes), input_name, PdfOpenOptions::default())?;
let options = SplitPageOptions::new(chunk_size, output)
.with_input_path(input_path)
.with_deterministic_id(deterministic_id)
.with_writer_configuration(writer_configuration);
let written = job.split_pages(&mut pdf, options)?;
Ok((written, job))
}
#[allow(clippy::too_many_arguments)]
fn run_rewrite_with_page_ops(
input: &std::path::Path,
output: &std::path::Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
page_ops: &PageOpArgs,
options: WriterOptions,
verbose: bool,
) -> CliResult<()> {
let opened = open_job_pdf(input, repair, password, json_input, update_from_json, false)?;
match opened {
JobPdf::File(pdf) => {
run_rewrite_with_page_ops_opened(pdf, input, output, page_ops, options, verbose)
}
JobPdf::Json(pdf) => {
run_rewrite_with_page_ops_opened(pdf, input, output, page_ops, options, verbose)
}
}
}
fn run_rewrite_with_page_ops_opened<R: Read + Seek + 'static>(
mut pdf: Pdf<R>,
input: &Path,
output: &std::path::Path,
page_ops: &PageOpArgs,
options: WriterOptions,
verbose: bool,
) -> CliResult<()> {
let mut standard_output = prepare_page_operation_standard_output(output, page_ops)?;
let creates_output = standard_output.is_none();
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
if !page_ops.rotate.is_empty() {
let page_refs = pages::page_refs(&mut pdf)?;
apply_rotate_specs(&mut pdf, &page_ops.rotate, &page_refs)?;
}
let mut options = options;
options.preserve_encryption = page_ops.split_pages.is_none() && pdf.is_encrypted();
let bytes = write_qpdf_to_memory(&mut pdf, &options)?;
if let Some(raw) = page_ops.split_pages.as_deref() {
let n = parse_split_n(raw)?;
let (written, mut split_job) = split_rewritten_pdf(
bytes,
n,
output,
input,
options.deterministic_id,
writer_configuration(&options, false),
)?;
if verbose {
for path in &written {
logger_info(format!("flpdf: wrote file {}\n", path.display()))?;
}
}
split_job.record_document_warnings(&pdf);
return finish_job_exit_status(split_job.complete(true)?);
} else if let Some(writer) = standard_output.as_mut() {
writer.write_all(&bytes)?;
} else {
std::fs::write(output, &bytes)?;
if verbose {
logger_info(format!("flpdf: wrote file {}\n", output.display()))?;
}
}
finish_operation_warnings(&pdf, creates_output)
}
fn page_ops_active(p: &PageOpArgs) -> bool {
!p.pages.is_empty() || !p.rotate.is_empty() || p.split_pages.is_some() || 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);
pdf.resolve(&page)?;
let contents = page.get_key(b"/Contents");
let contents_ref = contents.object_ref();
pdf.resolve(&contents)?;
let mut streams = Vec::new();
if contents.as_stream_dict().is_some() {
if let Some(stream_ref) = contents_ref {
streams.push((stream_ref, contents));
}
} else if let Some(items) = contents.as_array() {
for item in items {
let item_ref = item.object_ref();
pdf.resolve(&item)?;
if item.as_stream_dict().is_some() {
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(pdf, stream_ref, stream, seen)? {
warnings.push(last_bad);
}
}
Ok(warnings)
}
fn normalize_and_store_stream_handle<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
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();
pdf.mark_object_handle_dirty(&stream)?;
Ok(warning)
}
fn run_qdf(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
preserve_unreferenced: bool,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let output = output.ok_or("missing output file")?;
let mut standard_output = prepare_pdf_standard_output(&output)?;
let creates_output = standard_output.is_none();
let mut pdf = open_pdf(&input, repair, password)?;
let options = WriterOptions {
qdf: true,
preserve_unreferenced_objects: preserve_unreferenced,
..WriterOptions::default()
};
write_with_pdf_writer(
&mut pdf,
&output,
&mut standard_output,
&options,
false,
None,
)?;
finish_operation_warnings(&pdf, creates_output)
}
fn run_qdf_fix(input: &std::path::Path, output: &std::path::Path) -> CliResult<()> {
let bytes = std::fs::read(input)?;
let fixed = fix_qdf(&bytes)?;
std::fs::write(output, fixed)?;
Ok(())
}
fn reject_same_json_output(input: &Path, output: &Path) -> CliResult<()> {
reject_same_file(
input,
output,
"input file and output file are the same; choose a different --json-output path",
"--json-output",
)
}
fn reject_same_job_output(input: &Path, output: &Path) -> CliResult<()> {
reject_same_file(
input,
output,
"input file and output file are the same; use a different output path",
"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(same_file_message.into());
}
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => {
return Err(format!(
"unable to inspect {inspect_label} file {}: {error}",
output.display()
)
.into())
}
}
Ok(())
}
fn json_input_open_error(input: &Path, error: std::io::Error) -> Box<dyn std::error::Error> {
let rendered = error.to_string();
let message = error
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered);
format!("open {}: {message}", input.display()).into()
}
fn qpdf_json_input_open_error(input: &Path, error: std::io::Error) -> Box<dyn std::error::Error> {
let rendered = error.to_string();
let message = if error.kind() == std::io::ErrorKind::NotFound {
"No such file or directory"
} else {
error
.raw_os_error()
.and_then(|code| rendered.strip_suffix(&format!(" (os error {code})")))
.unwrap_or(&rendered)
};
format!("open {}: {message}", input.display()).into()
}
fn open_verified_json_output(input: &File, output: &Path) -> CliResult<File> {
let mut output_file = OpenOptions::new()
.write(true)
.create(true)
.truncate(false)
.open(output)?;
let input_handle = same_file::Handle::from_file(input.try_clone()?)?;
let output_handle = same_file::Handle::from_file(output_file.try_clone()?)?;
if input_handle == output_handle {
return Err(
"input file and output file are the same; choose a different --json-output path".into(),
);
}
if output_file.metadata()?.file_type().is_file() {
output_file.set_len(0)?;
output_file.seek(SeekFrom::Start(0))?;
}
Ok(output_file)
}
fn run_dump_object(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
object_ref: &str,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let object_ref = ObjectRef::parse(object_ref)?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
finish_job_exit_status(job.dump_object(&mut pdf, object_ref)?)
}
#[derive(Debug, Clone, Copy)]
enum ShowObjectSelector {
Trailer,
Object(ObjectRef),
Null,
NoObject,
}
fn parse_show_object_selector(value: &str) -> CliResult<ShowObjectSelector> {
if value == "trailer" {
return Ok(ShowObjectSelector::Trailer);
}
let (number, generation) = value.split_once(',').unwrap_or((value, "0"));
let number = qpdf_selector_integer(number)?;
let generation = if generation.is_empty() {
0
} else {
qpdf_selector_integer(generation)?
};
if number <= 0 {
return Ok(ShowObjectSelector::NoObject);
}
if !(0..=i32::from(u16::MAX)).contains(&generation) {
return Ok(ShowObjectSelector::Null);
}
Ok(ShowObjectSelector::Object(ObjectRef::new(
u32::try_from(number).expect("positive i32 fits u32"),
u16::try_from(generation).expect("validated u16 generation"),
)))
}
fn qpdf_selector_integer(value: &str) -> CliResult<i32> {
let original = value;
let value = value.trim_start_matches(|character| {
matches!(
character,
' ' | '\n' | '\r' | '\t' | '\u{000c}' | '\u{000b}'
)
});
let digits_start = usize::from(matches!(value.as_bytes().first(), Some(b'+') | Some(b'-')));
let digits_end = digits_start
+ value[digits_start..]
.bytes()
.take_while(u8::is_ascii_digit)
.count();
if digits_end == digits_start {
return Ok(0);
}
let prefix = &value[..digits_end];
let parsed = prefix.parse::<i128>().map_err(|_| {
UsageError::new(format!(
"overflow/underflow converting {original} to 64-bit integer"
))
})?;
if !(i128::from(i64::MIN)..=i128::from(i64::MAX)).contains(&parsed) {
return Err(UsageError::new(format!(
"overflow/underflow converting {original} to 64-bit integer"
))
.into());
}
let parsed = parsed as i64;
Ok(i32::try_from(parsed).map_err(|_| {
UsageError::new(format!(
"integer out of range converting {parsed} from a 8-byte signed type to a 4-byte signed type"
))
})?)
}
fn run_show_object(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
selector: &str,
raw_stream_data: bool,
filtered_stream_data: bool,
) -> CliResult<()> {
let selector = parse_show_object_selector(selector)?;
let input = input.ok_or("missing input file")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
let object = match selector {
ShowObjectSelector::Trailer => pdf.trailer(),
ShowObjectSelector::Object(object_ref) => pdf.get_object_handle(object_ref),
ShowObjectSelector::NoObject => {
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
ShowObjectSelector::Null => {
logger_info(b"null\n")?;
return finish_job_exit_status(
job.inspect(&mut pdf, |_pdf| Ok::<(), flpdf::Error>(()))?,
);
}
};
finish_job_exit_status(job.show_object(
&mut pdf,
object,
raw_stream_data,
filtered_stream_data,
)?)
}
fn run_show_stream(cmd: ShowStreamCommand) -> CliResult<()> {
let object_ref = ObjectRef::parse(&cmd.object_ref)?;
let mut pdf = open_pdf(&cmd.input, cmd.repair, &cmd.password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
finish_job_exit_status(job.show_stream(&mut pdf, object_ref, cmd.raw_stream_data)?)
}
fn run_show_npages(input: Option<PathBuf>, repair: bool, password: &PasswordArgs) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
finish_job_exit_status(job.show_npages(&mut pdf)?)
}
fn run_show_pages(input: Option<PathBuf>, repair: bool, password: &PasswordArgs) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
finish_job_exit_status(job.show_pages(&mut pdf)?)
}
fn run_show_xref(input: Option<PathBuf>, repair: bool, password: &PasswordArgs) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
finish_job_exit_status(job.show_xref(&mut pdf)?)
}
fn run_show_linearization(input: Option<PathBuf>) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
match show_linearization_path_with_warnings(&input) {
Ok(result) => {
for warning in &result.warnings {
logger_warn(format!("WARNING: {}: {warning}\n", input.display()))?;
}
logger_info(result.dump)?;
if result.warnings.is_empty() {
Ok(())
} else {
finish_warning_state(true, false)
}
}
Err(ShowLinearizationError::Malformed { message }) => {
logger_error(format!("flpdf: malformed linearization data: {message}\n"))?;
std::process::exit(ExitCode::Errors.as_i32());
}
Err(ShowLinearizationError::Io(e)) => Err(e.to_string().into()),
}
}
enum EncryptionProbe {
Opened { encrypted: bool },
EncryptedAuthFailed,
}
fn probe_encryption(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<EncryptionProbe> {
let file = File::open(input)?;
let mut options = pdf_open_options(repair, password)?;
configure_document_logger(&mut options, input);
match Pdf::open_with_options(BufReader::new(file), 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(other.into()),
}
}
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_is_encrypted(input: &PathBuf, repair: bool, recovery: RecoveryArgs) -> CliResult<()> {
let password = PasswordArgs {
recovery,
..PasswordArgs::default()
};
let encrypted = match probe_encryption(input, repair, &password)? {
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) -> CliResult<()> {
match probe_encryption(input, repair, password)? {
EncryptionProbe::Opened { encrypted: false } => {
Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}))
}
EncryptionProbe::Opened { encrypted: true } => {
Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}))
}
EncryptionProbe::EncryptedAuthFailed => {
Ok(())
}
}
}
fn run_show_encryption_key(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<()> {
let pdf = open_pdf_for_inspection(input, repair, password)?;
match pdf.encryption_file_key() {
Some(key) => {
logger_info(format!("{}\n", hex_lower(&key)))?;
finish_operation_warnings(&pdf, false)
}
None if pdf.is_encrypted() => Err("encrypted PDF: incorrect password".into()),
None => Err("file is not encrypted; no encryption key to show".into()),
}
}
fn run_show_encryption(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
no_warn: bool,
) -> CliResult<()> {
let file = File::open(input).map_err(|error| error_with_file(input, error.into()))?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_suppress_warnings(no_warn);
let mut options = pdf_open_options(repair, password)?;
options.suppress_warnings = no_warn;
let mut pdf = job
.open_for_encryption_inspection(BufReader::new(file), input.display().to_string(), options)
.map_err(|error| error_with_file(input, actionable_password_error(error)))?;
finish_show_encryption(&mut job, &mut pdf, password.password_is_hex_key)
}
fn finish_show_encryption<R: Read + Seek>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
password_is_hex_key: bool,
) -> CliResult<()> {
job.show_encryption(pdf, password_is_hex_key)?;
job.record_document_warnings(pdf);
finish_job_exit_status(job.complete(false)?)
}
fn hex_lower(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 2);
for b in bytes {
out.push_str(&format!("{b:02x}"));
}
out
}
enum JobPdf {
File(Pdf<BufReader<File>>),
Json(Pdf<Cursor<Vec<u8>>>),
}
struct JsonJobRuntime<'a> {
input_identity: &'a File,
standard_output: &'a mut Option<PipelineWriter>,
job: &'a mut QPDFJob,
}
fn apply_json_update<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
update_from_json: Option<&Path>,
) -> CliResult<()> {
if let Some(path) = update_from_json {
let source = File::open(path).map_err(|error| qpdf_json_input_open_error(path, error))?;
pdf.update_from_json(source, path.display().to_string())
.map_err(|error| Box::new(error) as Box<dyn std::error::Error>)?;
}
Ok(())
}
fn apply_json_update_with_job<R: Read + Seek + 'static>(
job: &mut QPDFJob,
pdf: &mut Pdf<R>,
update_from_json: Option<&Path>,
) -> CliResult<()> {
if let Some(path) = update_from_json {
let source = File::open(path).map_err(|error| qpdf_json_input_open_error(path, error))?;
job.update_from_json(pdf, source, path.display().to_string())?;
}
Ok(())
}
fn open_job_pdf(
input: &Path,
repair: bool,
password: &PasswordArgs,
json_input: bool,
update_from_json: Option<&Path>,
check_inspection: bool,
) -> CliResult<JobPdf> {
if json_input {
Ok(JobPdf::Json(open_json_pdf(input, update_from_json)?))
} else {
let mut pdf = if check_inspection {
open_pdf_for_check_inspection(&input.to_path_buf(), repair, password)?
} else {
open_pdf(&input.to_path_buf(), repair, password)?
};
apply_json_update(&mut pdf, update_from_json)?;
Ok(JobPdf::File(pdf))
}
}
fn open_json_pdf(input: &Path, update_from_json: Option<&Path>) -> CliResult<Pdf<Cursor<Vec<u8>>>> {
let source = File::open(input).map_err(|error| qpdf_json_input_open_error(input, error))?;
let mut pdf = Pdf::create_from_json(source, input.display().to_string())
.map_err(|error| Box::new(error) as Box<dyn std::error::Error>)?;
apply_json_update(&mut pdf, update_from_json)?;
Ok(pdf)
}
fn open_pdf(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, false)
}
fn open_pdf_from_file(
input: &Path,
file: File,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_file_impl(input, file, repair, password, false, false)
}
fn open_pdf_for_inspection(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
let file = File::open(input).map_err(|error| error_with_file(input, error.into()))?;
open_pdf_file_impl(input, file, repair, password, false, true)
}
fn open_pdf_for_check_inspection(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, true)
}
fn open_pdf_impl(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
suppress_warnings: bool,
) -> CliResult<Pdf<BufReader<File>>> {
let file = File::open(input).map_err(|error| 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());
let pdf = if encryption_inspection {
job.open_for_encryption_inspection(
BufReader::new(file),
input.display().to_string(),
options,
)
} else {
job.open(BufReader::new(file), input.display().to_string(), 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 {
password.as_bytes().to_vec()
} else if let Some(path) = &password.password_file {
let mut bytes = std::fs::read(path)?;
if bytes.ends_with(b"\r\n") {
bytes.truncate(bytes.len() - 2);
} else if bytes.ends_with(b"\n") {
bytes.truncate(bytes.len() - 1);
}
bytes
} else {
Vec::new()
};
Ok(pdf_open_options_with_password_bytes(
repair,
password,
password_bytes,
))
}
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,
..PdfOpenOptions::default()
}
}
fn cli_logger() -> QPDFLogger {
static LOGGER: OnceLock<QPDFLogger> = OnceLock::new();
LOGGER.get_or_init(QPDFLogger::create).clone()
}
fn standard_save_writer() -> CliResult<PipelineWriter> {
standard_save_writer_for(&cli_logger())
}
fn standard_save_writer_for(logger: &QPDFLogger) -> CliResult<PipelineWriter> {
logger.save_to_standard_output(true)?;
Ok(PipelineWriter {
pipeline: logger.get_save()?,
})
}
fn prepare_pdf_standard_output(output: &Path) -> CliResult<Option<PipelineWriter>> {
if output.as_os_str() == "-" {
Ok(Some(standard_save_writer()?))
} else {
Ok(None)
}
}
fn prepare_page_operation_standard_output(
output: &Path,
page_ops: &PageOpArgs,
) -> CliResult<Option<PipelineWriter>> {
if output.as_os_str() == "-" && page_ops.split_pages.is_some() {
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 logger_error(data: impl AsRef<[u8]>) -> CliResult<()> {
cli_logger().error(data)?;
Ok(())
}
fn emit_logger_error(data: impl AsRef<[u8]>) {
if let Err(error) = cli_logger().error(data) {
eprintln!("flpdf: unable to write diagnostic: {error}"); }
}
fn configure_document_logger(options: &mut PdfOpenOptions, input: &Path) {
options.logger = Some(cli_logger());
options.description = input.display().to_string();
}
fn progname() -> String {
std::env::var("FLPDF_PROGNAME")
.ok()
.filter(|name| !name.is_empty())
.unwrap_or_else(|| "flpdf".to_string())
}
fn diagnostic_location(input: &Path, offset: Option<u64>) -> String {
match offset {
Some(offset) => format!("{} (offset {offset})", input.display()),
None => input.display().to_string(),
}
}
fn finish_operation_warnings<R: Read + Seek>(pdf: &Pdf<R>, creates_output: bool) -> CliResult<()> {
finish_operation_warnings_with_prior(pdf, creates_output, false)
}
fn finish_operation_warnings_with_prior<R: Read + Seek>(
pdf: &Pdf<R>,
creates_output: bool,
prior_warnings: bool,
) -> CliResult<()> {
finish_warning_state(
prior_warnings || !pdf.repair_diagnostics().entries().is_empty(),
creates_output,
)
}
fn finish_job_exit_status(status: JobExitCode) -> CliResult<()> {
match status {
JobExitCode::Success => Ok(()),
JobExitCode::Error => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
JobExitCode::Warning => Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
})),
}
}
fn finish_check_job(result: std::result::Result<JobExitCode, CheckError>) -> CliResult<()> {
match result {
Ok(status) => finish_job_exit_status(status),
Err(CheckError::ErrorsDetected) => Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
})),
Err(CheckError::Operation(error)) => Err(Box::new(error)),
}
}
fn finish_warning_state(has_warnings: bool, creates_output: bool) -> CliResult<()> {
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
if has_warnings {
job.record_warnings();
}
match job.complete(creates_output)? {
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 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 finish_rewrite_warnings<R: Read + Seek>(
input: &Path,
pdf: &Pdf<R>,
normalization_warnings: &[ContentNormalizationWarning],
creates_output: bool,
) -> CliResult<()> {
let has_repair_warnings = !pdf.repair_diagnostics().entries().is_empty();
for &warning in normalization_warnings {
emit_content_normalization_warnings(input, warning)?;
}
if normalization_warnings.is_empty() && !has_repair_warnings {
return Ok(());
}
finish_warning_state(true, creates_output)
}
fn error_with_file(input: &Path, error: Box<dyn std::error::Error>) -> Box<dyn std::error::Error> {
format!("{}: {error}", input.display()).into()
}
fn actionable_password_error(error: flpdf::Error) -> Box<dyn std::error::Error> {
if is_bad_password_error(&error) {
return "encrypted PDF: incorrect password; retry with --password or --password-file"
.into();
}
error.into()
}
fn parse_pdf_date_arg(s: &str) -> CliResult<Vec<u8>> {
let s = s
.strip_prefix("D:")
.ok_or_else(|| format!("invalid PDF date {s:?}: must start with D:"))?;
if s.len() < 14 || !s.as_bytes()[..14].iter().all(u8::is_ascii_digit) {
return Err(format!(
"invalid PDF date D:{s:?}: need at least 14 ASCII digits (YYYYMMDDHHmmSS)"
)
.into());
}
let suffix = &s[14..];
let valid_suffix = match suffix.as_bytes() {
b"" | b"Z" => true,
[sign, hour_tens, hour_ones, b'\'', minute_tens, minute_ones, b'\''] => {
matches!(sign, b'+' | b'-')
&& hour_tens.is_ascii_digit()
&& hour_ones.is_ascii_digit()
&& minute_tens.is_ascii_digit()
&& minute_ones.is_ascii_digit()
}
_ => false,
};
if !valid_suffix {
return Err(format!("invalid PDF date D:{s:?}: timezone must be Z or [+|-]HH'MM'").into());
}
Ok(format!("D:{s}").into_bytes())
}
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(tokens: Vec<String>) -> CliResult<AddAttachmentArgs> {
let mut iter = tokens.into_iter();
let file: PathBuf = iter
.next()
.ok_or("--add-attachment: missing FILE argument")?
.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 {
if let Some(v) = token.strip_prefix("--key=") {
key = Some(v.as_bytes().to_vec());
} else if let Some(v) = token.strip_prefix("--filename=") {
filename = Some(v.as_bytes().to_vec());
} else if let Some(v) = token.strip_prefix("--mimetype=") {
if !v.contains('/') {
return Err("mime type should be specified as type/subtype".into());
}
mimetype = Some(v.as_bytes().to_vec());
} else if let Some(v) = token.strip_prefix("--description=") {
description = Some(v.as_bytes().to_vec());
} else if let Some(v) = token.strip_prefix("--creationdate=") {
creation_date = Some(parse_pdf_date_arg(v)?);
} else if let Some(v) = token.strip_prefix("--moddate=") {
mod_date = Some(parse_pdf_date_arg(v)?);
} else if token == "--replace" {
replace = true;
} else {
return Err(format!(
"--add-attachment: unknown sub-flag or unexpected token {token:?}"
)
.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(tokens: Vec<String>) -> CliResult<CopyAttachmentsArgs> {
let mut iter = tokens.into_iter();
let file: PathBuf = iter
.next()
.ok_or("--copy-attachments-from: missing FILE argument")?
.into();
let mut password: Vec<u8> = Vec::new();
let mut prefix: Option<Vec<u8>> = None;
for token in iter {
if let Some(v) = token.strip_prefix("--password=") {
password = v.as_bytes().to_vec();
} else if let Some(v) = token.strip_prefix("--prefix=") {
prefix = Some(v.as_bytes().to_vec());
} else {
return Err(format!(
"--copy-attachments-from: unknown sub-flag or unexpected token {token:?}"
)
.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(|n| n.to_string_lossy().into_owned().into_bytes())
}
#[allow(clippy::too_many_arguments)]
fn run_add_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
segments: Vec<Vec<String>>,
deterministic_id: bool,
static_id: bool,
preserve_unreferenced: bool,
verbose: bool,
version_options: &CliVersionOptions,
) -> CliResult<()> {
let input = input.ok_or("--add-attachment: missing input PDF")?;
let output = output.ok_or("--add-attachment: missing output PDF")?;
let attachment_options = segments
.into_iter()
.map(|tokens| {
let args = parse_add_attachment_segment(tokens)?;
let basename = path_basename(&args.file)?;
let key = args.key.unwrap_or_else(|| basename.clone());
let filename = args.filename.unwrap_or_else(|| basename.clone());
Ok(AttachmentAddOptions {
path: args.file,
key,
filename,
mimetype: args.mimetype,
description: args.description,
creation_date: args.creation_date,
modification_date: args.mod_date,
replace: args.replace,
verbose,
})
})
.collect::<CliResult<Vec<_>>>()?;
let file = File::open(&input).map_err(|error| 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());
let mut pdf = job
.open(BufReader::new(file), input.display().to_string(), options)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
let mut standard_output = prepare_pdf_standard_output(&output)?;
job.add_attachments(&mut pdf, &attachment_options)?;
let mut options = WriterOptions {
deterministic_id,
static_id,
preserve_unreferenced_objects: preserve_unreferenced,
..WriterOptions::default()
};
apply_cli_version_options(&mut options, version_options);
write_with_pdf_writer(
&mut pdf,
&output,
&mut standard_output,
&options,
false,
None,
)?;
if verbose && output.as_os_str() != "-" {
job.logger()
.info(format!("{}: wrote file {}\n", progname(), output.display()))?;
}
job.record_document_warnings(&pdf);
finish_job_exit_status(job.complete(true)?)
}
#[allow(clippy::too_many_arguments)]
fn run_remove_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
key: &str,
deterministic_id: bool,
static_id: bool,
preserve_unreferenced: bool,
version_options: &CliVersionOptions,
) -> CliResult<()> {
let input = input.ok_or("--remove-attachment: missing input PDF")?;
let output = output.ok_or("--remove-attachment: missing output PDF")?;
let mut pdf = open_pdf(&input, repair, password)?;
let found = pdf.embedded_files().remove_embedded_file(key.as_bytes())?;
if !found {
return Err(format!("--remove-attachment: key {:?} not found in document", key).into());
}
let mut options = WriterOptions {
deterministic_id,
static_id,
preserve_unreferenced_objects: preserve_unreferenced,
..WriterOptions::default()
};
apply_cli_version_options(&mut options, version_options);
let mut standard_output = None;
write_with_pdf_writer(
&mut pdf,
&output,
&mut standard_output,
&options,
false,
None,
)?;
finish_operation_warnings(&pdf, true)
}
fn run_list_attachments(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
verbose: bool,
) -> CliResult<()> {
let input = input.ok_or("--list-attachments: missing input PDF")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_input_name(input.display().to_string());
let status = job.list_attachments(&mut pdf, verbose)?;
finish_job_exit_status(status)
}
fn run_show_attachment(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
key: &str,
) -> CliResult<()> {
let input = input.ok_or("--show-attachment: missing input PDF")?;
let mut pdf = open_pdf(&input, repair, password)?;
let mut job = QPDFJob::new();
job.set_logger(cli_logger());
job.set_message_prefix(progname());
job.set_input_name(input.display().to_string());
let status = job
.show_attachment(&mut pdf, key.as_bytes())
.map_err(|error| {
format!(
"--show-attachment: key {:?} not found or unreadable: {error}",
key
)
})?;
finish_job_exit_status(status)
}
#[allow(clippy::too_many_arguments)]
fn run_copy_attachments_from(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
tokens: Vec<String>,
deterministic_id: bool,
static_id: bool,
preserve_unreferenced: bool,
verbose: bool,
version_options: &CliVersionOptions,
) -> CliResult<()> {
let input = input.ok_or("--copy-attachments-from: missing input PDF")?;
let output = output.ok_or("--copy-attachments-from: missing output PDF")?;
let args = parse_copy_attachments_segment(tokens)?;
let file = File::open(&input).map_err(|error| 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());
let mut pdf = job
.open(BufReader::new(file), input.display().to_string(), options)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
let mut standard_output = prepare_pdf_standard_output(&output)?;
let mut source_password = password.clone();
source_password.password = None;
source_password.password_file = None;
let mut src_options =
pdf_open_options_with_password_bytes(repair, &source_password, args.password.clone());
configure_document_logger(&mut src_options, &args.file);
let src_file =
File::open(&args.file).map_err(|error| error_with_file(&args.file, error.into()))?;
let mut src = Pdf::open_with_options(BufReader::new(src_file), src_options)
.map_err(|error| error_with_file(&args.file, actionable_password_error(error)))?;
src.root_handle()
.map_err(|error| error_with_file(&args.file, actionable_password_error(error)))?;
job.copy_attachments(
&mut pdf,
&mut src,
&AttachmentCopyOptions {
path: args.file,
prefix: args.prefix.unwrap_or_default(),
verbose,
},
)?;
let mut writer_options = WriterOptions {
deterministic_id,
static_id,
preserve_unreferenced_objects: preserve_unreferenced,
..WriterOptions::default()
};
apply_cli_version_options(&mut writer_options, version_options);
write_with_pdf_writer(
&mut pdf,
&output,
&mut standard_output,
&writer_options,
false,
None,
)?;
if verbose && output.as_os_str() != "-" {
job.logger()
.info(format!("{}: wrote file {}\n", progname(), output.display()))?;
}
job.record_document_warnings(&pdf);
finish_job_exit_status(job.complete(true)?)
}
#[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(())
}
}
fn strs(v: &[&str]) -> Vec<String> {
v.iter().map(|s| s.to_string()).collect()
}
#[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, 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 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 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"
);
}
#[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(), 5);
assert_eq!(
chunks.concat(),
b"page 1: 3 0 R\n media-box: [ 0 0 612 792 ]\n resources: << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >>\n contents: 7 0 R\n rotate: 0\n"
);
}
#[test]
fn probe_encryption_classifies_bad_password_after_repair_warnings() {
let mut input =
include_bytes!("../../../tests/fixtures/compat/encrypted-r4-three-page.pdf").to_vec();
let xref = input
.windows(4)
.position(|window| window == b"xref")
.expect("encrypted fixture should contain an xref keyword");
input[xref + 2] = b'X';
let directory = tempfile::tempdir().expect("temporary directory");
let path = directory.path().join("damaged-encrypted.pdf");
std::fs::write(&path, input).expect("write damaged encrypted fixture");
let outcome = probe_encryption(
&path,
true,
&PasswordArgs {
password: Some("wrong".to_owned()),
..PasswordArgs::default()
},
);
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()) else {
panic!("a missing /Root must be a hard error");
};
assert!(
error.to_string().contains(&path.display().to_string()),
"error should carry the input path like other open boundaries: {error}"
);
assert!(error
.to_string()
.contains("unable to find /Root dictionary"));
}
#[cfg(unix)]
#[test]
fn verified_json_output_rejects_hardlink_swapped_after_path_check() {
let temp = tempfile::tempdir().unwrap();
let input_path = temp.path().join("input.pdf");
let output_path = temp.path().join("output.json");
let original = b"input bytes must survive".to_vec();
std::fs::write(&input_path, &original).unwrap();
std::fs::write(&output_path, b"distinct output").unwrap();
reject_same_json_output(&input_path, &output_path).unwrap();
std::fs::remove_file(&output_path).unwrap();
std::fs::hard_link(&input_path, &output_path).unwrap();
let input_file = File::open(&input_path).unwrap();
let error = open_verified_json_output(&input_file, &output_path).unwrap_err();
assert!(error
.to_string()
.contains("input file and output file are the same"));
assert_eq!(std::fs::read(&input_path).unwrap(), original);
}
#[test]
fn overlay_bare_file() {
let spec = parse_overlay_segment(OverlayKind::Overlay, &strs(&["over.pdf"])).unwrap();
assert_eq!(
spec,
OverlaySpec {
kind: OverlayKind::Overlay,
file: "over.pdf".into(),
password: None,
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, &[])
.unwrap_err()
.to_string();
assert!(err.contains("--overlay"), "got: {err}");
assert!(err.contains("no source file"), "got: {err}");
}
#[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!(err.contains("--overlay"), "got: {err}");
assert!(err.contains("no source file"), "got: {err}");
}
#[test]
fn overlay_duplicate_file_bare_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["a.pdf", "b.pdf"]))
.unwrap_err()
.to_string();
assert!(err.contains("duplicate file"), "got: {err}");
}
#[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!(err.contains("duplicate file"), "got: {err}");
}
#[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!(err.contains("duplicate file"), "got: {err}");
}
#[test]
fn overlay_duplicate_to_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--to=1", "--to=2"]),
)
.unwrap_err()
.to_string();
assert!(err.contains("duplicate --to="), "got: {err}");
}
#[test]
fn overlay_duplicate_from_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--from=1", "--from=2"]),
)
.unwrap_err()
.to_string();
assert!(err.contains("duplicate --from="), "got: {err}");
}
#[test]
fn overlay_duplicate_repeat_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--repeat=1", "--repeat=z"]),
)
.unwrap_err()
.to_string();
assert!(err.contains("duplicate --repeat="), "got: {err}");
}
#[test]
fn overlay_unknown_flag_error() {
let err = parse_overlay_segment(OverlayKind::Overlay, &strs(&["src.pdf", "--bogus=x"]))
.unwrap_err()
.to_string();
assert!(err.contains("--overlay"), "got: {err}");
assert!(err.contains("unsupported token"), "got: {err}");
}
#[test]
fn underlay_unknown_flag_error_prefix() {
let err = parse_overlay_segment(OverlayKind::Underlay, &strs(&["src.pdf", "--unknown"]))
.unwrap_err()
.to_string();
assert!(err.contains("--underlay"), "got: {err}");
}
#[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_duplicate_to_before_file_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["--to=1", "src.pdf", "--to=2"]),
)
.unwrap_err()
.to_string();
assert!(err.contains("duplicate --to="), "got: {err}");
}
#[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_duplicate_password_error() {
let err = parse_overlay_segment(
OverlayKind::Overlay,
&strs(&["src.pdf", "--password=a", "--password=b"]),
)
.unwrap_err()
.to_string();
assert!(err.contains("duplicate --password="), "got: {err}");
}
#[test]
fn single_dash_long_becomes_double_dash() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-qdf", "-static-id", "in.pdf"]));
assert_eq!(out, strs(&["flpdf", "--qdf", "--static-id", "in.pdf"]));
}
#[test]
fn single_dash_long_with_equals_becomes_double_dash() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-object-streams=generate"]));
assert_eq!(out, strs(&["flpdf", "--object-streams=generate"]));
}
#[test]
fn single_dash_bare_equals_value_is_discarded_after_rewriting() {
let out =
normalize_qpdf_bare_equals(rewrite_qpdf_single_dash(strs(&["flpdf", "-qdf=ignored"])));
assert_eq!(out, strs(&["flpdf", "--qdf"]));
}
#[test]
fn qpdf_bare_boolean_equals_values_are_discarded() {
let out = normalize_qpdf_bare_equals(strs(&[
"flpdf",
"--check=ignored",
"--qdf=ignored",
"--static-id=ignored",
"--verbose=ignored",
"--preserve-unreferenced=ignored",
]));
assert_eq!(
out,
strs(&[
"flpdf",
"--check",
"--qdf",
"--static-id",
"--verbose",
"--preserve-unreferenced",
])
);
}
#[test]
fn qpdf_bare_normalization_preserves_value_options() {
let args = strs(&[
"flpdf",
"--json=2",
"--object-streams=generate",
"--normalize-content=y",
"--newline-before-endstream=never",
]);
assert_eq!(normalize_qpdf_bare_equals(args.clone()), args);
}
#[test]
fn newline_before_endstream_discards_an_unrecognized_equals_value() {
let args = strs(&["flpdf", "--newline-before-endstream=garbage"]);
assert_eq!(
normalize_qpdf_bare_equals(args),
strs(&["flpdf", "--newline-before-endstream"])
);
}
#[test]
fn qpdf_bare_normalization_preserves_value_terminated_segments() {
let args = strs(&[
"flpdf",
"--encrypt",
"user",
"owner",
"256",
"--qdf=an-encrypt-suboption-value",
"--",
"--check=after-segment",
]);
assert_eq!(
normalize_qpdf_bare_equals(args),
strs(&[
"flpdf",
"--encrypt",
"user",
"owner",
"256",
"--qdf=an-encrypt-suboption-value",
"--",
"--check",
])
);
}
#[test]
fn double_dash_long_is_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "--qdf", "--static-id"]));
assert_eq!(out, strs(&["flpdf", "--qdf", "--static-id"]));
}
#[test]
fn known_short_flags_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-o", "path", "-h"]));
assert_eq!(out, strs(&["flpdf", "-o", "path", "-h"]));
}
#[test]
fn stdin_sentinel_and_options_terminator_untouched() {
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_preserves_remaining_tokens() {
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, strs(&["flpdf"]));
assert_eq!(parsed.named_segments[0].option, "overlay");
assert_eq!(
parsed.named_segments[0].tokens,
strs(&["stamp.pdf", "--to=1"])
);
}
#[test]
fn each_segment_kind_recognizes_its_sub_options() {
let parsed = arg_parser::ArgParser::from_command(Cli::command())
.parse(strs(&[
"flpdf",
"--encrypt",
"-use-aes",
"--",
"--pages",
"-range=1",
"--",
"--add-attachment",
"-replace",
"--",
"--copy-attachments-from",
"-prefix=copy-",
"--",
]))
.unwrap();
assert_eq!(parsed.named_segments[0].tokens, ["--use-aes"]);
assert_eq!(parsed.named_segments[1].tokens, ["--range=1"]);
assert_eq!(parsed.named_segments[2].tokens, ["--replace"]);
assert_eq!(parsed.named_segments[3].tokens, ["--prefix=copy-"]);
}
#[test]
fn collect_clap_long_options_includes_aliases() {
let command = clap::Command::new("test")
.arg(clap::Arg::new("mode").long("mode").alias("legacy-mode"));
let parsed = arg_parser::ArgParser::from_command(command)
.parse(strs(&["test", "-legacy-mode"]))
.unwrap();
assert_eq!(parsed.residual_args, 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"]), true)
.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"]), true).unwrap();
assert_eq!(params.user_password, b"-");
assert_eq!(params.owner_password, b"-");
}
#[test]
fn negative_number_positional_untouched() {
let out = rewrite_qpdf_single_dash(strs(&["flpdf", "-1", "-0.5"]));
assert_eq!(out, strs(&["flpdf", "-1", "-0.5"]));
}
#[test]
fn extract_no_overlay_leaves_args_untouched() {
let argv = strs(&["flpdf", "rewrite", "--static-id", "in.pdf", "out.pdf"]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert_eq!(residual, argv);
assert!(specs.is_empty());
}
#[test]
fn extract_single_attachment_group_leaves_a_clap_dispatch_marker() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(
residual,
strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
])
);
assert_eq!(groups, vec![strs(&["one.txt", "--key=one"])]);
}
#[test]
fn extract_repeated_attachment_groups_preserves_order_and_boundaries() {
let argv = strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"--add-attachment",
"two.txt",
"--key=two",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv).unwrap();
assert_eq!(
residual,
strs(&[
"flpdf",
"in.pdf",
"--add-attachment",
"one.txt",
"--key=one",
"--",
"out.pdf",
])
);
assert_eq!(
groups,
vec![
strs(&["one.txt", "--key=one"]),
strs(&["two.txt", "--key=two"]),
]
);
}
#[test]
fn extract_attachment_groups_leaves_opaque_sibling_values_untouched() {
let argv = strs(&[
"flpdf",
"--pages",
"--add-attachment",
"one.txt",
"--",
"out.pdf",
]);
let (residual, groups) = extract_attachment_groups(argv.clone()).unwrap();
assert_eq!(residual, argv);
assert!(groups.is_empty());
}
#[test]
fn extract_attachment_groups_rejects_an_unterminated_group() {
let error = extract_attachment_groups(strs(&["flpdf", "--add-attachment", "one.txt"]))
.expect_err("an attachment group must have a terminator");
assert_eq!(error.to_string(), "--add-attachment: missing -- terminator");
}
#[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("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!(err.contains("terminated by a `--`"), "got: {err}");
}
#[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!(err.contains("--overlay"), "got: {err}");
assert!(err.contains("no source file"), "got: {err}");
}
#[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!(err.contains("--underlay"), "got: {err}");
assert!(err.contains("no source file"), "got: {err}");
}
#[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("--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!(error.contains("--encrypt"), "got: {error}");
assert!(error.contains("terminated"), "got: {error}");
}
#[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"),
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"),
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,
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(),
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(),
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(),
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"),
password: Some("user-v2".into()),
from: None,
to: None,
repeat: None,
}];
let built = build_overlay_specs(&cli_specs, false, &PasswordArgs::default()).unwrap();
assert_eq!(built.len(), 1);
assert_eq!(built[0].kind, flpdf::OverlayKind::Overlay);
}
#[test]
fn show_object_selector_defaults_generation_like_qpdf() {
assert!(matches!(
parse_show_object_selector("1"),
Ok(ShowObjectSelector::Object(ObjectRef {
number: 1,
generation: 0,
}))
));
assert!(matches!(
parse_show_object_selector("1,"),
Ok(ShowObjectSelector::Object(ObjectRef {
number: 1,
generation: 0,
}))
));
}
#[test]
fn show_object_selector_integer_errors_match_qpdf() {
let overflow = qpdf_selector_integer("9223372036854775808").expect_err("i64 overflow");
assert_eq!(
overflow.to_string(),
"overflow/underflow converting 9223372036854775808 to 64-bit integer"
);
assert!(
overflow.downcast_ref::<UsageError>().is_some(),
"qpdf reports this as a QPDFUsage-class error (thrown from argv parsing, \
before the input file is opened), so it must route through \
flpdf-cli's usage_exit path rather than the generic error path"
);
let huge = qpdf_selector_integer("99999999999999999999999999999999999999999999999999")
.expect_err("digit run exceeding i128");
assert_eq!(
huge.to_string(),
"overflow/underflow converting 99999999999999999999999999999999999999999999999999 to 64-bit integer"
);
assert!(huge.downcast_ref::<UsageError>().is_some());
let narrowing = qpdf_selector_integer("2147483648").expect_err("i32 narrowing overflow");
assert_eq!(
narrowing.to_string(),
"integer out of range converting 2147483648 from a 8-byte signed type to a 4-byte signed type"
);
assert!(narrowing.downcast_ref::<UsageError>().is_some());
}
#[test]
fn show_object_selector_parses_before_checking_for_an_input_file() {
let error = run_show_object(
None,
false,
&PasswordArgs::default(),
"2147483648",
false,
false,
)
.expect_err("overflow selector with no input file");
assert!(
error.downcast_ref::<UsageError>().is_some(),
"got {error} instead of a UsageError -- the missing-input-file check must not \
run before selector parsing"
);
}
}