#![forbid(unsafe_code)]
use clap::{ArgGroup, Args as ClapArgs, CommandFactory, Parser, Subcommand, ValueEnum};
use flpdf::disable_digital_signatures;
use flpdf::filespec_helper::ascii_filename_fallback;
use flpdf::{
acroform_field_prune::prune_acroform_after_subset,
objr_obj_annot_p::drop_objr_obj_annot_dangling_p, outline_dest_remap::remap_outline_and_dests,
page_collate::collate, page_combine::CombinedPlan, page_rotate::apply_rotate_to_pages,
page_split::split_pages, page_tree_rebuild::rebuild_page_tree,
struct_tree_pg::drop_struct_elem_dangling_pg, subset_prune::prune_after_subset,
thread_bead_p::drop_thread_bead_dangling_p, InputSpec, PageRange, RotateSpec,
};
use flpdf::{
check_reader_with_options_and_limits, enumerate_document_annotations, filters,
flatten_annotations, flatten_rotation_on_pages, fonts, generate_button_field_appearance,
generate_choice_field_appearance, generate_text_field_appearance,
json_inspect::{
build_qpdf_json_v2_selected_objects_with_options, format_json_side_file_path,
qpdf_raw_stream_payload, DecodeLevel, JsonKey, JsonObjectSelector,
StreamDataMode as JsonStreamDataMode,
},
linearization::{
check_linearization_path, show_linearization_path, write_linearized,
LinearizationCheckError, LinearizationPlan, RenumberMap, ShowLinearizationError,
},
normalize_content_stream, pages,
pages::coalesce_page_contents,
parse_pdf_version, write_pdf_with_options, AnnotationObjectHelper, CompressStreams,
CopyEncryptionSource, Dictionary, EncryptMethod, EncryptParams, FlattenMode,
FormFieldObjectHelper, NewlineBeforeEndstream, Object, ObjectKeyAlg, ObjectRef,
ObjectStreamMode, PasswordMode, Pdf, PdfOpenOptions, PermissionsConfig, PrintPermission,
RemoveUnreferencedResources, Severity, Stream, StreamDataMode, WriteOptions,
};
use flpdf::{
copy_attachments_from, extract_attachment, fix_qdf, format_attachment_list,
insert_embedded_file, list_attachment_info, remove_attachment, FileParamDates, FileSpecBuilder,
};
use std::collections::HashSet;
use std::fs::File;
use std::io::{BufReader, Read, Seek, Write};
use std::path::{Path, PathBuf};
type CliResult<T> = Result<T, Box<dyn std::error::Error>>;
#[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)]
check: bool,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(long = "decode-memory-limit", value_name = "BYTES", requires = "check")]
decode_memory_limit: Option<usize>,
#[arg(long)]
dump_object: Option<String>,
#[arg(long)]
show_info: bool,
#[arg(long)]
show_catalog: bool,
#[arg(long)]
show_metadata: bool,
#[arg(long)]
show_outline: bool,
#[arg(long)]
show_fonts: bool,
#[arg(long)]
show_npages: bool,
#[arg(long)]
show_pages: bool,
#[arg(long)]
show_linearization: bool,
#[arg(long, num_args = 0..=1, default_missing_value = "2",
require_equals = true,
value_name = "VERSION", value_parser = ["2"],
conflicts_with_all = [
"check", "linearize", "static_id", "deterministic_id", "static_aes_iv",
"dump_object",
"show_info", "show_catalog", "show_metadata", "show_outline",
"show_fonts", "show_npages", "show_pages", "show_linearization", "output",
"compress_streams", "linearize_pass1", "remove_restrictions",
"decrypt", "encrypt", "copy_encryption_from",
"add_attachment", "remove_attachment", "list_attachments",
"show_attachment", "copy_attachments_from",
"no_original_object_ids", "qdf", "coalesce_contents",
],
help = "Generate JSON v2 output (qpdf --json compatible)")]
json: Option<String>,
#[arg(
long = "json-output",
value_name = "PATH",
requires = "json",
help = "Write JSON to PATH instead of stdout"
)]
json_output: Option<PathBuf>,
#[arg(
long = "json-key",
value_name = "KEY",
requires = "json",
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",
requires = "json",
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",
requires = "json",
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",
requires = "json",
help = "Prefix for side files with --json-stream-data=file"
)]
json_stream_prefix: Option<String>,
#[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",
conflicts_with_all = [
"check", "dump_object", "show_info", "show_catalog",
"show_metadata", "show_outline", "show_fonts",
"show_npages", "show_pages", "show_linearization",
])]
remove_restrictions: bool,
#[arg(long = "decrypt",
conflicts_with_all = [
"check", "dump_object", "show_info", "show_catalog",
"show_metadata", "show_outline", "show_fonts",
"show_npages", "show_pages", "show_linearization",
])]
decrypt: bool,
#[arg(long = "compress-streams")]
compress_streams: Option<String>,
#[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 = "coalesce-contents",
conflicts_with_all = [
"check", "dump_object", "show_info", "show_catalog",
"show_metadata", "show_outline", "show_fonts",
"show_npages", "show_pages", "show_linearization",
"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",
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",
value_name = "KEY",
help = "Extract the embedded file with the given key to stdout or -o PATH \
(qpdf --show-attachment)"
)]
show_attachment: Option<String>,
#[arg(
short = 'o',
long = "show-attachment-to",
value_name = "PATH",
requires = "show_attachment",
help = "Write --show-attachment output to PATH instead of stdout"
)]
show_attachment_to: Option<PathBuf>,
#[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.
// --linearize / --remove-restrictions / --decrypt overlaps with
// --encrypt are rejected because they imply contradictory output
// forms; --check / --dump-object / --show-* are inspection paths
// that don't produce an output file at all.
conflicts_with_all = [
"check", "dump_object", "show_info", "show_catalog",
"show_metadata", "show_outline", "show_fonts",
"show_npages", "show_pages", "show_linearization",
"linearize", "remove_restrictions", "decrypt", "qdf",
"copy_encryption_from",
],
help = "Encrypt output (qpdf --encrypt compatible): \
USER-PW OWNER-PW KEY-LEN [sub-flags] -- ; \
walking skeleton supports 128 with --use-aes=y only"
)]
encrypt: Vec<String>,
#[arg(
long = "copy-encryption-from",
value_name = "FILE",
conflicts_with_all = [
"encrypt",
"check", "dump_object", "show_info", "show_catalog",
"show_metadata", "show_outline", "show_fonts",
"show_npages", "show_pages", "show_linearization",
"linearize", "remove_restrictions", "decrypt", "qdf",
],
help = "Copy /Encrypt from donor PDF (qpdf --copy-encryption-from); \
pair with --encryption-file-password"
)]
copy_encryption_from: Option<PathBuf>,
#[arg(
long = "encryption-file-password",
value_name = "PW",
requires = "copy_encryption_from",
help = "User password to open the donor PDF for --copy-encryption-from"
)]
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
grep qpdf output also work here. flpdf adds extra leading lines
(`V = `, `Length = `, `Filter = `, `EncryptMetadata = `, and per-named
`CF /<name> = <method>`) before the qpdf block.
Divergences from qpdf, by design (flpdf-9hc.3.17): flpdf does not recover
the cleartext user password, so qpdf's `User password = <value>` line is
omitted (a grep for it simply misses rather than getting wrong data).
`Supplied password is owner/user password` is printed from the
authenticated state. If FILE is not encrypted, prints qpdf's
`File is not encrypted` and exits 0. Requires a correct password to open
the document (same as the other inspection subcommands)."
)]
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,
}
#[derive(Debug, ClapArgs)]
struct CheckCommand {
input: PathBuf,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
#[arg(long = "decode-memory-limit", value_name = "BYTES")]
decode_memory_limit: Option<usize>,
}
#[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: bool,
#[arg(long, value_name = "PATH")]
out: Option<PathBuf>,
#[arg(long)]
repair: bool,
#[command(flatten)]
password: PasswordArgs,
}
#[derive(Debug, ClapArgs)]
struct PagesCommand {
input: PathBuf,
#[arg(long)]
count: 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,
}
#[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 = [
"linearize", "remove_restrictions", "decrypt", "qdf",
"copy_encryption_from",
]
)]
encrypt: Vec<String>,
#[arg(
long = "copy-encryption-from",
value_name = "FILE",
conflicts_with_all = [
"encrypt",
"linearize", "remove_restrictions", "decrypt", "qdf",
],
help = "Copy /Encrypt from donor PDF (qpdf --copy-encryption-from); \
pair with --encryption-file-password"
)]
copy_encryption_from: Option<PathBuf>,
#[arg(
long = "encryption-file-password",
value_name = "PW",
requires = "copy_encryption_from",
help = "User password to open the donor PDF for --copy-encryption-from"
)]
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 = "full-rewrite")]
full_rewrite: bool,
#[arg(long = "qdf")]
qdf: bool,
#[arg(long = "object-streams", value_enum, default_value_t = CliObjectStreamMode::Preserve)]
object_streams: CliObjectStreamMode,
#[arg(long = "compress-streams", value_enum, default_value_t = CliYesNo::Yes,
help = "Compress output streams with FlateDecode (qpdf default: y)")]
compress_streams: CliYesNo,
#[arg(long = "normalize-content", value_enum, default_value_t = CliYesNo::No,
help = "Normalize page content streams (qpdf default: n)")]
normalize_content: 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,
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,
}
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 From<CliFlattenMode> for FlattenMode {
fn from(v: CliFlattenMode) -> Self {
match v {
CliFlattenMode::All => FlattenMode::All,
CliFlattenMode::Screen => FlattenMode::Screen,
CliFlattenMode::Print => FlattenMode::Print,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum CliYesNo {
#[clap(name = "y")]
Yes,
#[clap(name = "n")]
No,
}
#[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, Default, ClapArgs)]
struct PasswordArgs {
#[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 on V<5 documents; this flag disables that recovery. flpdf performs a \
single authentication attempt with no encoding fallback, so there is no \
recovery to suppress: this flag is a DOCUMENTED NO-OP. It is parsed without \
error so scripts passing it do not break, and the contract is reserved so \
encoding fallback can be added later without changing the CLI surface."
)]
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 main() {
let rewritten_args = rewrite_qpdf_single_dash(std::env::args().collect());
let (residual_args, overlay_specs) = match extract_overlay_groups(rewritten_args) {
Ok(parsed) => parsed,
Err(error) => {
eprintln!("flpdf: {error}");
std::process::exit(2);
}
};
let args = Cli::parse_from(residual_args);
warn_if_static_id(&args);
if args.qdf && args.linearize {
eprintln!("flpdf: --qdf and --linearize cannot be used together");
std::process::exit(1);
}
if args.qdf && page_ops_active(&args.page_ops) {
eprintln!("flpdf: --qdf cannot be combined with --pages/--rotate/--split-pages");
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.dump_object.is_none()
&& !args.show_info
&& !args.show_catalog
&& !args.show_metadata
&& !args.show_outline
&& !args.show_fonts
&& !args.show_npages
&& !args.show_pages
&& !args.show_linearization
&& !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 result = if args.json.is_some() {
run_json(&args)
} else if let Some(command) = args.command {
run_command(command, &overlay_specs)
} else if let Some(object_ref) = args.dump_object.as_deref() {
run_dump_object(args.input, args.repair, &args.password, object_ref)
} else if args.show_info {
run_show_info(args.input, args.repair, &args.password)
} else if args.show_catalog {
run_show_catalog(args.input, args.repair, &args.password)
} else if args.show_metadata {
run_show_metadata(args.input, args.repair, &args.password)
} else if args.show_outline {
run_show_outline(args.input, args.repair, &args.password)
} else if args.show_fonts {
run_show_fonts(args.input, args.repair, &args.password)
} 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_linearization {
run_show_linearization(args.input)
} else if args.check {
run_check(
args.input,
args.repair,
&args.password,
filters::DecodeLimits {
max_output: args.decode_memory_limit,
},
)
} 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,
args.show_attachment_to,
)
} else if let Some(key) = args.remove_attachment {
run_remove_attachment(
args.input,
args.output,
args.repair,
&args.password,
&key,
args.deterministic_id,
)
} else if !args.add_attachment.is_empty() {
run_add_attachment(
args.input,
args.output,
args.repair,
&args.password,
args.add_attachment,
args.deterministic_id,
)
} 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,
)
} 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 = WriteOptions::default();
options.static_id = args.static_id;
options.deterministic_id = args.deterministic_id;
options.static_aes_iv = args.static_aes_iv;
options.no_original_object_ids = args.no_original_object_ids;
if let Some(ref cs) = args.compress_streams {
match cs.as_str() {
"y" => options.compress_streams = CompressStreams::Yes,
"n" => options.compress_streams = CompressStreams::No,
other => {
eprintln!("flpdf: --compress-streams must be y or n, got: {:?}", other);
std::process::exit(2);
}
}
}
let result = run_rewrite(
args.input,
args.output.clone(),
args.repair,
&args.password,
true,
args.remove_restrictions,
args.decrypt,
false, args.coalesce_contents,
CliRemoveUnreferencedResources::No, false, None, false, &overlay_specs,
args.verbose,
options,
);
if result.is_ok() {
if let (Some(pass1), Some(output)) =
(args.linearize_pass1.as_ref(), args.output.as_ref())
{
if let Err(error) = std::fs::copy(output, pass1) {
eprintln!("flpdf: failed to write --linearize-pass1 file: {error}");
std::process::exit(2);
}
}
}
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_from.is_some() {
eprintln!(
"flpdf: --copy-encryption-from is not applied in the \
--pages/--rotate/--split-pages/--collate pipeline; \
rerun without --copy-encryption-from or without the page operation"
);
std::process::exit(1);
}
let mut options = WriteOptions::default();
options.static_id = args.static_id;
options.deterministic_id = args.deterministic_id;
options.static_aes_iv = args.static_aes_iv;
options.no_original_object_ids = args.no_original_object_ids;
if let Some(ref cs) = args.compress_streams {
match cs.as_str() {
"y" => options.compress_streams = CompressStreams::Yes,
"n" => options.compress_streams = 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.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.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 = WriteOptions::default();
options.static_id = args.static_id;
options.deterministic_id = args.deterministic_id;
options.static_aes_iv = args.static_aes_iv;
options.no_original_object_ids = args.no_original_object_ids;
options.qdf = args.qdf;
if args.qdf {
options.full_rewrite = true;
}
if args.deterministic_id {
options.full_rewrite = true;
}
if let Some(ref cs) = args.compress_streams {
match cs.as_str() {
"y" => options.compress_streams = CompressStreams::Yes,
"n" => options.compress_streams = 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_from.as_deref(),
args.encryption_file_password.as_deref(),
args.password.allow_weak_crypto,
);
run_rewrite(
args.input,
args.output,
args.repair,
&args.password,
false,
args.remove_restrictions,
args.decrypt,
false, 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() {
eprintln!("{}: {}", progname(), exit_err.message);
}
std::process::exit(exit_err.code.as_i32());
}
eprintln!("{}: {error}", progname());
std::process::exit(2);
}
}
fn run_json(cli: &Cli) -> CliResult<()> {
const QPDF_JSON_KEY_NAMES: &[&str] = &[
"acroform",
"attachments",
"encrypt",
"objectinfo",
"objects",
"outlines",
"pagelabels",
"pages",
"qpdf",
];
let mut json_keys: Vec<JsonKey> = Vec::new();
for raw in &cli.json_key {
if matches!(raw.as_str(), "objects" | "objectinfo") {
eprintln!(
"flpdf: json keys \"objects\" and \"objectinfo\" are 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);
}
}
}
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_raw = cli.json_stream_data.as_deref().unwrap_or("none");
let prefix_default = || -> String {
cli.json_stream_prefix
.clone()
.or_else(|| {
cli.json_output
.as_ref()
.map(|p| p.to_string_lossy().into_owned())
})
.unwrap_or_else(|| "stream".to_string())
};
let stream_mode = match stream_data_raw {
"none" => JsonStreamDataMode::None,
"inline" => JsonStreamDataMode::Inline,
"file" => JsonStreamDataMode::File {
prefix: prefix_default(),
},
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")?;
let mut pdf = open_pdf(input, cli.repair, &cli.password)?;
let decode_level = DecodeLevel::Generalized;
let diagnostics_start = pdf.repair_diagnostics().entries().len();
let had_open_warnings = diagnostics_start > 0;
let v2 = match build_qpdf_json_v2_selected_objects_with_options(
&mut pdf,
decode_level,
&stream_mode,
&json_keys,
&json_objects,
) {
Ok(v2) => v2,
Err(error) => {
emit_warnings_since(input, &pdf, diagnostics_start);
return Err(Box::<dyn std::error::Error>::from(error.to_string()));
}
};
let json_write_result = (|| -> CliResult<()> {
if let Some(ref out_path) = cli.json_output {
let mut file = File::create(out_path)?;
flpdf::json::write(&v2, &mut file)?;
} else {
let stdout = std::io::stdout();
let mut locked = stdout.lock();
flpdf::json::write(&v2, &mut locked)?;
locked.flush()?;
}
Ok(())
})();
if let Err(error) = json_write_result {
emit_warnings_since(input, &pdf, diagnostics_start);
return Err(error);
}
let side_file_result = (|| -> CliResult<()> {
if let JsonStreamDataMode::File { ref prefix } = stream_mode {
let wanted_refs = collect_datafile_object_refs(&v2);
for oref in wanted_refs {
let Some(payload) = qpdf_raw_stream_payload(&mut pdf, oref, decode_level)? else {
continue; };
let side_path = format_json_side_file_path(prefix, oref.number);
std::fs::write(&side_path, payload)?;
}
}
Ok(())
})();
if let Err(error) = side_file_result {
emit_warnings_since(input, &pdf, diagnostics_start);
return Err(error);
}
if had_open_warnings || pdf.repair_diagnostics().entries().len() > diagnostics_start {
emit_warnings_since(input, &pdf, diagnostics_start);
eprintln!("{}: operation succeeded with warnings", progname());
return Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}));
}
Ok(())
}
fn collect_datafile_object_refs(v2: &flpdf::json::JsonValue) -> Vec<ObjectRef> {
use flpdf::json::JsonValue;
let mut out = Vec::new();
let JsonValue::Object(top) = v2 else {
return out;
};
let Some((_, qpdf_value)) = top.iter().find(|(k, _)| k == "qpdf") else {
return out;
};
let JsonValue::Array(qpdf_arr) = qpdf_value else {
return out;
};
let Some(JsonValue::Object(objects_map)) = qpdf_arr.get(1) else {
return out;
};
for (key, entry) in objects_map {
let Some(rest) = key.strip_prefix("obj:") else {
continue;
};
let rest = rest.trim_end_matches(" R");
let mut parts = rest.split_whitespace();
let Some(num) = parts.next().and_then(|s| s.parse::<u32>().ok()) else {
continue;
};
let Some(gen) = parts.next().and_then(|s| s.parse::<u16>().ok()) else {
continue;
};
let JsonValue::Object(entry_pairs) = entry else {
continue;
};
let Some((_, stream_val)) = entry_pairs.iter().find(|(k, _)| k == "stream") else {
continue;
};
let JsonValue::Object(stream_pairs) = stream_val else {
continue;
};
if stream_pairs.iter().any(|(k, _)| k == "datafile") {
out.push(ObjectRef::new(num, gen));
}
}
out
}
fn run_command(command: Commands, overlay_specs: &[OverlaySpec]) -> CliResult<()> {
match command {
Commands::Check(cmd) => run_check(
Some(cmd.input),
cmd.repair,
&cmd.password,
filters::DecodeLimits {
max_output: cmd.decode_memory_limit,
},
),
Commands::CheckLinearization(cmd) => match check_linearization_path(&cmd.input) {
Ok(()) => {
println!("linearization OK");
Ok(())
}
Err(LinearizationCheckError::NotLinearized) => {
eprintln!(
"flpdf: not a linearized PDF: the first object in the file has no /Linearized key"
);
std::process::exit(1);
}
Err(LinearizationCheckError::InvalidParam { message }) => {
eprintln!("flpdf: linearization check failed: {message}");
std::process::exit(1);
}
Err(LinearizationCheckError::Io(e)) => Err(e.to_string().into()),
},
Commands::DumpObject(cmd) => {
run_dump_object(Some(cmd.input), cmd.repair, &cmd.password, &cmd.object_ref)
}
Commands::Pages(cmd) => {
if cmd.count {
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),
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),
Commands::IsEncrypted(cmd) => run_is_encrypted(&cmd.input, cmd.repair),
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) => {
if let Some(ref v) = cmd.force_version {
if parse_pdf_version(v).is_none() {
eprintln!("flpdf: invalid --force-version value: {:?}", v);
std::process::exit(1);
}
}
if let Some(ref v) = cmd.min_version {
if parse_pdf_version(v).is_none() {
eprintln!("flpdf: invalid --min-version value: {:?}", v);
std::process::exit(1);
}
}
if cmd.full_rewrite && cmd.linearize {
eprintln!("flpdf: --full-rewrite and --linearize cannot be used together");
std::process::exit(1);
}
if cmd.qdf && cmd.linearize {
eprintln!("flpdf: --qdf and --linearize cannot be used together");
std::process::exit(1);
}
if cmd.qdf {
match cmd.object_streams {
CliObjectStreamMode::Generate => {
eprintln!(
"flpdf: --qdf forces object streams off; ignoring \
--object-streams=generate"
);
}
CliObjectStreamMode::Disable => {
eprintln!(
"flpdf: --qdf forces object streams off; ignoring \
--object-streams=disable"
);
}
CliObjectStreamMode::Preserve => {}
}
}
let mut options = WriteOptions::default();
options.static_id = cmd.static_id;
options.deterministic_id = cmd.deterministic_id;
options.static_aes_iv = cmd.static_aes_iv;
options.min_version = cmd.min_version;
options.force_version = cmd.force_version;
options.no_original_object_ids = cmd.no_original_object_ids;
options.qdf = cmd.qdf;
options.full_rewrite = cmd.full_rewrite || cmd.qdf || cmd.deterministic_id;
options.object_streams = cmd.object_streams.into();
options.compress_streams = match cmd.compress_streams {
CliYesNo::Yes => CompressStreams::Yes,
CliYesNo::No => CompressStreams::No,
};
options.newline_before_endstream = match cmd.newline_before_endstream {
CliNewlineBeforeEndstream::Yes => NewlineBeforeEndstream::Yes,
CliNewlineBeforeEndstream::No => NewlineBeforeEndstream::No,
CliNewlineBeforeEndstream::Never => NewlineBeforeEndstream::Never,
};
options.stream_data = cmd.stream_data.map(Into::into);
if options.stream_data.is_some() {
options.full_rewrite = true;
}
options.recompress_flate = cmd.recompress_flate;
if cmd.recompress_flate {
options.full_rewrite = true;
}
apply_encryption_options(
&mut options,
&cmd.encrypt,
cmd.copy_encryption_from.as_deref(),
cmd.encryption_file_password.as_deref(),
cmd.password.allow_weak_crypto,
);
let normalize_content = cmd.normalize_content == CliYesNo::Yes;
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 normalize_content
|| coalesce_contents
|| cmd.remove_restrictions
|| cmd.decrypt
|| !cmd.encrypt.is_empty()
|| cmd.copy_encryption_from.is_some()
|| cmd.generate_appearances
|| cmd.flatten_annotations.is_some()
|| cmd.flatten_rotation
{
eprintln!(
"flpdf: --normalize-content / --coalesce-contents / \
--remove-restrictions / --decrypt / --encrypt / \
--copy-encryption-from / --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,
&cmd.page_ops,
overlay_specs,
remove_unref,
options,
cmd.verbose,
)
} else {
run_rewrite_with_page_ops(
&cmd.input,
&cmd.output,
cmd.repair,
&cmd.password,
&cmd.page_ops,
options,
cmd.verbose,
)
};
}
run_rewrite(
Some(cmd.input),
Some(cmd.output),
cmd.repair,
&cmd.password,
cmd.linearize,
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,
decode_limits: filters::DecodeLimits,
) -> 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 options = pdf_open_options(repair, password)?;
options.allow_weak_crypto = true;
let report = check_reader_with_options_and_limits(BufReader::new(file), options, decode_limits)
.map_err(|error| error_with_file(&input, actionable_password_error(error)))?;
let is_weak_crypto_advisory = |d: &flpdf::Diagnostic| {
d.severity == Severity::Warning && d.message.contains("weak crypto")
};
for diagnostic in report.diagnostics.entries() {
if is_weak_crypto_advisory(diagnostic) {
continue;
}
let location = diagnostic_location(&input, diagnostic.offset);
match diagnostic.severity {
Severity::Warning => eprintln!("WARNING: {location}: {}", diagnostic.message),
Severity::Error => {
eprintln!("{}: {location}: {}", progname(), diagnostic.message)
}
}
}
let has_warnings = report
.diagnostics
.entries()
.iter()
.any(|d| d.severity == Severity::Warning && !is_weak_crypto_advisory(d));
if !report.valid {
return Err(Box::new(CliExitError {
code: ExitCode::Errors,
message: String::new(),
}));
}
if let Some(summary) = &report.summary {
print_check_block(&input, summary);
}
if has_warnings {
eprintln!("{}: operation succeeded with warnings", progname());
return Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}));
}
println!("No syntax or stream encoding errors found; the file may still contain");
println!("errors that {} cannot detect", progname());
Ok(())
}
fn print_check_block(input: &Path, summary: &flpdf::CheckSummary) {
println!("checking {}", input.display());
match summary.extension_level {
Some(level) => println!("PDF Version: {} extension level {level}", summary.version),
None => println!("PDF Version: {}", summary.version),
}
println!(
"{}",
if summary.encrypted {
"File is encrypted"
} else {
"File is not encrypted"
}
);
println!(
"{}",
if summary.linearized {
"File is linearized"
} else {
"File is not linearized"
}
);
}
fn apply_encryption_options(
options: &mut WriteOptions,
encrypt: &[String],
copy_encryption_from: Option<&std::path::Path>,
encryption_file_password: Option<&str>,
allow_weak_crypto: bool,
) {
if !encrypt.is_empty() {
match parse_encrypt_segment(encrypt, allow_weak_crypto) {
Ok(params) => {
options.encrypt = Some(params);
options.full_rewrite = true;
}
Err(e) => {
eprintln!("flpdf: {e}");
std::process::exit(2);
}
}
}
if let Some(donor_path) = copy_encryption_from {
match build_copy_encryption_source(donor_path, encryption_file_password) {
Ok(src) => {
options.copy_encryption = Some(src);
options.full_rewrite = true;
}
Err(e) => {
eprintln!("flpdf: {e}");
std::process::exit(2);
}
}
}
}
fn build_copy_encryption_source(
path: &std::path::Path,
password: Option<&str>,
) -> CliResult<CopyEncryptionSource> {
let file = File::open(path)
.map_err(|e| format!("--copy-encryption-from: cannot open {:?}: {e}", path))?;
let reader = BufReader::new(file);
let pw_bytes: Vec<u8> = password.unwrap_or("").as_bytes().to_vec();
let opts = PdfOpenOptions {
password: pw_bytes,
repair: true,
..PdfOpenOptions::default()
};
let mut donor = Pdf::open_with_options(reader, opts)
.map_err(|e| format!("--copy-encryption-from: failed to open {:?}: {e}", path))?;
let info = donor
.encryption_info()
.map_err(|e| format!("--copy-encryption-from: failed to read encryption info: {e}"))?
.ok_or_else(|| format!("--copy-encryption-from: 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-from: donor {:?} uses V={} length={} \
stream={} string={} — not yet supported \
(flpdf-9hc.4.9 follow-up; 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-from: failed to recover donor file key for {:?} \
(wrong --encryption-file-password?)",
path
)
})?
.to_vec();
let encrypt_ref = donor.trailer().get_ref("Encrypt").ok_or_else(|| {
format!(
"--copy-encryption-from: donor {:?} has no /Encrypt in trailer",
path
)
})?;
let encrypt_obj = donor.resolve_borrowed(encrypt_ref).map_err(|e| {
format!(
"--copy-encryption-from: failed to resolve /Encrypt in {:?}: {e}",
path
)
})?;
let encrypt_dict = match encrypt_obj {
Object::Dictionary(d) => d.clone(),
other => {
return Err(format!(
"--copy-encryption-from: /Encrypt in {:?} is not a dictionary (got {:?})",
path, other
)
.into())
}
};
let id0: Vec<u8> = match donor.trailer().get("ID") {
Some(Object::Array(arr)) => match arr.first() {
Some(Object::String(bytes)) => bytes.clone(),
_ => {
return Err(format!(
"--copy-encryption-from: donor {:?} /ID[0] is not a string",
path
)
.into())
}
},
_ => {
return Err(format!(
"--copy-encryption-from: donor {:?} has no /ID array in trailer",
path
)
.into())
}
};
Ok(CopyEncryptionSource {
encrypt_dict,
file_key,
id0,
object_key_alg: ObjectKeyAlg::Aes,
})
}
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("-") {
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 (40-bit permission \
flags are flpdf-9hc.4.9.5 follow-up)"
.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,
linearize: bool,
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: WriteOptions,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let output = output.ok_or("missing output file")?;
if linearize && !overlay_specs.is_empty() {
return Err("--overlay/--underlay cannot be combined with --linearize".into());
}
let _ = decrypt;
if linearize {
let mut pdf = open_pdf(&input, repair, password)?;
reject_encrypted_write(&pdf)?;
let had_signatures = if remove_restrictions {
disable_digital_signatures(&mut pdf)?
} else {
false
};
let plan =
LinearizationPlan::from_pdf_with_object_stream_mode(&mut pdf, options.object_streams)?;
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = open_pdf(&input, repair, password)?;
reject_encrypted_write(&pdf2)?;
let mut options = options;
if remove_restrictions {
disable_digital_signatures(&mut pdf2)?;
}
if had_signatures {
options.full_rewrite = true;
}
let mut doc = write_linearized(&plan, &renumber, &mut pdf2, &options)?;
doc.back_patch()?;
std::fs::write(&output, &doc.bytes)?;
if verbose {
eprintln!("flpdf: wrote file {}", output.display());
}
if had_signatures {
eprintln!("flpdf: warning: removed signatures; signatures are now invalidated");
}
} else {
let mut pdf = open_pdf(&input, repair, password)?;
let diagnostics_start = pdf.repair_diagnostics().entries().len();
let was_encrypted = pdf.is_encrypted();
let had_signatures = if remove_restrictions {
disable_digital_signatures(&mut pdf)?
} else {
false
};
let mut options = options;
if was_encrypted {
options.full_rewrite = true;
}
if had_signatures {
options.full_rewrite = true;
}
let needs_mutation = coalesce_contents
|| normalize_content
|| remove_unref != CliRemoveUnreferencedResources::No
|| generate_appearances
|| flatten_annotations_mode.is_some()
|| flatten_rotation
|| !overlay_specs.is_empty();
if needs_mutation {
options.full_rewrite = true;
}
if options.min_version.is_some() || options.force_version.is_some() {
options.full_rewrite = true;
}
if coalesce_contents {
let page_refs = pages::page_refs(&mut pdf)?;
for page_ref in page_refs {
coalesce_page_contents(&mut pdf, page_ref)?;
}
}
if normalize_content {
let page_refs = pages::page_refs(&mut pdf)?;
for page_ref in page_refs {
apply_normalize_content(&mut pdf, page_ref)?;
}
}
if generate_appearances {
generate_missing_appearances(&mut pdf)?;
}
if let Some(mode) = flatten_annotations_mode {
flatten_annotations(&mut pdf, mode.into())?;
}
if flatten_rotation {
let page_refs = pages::page_refs(&mut pdf)?;
flatten_rotation_on_pages(&mut pdf, &page_refs)?;
}
if !overlay_specs.is_empty() {
let mut built = build_overlay_specs(overlay_specs, repair)?;
let mut max_ver: (u8, u8) = parse_pdf_version(pdf.version()).unwrap_or((1, 0));
let mut max_ext: i64 = pdf.adobe_extension_level().unwrap_or(0);
for spec in built.iter_mut() {
let sv = parse_pdf_version(spec.source.version()).unwrap_or((1, 0));
let se = spec.source.adobe_extension_level().unwrap_or(0);
match sv.cmp(&max_ver) {
std::cmp::Ordering::Greater => {
max_ver = sv;
max_ext = se;
}
std::cmp::Ordering::Equal => {
if se > max_ext {
max_ext = se;
}
}
std::cmp::Ordering::Less => {}
}
}
if let Some(ref current) = options.min_version {
let cur = parse_pdf_version(current).unwrap_or((1, 0));
let cur_ext = options.min_extension_level.unwrap_or(0);
match cur.cmp(&max_ver) {
std::cmp::Ordering::Greater => {
max_ver = cur;
max_ext = cur_ext;
}
std::cmp::Ordering::Equal => {
if cur_ext > max_ext {
max_ext = cur_ext;
}
}
std::cmp::Ordering::Less => {}
}
}
options.min_version = Some(format!("{}.{}", max_ver.0, max_ver.1));
options.min_extension_level = (max_ext > 0).then_some(max_ext);
if verbose {
let report = flpdf::overlay_verbose_report(&mut pdf, &mut built)?;
eprintln!("flpdf: processing underlay/overlay");
for page in &report {
eprintln!(" page {}", 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",
};
eprintln!(" {} {} {}", file, kind_str, src.src_page);
}
}
}
flpdf::apply_overlay_specs(&mut pdf, &mut built)?;
}
let mut out = File::create(&output)?;
write_pdf_with_options(&mut pdf, &mut out, &options)?;
if verbose {
eprintln!("flpdf: wrote file {}", output.display());
}
if remove_restrictions && was_encrypted {
eprintln!("flpdf: removed restrictions (encryption and advisory permissions stripped)");
}
if had_signatures {
eprintln!("flpdf: warning: removed signatures; signatures are now invalidated");
}
finish_write_warnings(&input, &pdf, diagnostics_start)?;
}
Ok(())
}
fn generate_missing_appearances<R: Read + Seek>(pdf: &mut Pdf<R>) -> CliResult<()> {
let mut candidates: Vec<ObjectRef> = Vec::new();
for (_page_ref, annots) in enumerate_document_annotations(pdf)? {
for annot in annots {
if annot.is_widget {
candidates.push(annot.annot_ref);
}
}
}
for widget_ref in candidates {
let has_normal = {
let mut helper = AnnotationObjectHelper::new(widget_ref, pdf);
helper
.appearance()?
.is_some_and(|ap| ap.get("N").is_some_and(|val| !matches!(val, Object::Null)))
};
if has_normal {
continue;
}
let field_type = {
let mut helper = FormFieldObjectHelper::new(widget_ref, pdf);
helper.field_type()?
};
match field_type.as_deref() {
Some(b"Tx") => {
generate_text_field_appearance(pdf, widget_ref)?;
}
Some(b"Btn") => {
generate_button_field_appearance(pdf, widget_ref)?;
}
Some(b"Ch") => {
generate_choice_field_appearance(pdf, widget_ref)?;
}
_ => {}
}
}
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>,
}
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,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum QpdfArgSegment {
Encrypt,
Pages,
AddAttachment,
CopyAttachments,
Overlay,
}
impl QpdfArgSegment {
fn from_option_name(name: &str) -> Option<Self> {
match name {
"encrypt" => Some(Self::Encrypt),
"pages" => Some(Self::Pages),
"add-attachment" => Some(Self::AddAttachment),
"copy-attachments-from" => Some(Self::CopyAttachments),
"overlay" | "underlay" => Some(Self::Overlay),
_ => None,
}
}
fn accepts(self, name: &str) -> bool {
match self {
Self::Encrypt => matches!(
name,
"use-aes"
| "force-V4"
| "force-R5"
| "allow-insecure"
| "print"
| "modify"
| "extract"
| "annotate"
| "form"
| "assemble"
| "accessibility"
| "cleartext-metadata"
),
Self::Pages => matches!(name, "file" | "password" | "range"),
Self::AddAttachment => matches!(
name,
"key"
| "filename"
| "mimetype"
| "description"
| "creationdate"
| "moddate"
| "afrelationship"
| "replace"
),
Self::CopyAttachments => matches!(name, "password" | "prefix"),
Self::Overlay => matches!(name, "file" | "password" | "to" | "from" | "repeat"),
}
}
}
fn collect_clap_long_options(command: &clap::Command, names: &mut HashSet<String>) {
for arg in command.get_arguments() {
if let Some(long) = arg.get_long() {
names.insert(long.to_string());
}
if let Some(aliases) = arg.get_all_aliases() {
names.extend(aliases.into_iter().map(str::to_string));
}
}
for subcommand in command.get_subcommands() {
collect_clap_long_options(subcommand, names);
}
}
fn long_option_name(arg: &str) -> Option<&str> {
arg.strip_prefix("--")
.filter(|rest| !rest.is_empty())
.and_then(|rest| rest.split("=").next())
}
fn single_dash_option_name(arg: &str) -> Option<&str> {
if arg == "-" || arg.starts_with("--") {
return None;
}
let rest = arg.strip_prefix("-")?;
if rest.chars().next().is_some_and(|c| c.is_ascii_digit()) {
return None;
}
rest.split("=").next()
}
fn rewrite_qpdf_single_dash(args: Vec<String>) -> Vec<String> {
let mut known_long_options = HashSet::new();
collect_clap_long_options(&Cli::command(), &mut known_long_options);
let mut out = Vec::with_capacity(args.len());
let mut active_segment = None;
let mut passthrough = false;
for mut arg in args {
if passthrough {
out.push(arg);
continue;
}
if arg == "--" {
out.push(arg);
if active_segment.take().is_none() {
passthrough = true;
}
continue;
}
if let Some(name) = single_dash_option_name(&arg) {
let recognized = active_segment
.map(|segment: QpdfArgSegment| segment.accepts(name))
.unwrap_or_else(|| known_long_options.contains(name));
if recognized {
arg = format!("-{arg}");
}
}
if active_segment.is_none() {
if let Some(name) = long_option_name(&arg) {
active_segment = QpdfArgSegment::from_option_name(name);
}
}
out.push(arg);
}
out
}
fn extract_overlay_groups(args: Vec<String>) -> CliResult<(Vec<String>, Vec<OverlaySpec>)> {
let mut residual: Vec<String> = Vec::with_capacity(args.len());
let mut specs: Vec<OverlaySpec> = Vec::new();
let mut iter = args.into_iter();
while let Some(arg) = iter.next() {
if matches!(
arg.as_str(),
"--encrypt" | "--pages" | "--add-attachment" | "--copy-attachments-from"
) {
residual.push(arg);
for tok in iter.by_ref() {
let is_terminator = tok == "--";
residual.push(tok);
if is_terminator {
break;
}
}
continue;
}
for prefix in ["--overlay=", "--underlay="] {
if arg.starts_with(prefix) {
let flag = prefix.trim_end_matches('=');
return Err(format!(
"{flag}: the `{flag}=FILE` form is not supported; pass the file as a \
separate token: `{flag} FILE … --`"
)
.into());
}
}
let kind = match arg.as_str() {
"--overlay" => Some(OverlayKind::Overlay),
"--underlay" => Some(OverlayKind::Underlay),
_ => None,
};
let Some(kind) = kind else {
residual.push(arg);
continue;
};
let mut tokens: Vec<String> = Vec::new();
let mut terminated = false;
for tok in iter.by_ref() {
if tok == "--" {
terminated = true;
break;
}
tokens.push(tok);
}
if !terminated {
let flag = match kind {
OverlayKind::Overlay => "--overlay",
OverlayKind::Underlay => "--underlay",
};
return Err(format!(
"{flag}: overlay/underlay group must be terminated by a `--` token"
)
.into());
}
specs.push(parse_overlay_segment(kind, &tokens)?);
}
Ok((residual, specs))
}
fn build_overlay_specs(
specs: &[OverlaySpec],
repair: bool,
) -> CliResult<Vec<flpdf::OverlaySpec<BufReader<File>>>> {
let mut built = Vec::with_capacity(specs.len());
for spec in specs {
let path = PathBuf::from(&spec.file);
let file = File::open(&path).map_err(|error| error_with_file(&path, error.into()))?;
let options = PdfOpenOptions {
repair,
allow_weak_crypto: true,
password: spec
.password
.as_ref()
.map(|p| p.as_bytes().to_vec())
.unwrap_or_default(),
..Default::default()
};
let source = Pdf::open_with_options(BufReader::new(file), options)
.map_err(|error| error_with_file(&path, actionable_password_error(error)))?;
emit_open_warnings(&path, &source);
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,
page_ops: &PageOpArgs,
overlay_specs: &[OverlaySpec],
remove_unref: CliRemoveUnreferencedResources,
options: WriteOptions,
verbose: bool,
) -> CliResult<()> {
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
let specs = parse_pages_segment(&page_ops.pages)?;
let mut inputs = resolve_page_specs(&specs, primary_input)?;
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 distinct.len() > 1 {
return Err(format!(
"--pages: cross-document page merge is not supported at this layer \
(got {} distinct source files: {}). Single-document extraction \
(repeats of the same file or '.') is supported; cross-doc merge \
and AcroForm field-collision handling are tracked in a separate issue.",
distinct.len(),
distinct
.iter()
.map(|p| p.display().to_string())
.collect::<Vec<_>>()
.join(", ")
)
.into());
}
if verbose {
eprintln!("flpdf: selecting --keep-open-files=y");
for path in &distinct {
let fname = pages_progress_filename(path);
eprintln!("flpdf: {fname}: checking for shared resources");
eprintln!("flpdf: no shared resources found");
}
}
let plan = CombinedPlan::from_specs(inputs.clone())?;
if verbose {
eprintln!("flpdf: removing unreferenced pages from primary input");
for spec in &inputs {
eprintln!(
"flpdf: adding pages from {}",
pages_progress_filename(&spec.path)
);
}
}
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)?;
reject_encrypted_write(&pdf)?;
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 result = rebuild_page_tree(&mut pdf, &selected)?;
apply_rotate_specs(&mut pdf, &page_ops.rotate, &result.new_kids)?;
{
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(&src_indices, 0)?;
let folded = flpdf::merge_adjacent_ranges(entries);
labels.write_reconstructed_labels(&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)?;
prune_after_subset(&mut pdf, remove_unref.into())?;
prune_acroform_after_subset(&mut pdf, &result)?;
let mut options = options;
options.full_rewrite = true;
if !overlay_specs.is_empty() {
let mut built = build_overlay_specs(overlay_specs, repair)?;
let mut max_ver: (u8, u8) = parse_pdf_version(pdf.version()).unwrap_or((1, 0));
let mut max_ext: i64 = pdf.adobe_extension_level().unwrap_or(0);
for spec in built.iter_mut() {
let sv = parse_pdf_version(spec.source.version()).unwrap_or((1, 0));
let se = spec.source.adobe_extension_level().unwrap_or(0);
if (sv, se) > (max_ver, max_ext) {
max_ver = sv;
max_ext = se;
}
}
if let Some(ref current) = options.min_version {
let cur = parse_pdf_version(current).unwrap_or((1, 0));
let cur_ext = options.min_extension_level.unwrap_or(0);
if (cur, cur_ext) > (max_ver, max_ext) {
max_ver = cur;
max_ext = cur_ext;
}
}
options.min_version = Some(format!("{}.{}", max_ver.0, max_ver.1));
options.min_extension_level = (max_ext > 0).then_some(max_ext);
if verbose {
let report = flpdf::overlay_verbose_report(&mut pdf, &mut built)?;
eprintln!("flpdf: processing underlay/overlay");
for page in &report {
eprintln!(" page {}", 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",
};
eprintln!(" {} {} {}", file, kind_str, src.src_page);
}
}
}
flpdf::apply_overlay_specs(&mut pdf, &mut built)?;
}
let mut bytes: Vec<u8> = Vec::new();
write_pdf_with_options(&mut pdf, &mut bytes, &options)?;
if let Some(raw) = page_ops.split_pages.as_deref() {
let n = parse_split_n(raw)?;
let written = split_pages(&bytes, n, output, options.deterministic_id)?;
if verbose {
for path in &written {
eprintln!("flpdf: wrote file {}", path.display());
}
}
} else {
std::fs::write(output, &bytes)?;
if verbose {
eprintln!("flpdf: wrote file {}", output.display());
}
}
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 run_rewrite_with_page_ops(
input: &std::path::Path,
output: &std::path::Path,
repair: bool,
password: &PasswordArgs,
page_ops: &PageOpArgs,
options: WriteOptions,
verbose: bool,
) -> CliResult<()> {
if page_ops.empty {
return Err(
"--empty is accepted by qpdf but not implemented in flpdf at this layer \
(tracked separately); rerun without --empty"
.into(),
);
}
let mut pdf = open_pdf(&input.to_path_buf(), repair, password)?;
reject_encrypted_write(&pdf)?;
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.full_rewrite = true;
let mut bytes: Vec<u8> = Vec::new();
write_pdf_with_options(&mut pdf, &mut bytes, &options)?;
if let Some(raw) = page_ops.split_pages.as_deref() {
let n = parse_split_n(raw)?;
let written = split_pages(&bytes, n, output, options.deterministic_id)?;
if verbose {
for path in &written {
eprintln!("flpdf: wrote file {}", path.display());
}
}
} else {
std::fs::write(output, &bytes)?;
if verbose {
eprintln!("flpdf: wrote file {}", output.display());
}
}
Ok(())
}
fn page_ops_active(p: &PageOpArgs) -> bool {
!p.pages.is_empty() || !p.rotate.is_empty() || p.split_pages.is_some() || p.empty
}
fn apply_normalize_content<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> CliResult<()> {
let page_obj = pdf.resolve_borrowed(page_ref)?;
let Object::Dictionary(page_dict) = page_obj else {
return Ok(()); };
let contents = match page_dict.get("Contents").cloned() {
None => return Ok(()), Some(c) => c,
};
match contents {
Object::Reference(stream_ref) => {
normalize_and_store_stream(pdf, stream_ref)?;
}
Object::Array(elems) => {
for elem in elems {
if let Object::Reference(r) = elem {
normalize_and_store_stream(pdf, r)?;
}
}
}
Object::Stream(_) => {
}
_ => {}
}
Ok(())
}
fn normalize_and_store_stream<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
stream_ref: ObjectRef,
) -> CliResult<()> {
let resolved = pdf.resolve_borrowed(stream_ref)?;
let Object::Stream(stream) = resolved else {
return Ok(()); };
let decoded = filters::decode_stream_data(&stream.dict, &stream.data)?;
let normalized = normalize_content_stream(&decoded)?;
let mut new_dict: Dictionary = stream.dict.clone();
for key in &["Filter", "DecodeParms", "DP", "DL"] {
new_dict.remove(key);
}
new_dict.insert("Length", Object::Integer(normalized.len() as i64));
let new_stream = Stream::new(new_dict, normalized);
pdf.set_object(stream_ref, Object::Stream(new_stream));
Ok(())
}
fn run_qdf(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
let output = output.ok_or("missing output file")?;
let mut pdf = open_pdf(&input, repair, password)?;
reject_encrypted_write(&pdf)?;
let diagnostics_start = pdf.repair_diagnostics().entries().len();
let mut options = WriteOptions::default();
options.qdf = true;
options.full_rewrite = true;
let mut out = File::create(output)?;
write_pdf_with_options(&mut pdf, &mut out, &options)?;
finish_write_warnings(&input, &pdf, diagnostics_start)
}
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_encrypted_write<R: std::io::Read + std::io::Seek>(pdf: &Pdf<R>) -> CliResult<()> {
if pdf.is_encrypted() {
return Err("encrypted PDF output is not supported for this mode; use plain rewrite to produce decrypted plaintext".into());
}
Ok(())
}
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 object = pdf.resolve_borrowed(object_ref)?;
if matches!(object, Object::Null) {
return Err(format!(
"object {} {} R not found",
object_ref.number, object_ref.generation
)
.into());
}
let mut out = Vec::new();
object.write_pdf(&mut out);
println!("{}", String::from_utf8_lossy(&out));
Ok(())
}
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 object = pdf.resolve_borrowed(object_ref)?;
if matches!(object, Object::Null) {
return Err(format!(
"object {} {} R not found",
object_ref.number, object_ref.generation
)
.into());
}
let Object::Stream(stream) = object else {
return Err(format!(
"object {} {} R is not a stream",
object_ref.number, object_ref.generation
)
.into());
};
if cmd.raw {
if let Some(path) = cmd.out {
std::fs::write(path, &stream.data)?;
} else {
std::io::stdout().write_all(&stream.data)?;
std::io::stdout().flush()?;
}
return Ok(());
}
let passthrough_label = stream.dict.get("Filter").and_then(|filter| {
let name = filter.as_name().or_else(|| match filter.as_array() {
Some([single]) => single.as_name(),
_ => None,
})?;
filters::passthrough_codec_label(name)
});
if let Some(label) = passthrough_label {
if let Some(path) = cmd.out {
std::fs::write(path, &stream.data)?;
eprintln!("<binary, {} bytes, codec {}>", stream.data.len(), label);
} else {
println!("<binary, {} bytes, codec {}>", stream.data.len(), label);
}
return Ok(());
}
let bytes = filters::decode_stream_data(&stream.dict, &stream.data)?;
if let Some(path) = cmd.out {
std::fs::write(path, bytes)?;
} else {
std::io::stdout().write_all(&bytes)?;
std::io::stdout().flush()?;
}
Ok(())
}
fn run_show_info(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 info_ref = pdf
.trailer()
.get_ref("Info")
.ok_or("document info dictionary not found")?;
let info = pdf.resolve_borrowed(info_ref)?;
let Object::Dictionary(dict) = info else {
return Err(format!("info object {} is not a dictionary", info_ref).into());
};
println!("Info:");
for (key, value) in dict.iter() {
let key = String::from_utf8_lossy(key);
println!(" {} = {}", key, object_to_pdf(value));
}
Ok(())
}
fn run_show_catalog(
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 catalog_ref = pdf.root_ref().ok_or("document catalog missing")?;
let catalog = pdf.resolve_borrowed(catalog_ref)?;
println!("Catalog: {}", object_to_pdf(catalog));
Ok(())
}
fn run_show_metadata(
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 catalog_ref = pdf.root_ref().ok_or("document catalog missing")?;
let catalog = pdf.resolve_borrowed(catalog_ref)?;
let Object::Dictionary(catalog) = catalog else {
return Err(format!("document catalog {} is not a dictionary", catalog_ref).into());
};
match catalog.get_ref("Metadata") {
Some(metadata_ref) => {
let metadata = pdf.resolve_borrowed(metadata_ref)?;
match metadata {
Object::Stream(stream) => {
let kind = stream
.dict
.get("Subtype")
.map(object_to_pdf)
.unwrap_or_else(|| String::from("Unknown"));
println!("Metadata: stream ({}) {}", metadata_ref, kind);
println!(" length: {}", stream.data.len());
const MAX_METADATA_PREVIEW_BYTES: usize = 1000;
let preview_len = stream.data.len().min(MAX_METADATA_PREVIEW_BYTES);
let preview = String::from_utf8_lossy(&stream.data[..preview_len]);
if stream.data.len() > MAX_METADATA_PREVIEW_BYTES {
println!(
" preview: {} (truncated, total {} bytes)",
preview,
stream.data.len()
);
} else {
println!(" preview: {}", preview);
}
}
Object::Dictionary(dict) => {
println!("Metadata: dictionary {}", metadata_ref);
for (key, value) in dict.iter() {
let key = String::from_utf8_lossy(key);
println!(" {}: {}", key, object_to_pdf(value));
}
}
other => {
println!("Metadata: non-stream {}", metadata_ref);
println!(" type: {}", object_to_pdf(other));
}
}
}
None => println!("Metadata: <missing>"),
}
Ok(())
}
fn run_show_outline(
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 tree = match pdf.outline().get_tree() {
Ok(tree) => tree,
Err(error) => {
eprintln!("Warning: {error}");
println!("Outline:");
println!(" <empty>");
return Ok(());
}
};
println!("Outline:");
if tree.roots().is_empty() {
println!(" <empty>");
return Ok(());
}
for (index, (depth, _id, item)) in tree.preorder().enumerate() {
println!("{}{}: {}", " ".repeat(depth - 1), index + 1, item.title);
}
Ok(())
}
fn run_show_fonts(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 font_refs = match fonts::font_entries(&mut pdf) {
Ok(font_refs) => font_refs,
Err(error) => {
eprintln!("Warning: {error}");
Default::default()
}
};
println!("Fonts:");
if font_refs.is_empty() {
println!(" <none>");
return Ok(());
}
for (name, font_obj) in font_refs {
let font_name = String::from_utf8_lossy(&name);
if let Object::Dictionary(dict) = font_obj {
println!(" /{}", font_name);
if let Some(font_type) = dict.get("Type") {
println!(" type: {}", object_to_pdf(font_type));
}
if let Some(subtype) = dict.get("Subtype") {
println!(" subtype: {}", object_to_pdf(subtype));
}
if let Some(base_font) = dict.get("BaseFont") {
println!(" base_font: {}", object_to_pdf(base_font));
}
} else {
println!(" /{}", font_name);
println!(" type: <invalid>");
println!(" subtype: <invalid>");
println!(" base_font: <invalid>");
}
}
Ok(())
}
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 pages = pages::page_refs(&mut pdf)?;
println!("{}", pages.len());
Ok(())
}
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 page_refs = pages::page_refs(&mut pdf)?;
for (index, page_ref) in page_refs.iter().enumerate() {
let page = pdf.resolve_borrowed(*page_ref)?;
let Object::Dictionary(dict) = page else {
continue;
};
println!("page {}: {}", index + 1, page_ref);
if let Some(media_box) = dict.get("MediaBox") {
println!(" media-box: {}", object_to_pdf(media_box));
}
if let Some(resources) = dict.get("Resources") {
println!(" resources: {}", object_to_pdf(resources));
}
if let Some(contents) = dict.get("Contents") {
println!(" contents: {}", object_to_pdf(contents));
}
if let Some(rotate) = dict.get("Rotate") {
println!(" rotate: {}", object_to_pdf(rotate));
}
}
Ok(())
}
fn run_show_linearization(input: Option<PathBuf>) -> CliResult<()> {
let input = input.ok_or("missing input file")?;
match show_linearization_path(&input) {
Ok(dump) => {
print!("{dump}");
Ok(())
}
Err(ShowLinearizationError::Malformed { message }) => {
eprintln!("flpdf: malformed linearization data: {message}");
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)?;
options.allow_weak_crypto = true;
match Pdf::open_with_options(BufReader::new(file), options) {
Ok(pdf) => Ok(EncryptionProbe::Opened {
encrypted: pdf.is_encrypted(),
}),
Err(flpdf::Error::Encrypted(flpdf::EncryptedError::BadPassword)) => {
Ok(EncryptionProbe::EncryptedAuthFailed)
}
Err(other) => Err(other.into()),
}
}
fn run_is_encrypted(input: &PathBuf, repair: bool) -> CliResult<()> {
let encrypted = match probe_encryption(input, repair, &PasswordArgs::default())? {
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) => {
println!("{}", hex_lower(key));
Ok(())
}
None => {
Err("file is not encrypted; no encryption key to show".into())
}
}
}
fn run_show_encryption(input: &PathBuf, repair: bool, password: &PasswordArgs) -> CliResult<()> {
let mut pdf = open_pdf_for_inspection(input, repair, password)?;
let Some(info) = pdf.encryption_info()? else {
println!("File is not encrypted");
return Ok(());
};
println!("V = {}", info.v);
println!("Length = {}", info.length_bits);
println!("Filter = {}", info.filter);
println!(
"EncryptMetadata = {}",
if info.encrypt_metadata {
"true"
} else {
"false"
}
);
let mut cf_names: Vec<_> = info.named_crypt_filters.clone();
cf_names.sort();
for (name, method) in &cf_names {
println!("CF /{name} = {method}");
}
println!("R = {}", info.r);
println!("P = {}", info.permissions.raw());
if pdf.owner_password_matched() {
println!("Supplied password is owner password");
}
if pdf.user_password_matched() {
println!("Supplied password is user password");
}
let p = info.permissions.raw();
let r = info.r;
let bit = |n: u32| (p >> (n - 1)) & 1 == 1;
let allow_print_low = bit(3);
let allow_extract_all = bit(5);
let allow_accessibility = if r < 3 { bit(5) } else { bit(10) };
let allow_print_high = allow_print_low && (r < 3 || bit(12));
let allow_modify_assembly = if r < 3 { bit(4) } else { bit(11) };
let allow_modify_form = if r < 3 { bit(6) } else { bit(9) };
let allow_modify_annotation = bit(6);
let allow_modify_other = bit(4);
let allow_modify_all = allow_modify_annotation
&& allow_modify_other
&& (r < 3 || (allow_modify_form && allow_modify_assembly));
let show = |v: bool| if v { "allowed" } else { "not allowed" };
println!("extract for accessibility: {}", show(allow_accessibility));
println!("extract for any purpose: {}", show(allow_extract_all));
println!("print low resolution: {}", show(allow_print_low));
println!("print high resolution: {}", show(allow_print_high));
println!("modify document assembly: {}", show(allow_modify_assembly));
println!("modify forms: {}", show(allow_modify_form));
println!("modify annotations: {}", show(allow_modify_annotation));
println!("modify other: {}", show(allow_modify_other));
println!("modify anything: {}", show(allow_modify_all));
if info.v >= 4 {
println!("stream encryption method: {}", info.stream_method);
println!("string encryption method: {}", info.string_method);
let file_method = info.eff_method.unwrap_or(info.stream_method);
println!("file encryption method: {file_method}");
}
Ok(())
}
fn hex_lower(bytes: &[u8]) -> String {
let mut out = String::with_capacity(bytes.len() * 2);
for b in bytes {
out.push_str(&format!("{b:02x}"));
}
out
}
fn open_pdf(
input: &PathBuf,
repair: bool,
password: &PasswordArgs,
) -> CliResult<Pdf<BufReader<File>>> {
open_pdf_impl(input, repair, password, false)
}
fn open_pdf_for_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,
force_allow_weak_crypto: bool,
) -> CliResult<Pdf<BufReader<File>>> {
let file = File::open(input).map_err(|error| error_with_file(input, error.into()))?;
let mut options = pdf_open_options(repair, password)?;
if force_allow_weak_crypto {
options.allow_weak_crypto = true;
}
let pdf = Pdf::open_with_options(BufReader::new(file), options)
.map_err(|error| error_with_file(input, actionable_password_error(error)))?;
emit_open_warnings(input, &pdf);
if pdf.uses_weak_crypto() && !force_allow_weak_crypto {
eprintln!(
"WARNING: {}: encrypted PDF uses weak crypto; processing because --allow-weak-crypto was supplied",
input.display()
);
}
Ok(pdf)
}
fn pdf_open_options(repair: bool, password: &PasswordArgs) -> CliResult<PdfOpenOptions> {
let allow_weak_crypto = password.allow_weak_crypto;
let password_is_hex_key = password.password_is_hex_key;
let _suppress_password_recovery = password.suppress_password_recovery;
let password_mode = password.password_mode.into();
let password = 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(PdfOpenOptions {
repair,
password,
password_mode,
allow_weak_crypto,
password_is_hex_key,
})
}
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 emit_open_warnings<R: Read + Seek>(path: &Path, pdf: &Pdf<R>) {
emit_warnings_since(path, pdf, 0);
}
fn emit_warnings_since<R: Read + Seek>(path: &Path, pdf: &Pdf<R>, start: usize) {
for diagnostic in pdf.repair_diagnostics().entries().iter().skip(start) {
let location = diagnostic_location(path, diagnostic.offset);
eprintln!("WARNING: {location}: {}", diagnostic.message);
}
}
fn finish_write_warnings<R: Read + Seek>(
input: &Path,
pdf: &Pdf<R>,
diagnostics_start: usize,
) -> CliResult<()> {
if pdf.repair_diagnostics().entries().len() == diagnostics_start {
return Ok(());
}
emit_warnings_since(input, pdf, diagnostics_start);
eprintln!("{}: operation succeeded with warnings", progname());
Err(Box::new(CliExitError {
code: ExitCode::Warnings,
message: String::new(),
}))
}
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 matches!(
error,
flpdf::Error::Encrypted(flpdf::EncryptedError::BadPassword)
) {
return "encrypted PDF: incorrect password; retry with --password or --password-file"
.into();
}
error.into()
}
fn object_to_pdf(object: &Object) -> String {
let mut out = Vec::new();
object.write_pdf(&mut out);
String::from_utf8_lossy(&out).to_string()
}
fn parse_pdf_date_arg(s: &str) -> CliResult<(u16, u8, u8, u8, u8, 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 year: u16 = s[0..4]
.parse()
.map_err(|_| format!("invalid year in PDF date D:{s}"))?;
let month: u8 = s[4..6]
.parse()
.map_err(|_| format!("invalid month in PDF date D:{s}"))?;
let day: u8 = s[6..8]
.parse()
.map_err(|_| format!("invalid day in PDF date D:{s}"))?;
let hour: u8 = s[8..10]
.parse()
.map_err(|_| format!("invalid hour in PDF date D:{s}"))?;
let minute: u8 = s[10..12]
.parse()
.map_err(|_| format!("invalid minute in PDF date D:{s}"))?;
let second: u8 = s[12..14]
.parse()
.map_err(|_| format!("invalid second in PDF date D:{s}"))?;
Ok((year, month, day, hour, minute, second))
}
struct AddAttachmentArgs {
file: PathBuf,
key: Option<Vec<u8>>,
filename: Option<Vec<u8>>,
mimetype: Option<Vec<u8>>,
description: Option<Vec<u8>>,
af_relationship: Option<Vec<u8>>,
creation_date: Option<(u16, u8, u8, u8, u8, u8)>,
mod_date: Option<(u16, u8, u8, u8, u8, 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 af_relationship: Option<Vec<u8>> = None;
let mut creation_date: Option<(u16, u8, u8, u8, u8, u8)> = None;
let mut mod_date: Option<(u16, u8, u8, u8, u8, 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=") {
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("--afrelationship=") {
af_relationship = 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,
af_relationship,
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())
}
fn run_add_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
tokens: Vec<String>,
deterministic_id: bool,
) -> CliResult<()> {
let input = input.ok_or("--add-attachment: missing input PDF")?;
let output = output.ok_or("--add-attachment: missing output PDF")?;
let args = parse_add_attachment_segment(tokens)?;
let payload = std::fs::read(&args.file)
.map_err(|e| format!("--add-attachment: cannot read {:?}: {e}", args.file))?;
let basename = path_basename(&args.file)?;
let key = args.key.unwrap_or_else(|| basename.clone());
let filename = args.filename.unwrap_or_else(|| basename.clone());
let filename = String::from_utf8(filename).map_err(|_| {
"--add-attachment: filename must be valid UTF-8 so it can be encoded as /UF"
})?;
let mut pdf = open_pdf(&input, repair, password)?;
reject_encrypted_write(&pdf)?;
if !args.replace {
let existing = list_attachment_info(&mut pdf)?;
if existing.iter().any(|a| a.key == key) {
return Err(format!(
"--add-attachment: key {:?} already exists; use --replace to overwrite",
String::from_utf8_lossy(&key)
)
.into());
}
} else {
remove_attachment(&mut pdf, &key)?;
}
let dates = FileParamDates {
creation: args.creation_date,
modification: args.mod_date,
};
let mut builder = FileSpecBuilder::new(ascii_filename_fallback(&filename), payload)
.uf_filename(&filename)
.compress(true)
.dates(dates);
if let Some(mime) = args.mimetype {
builder = builder.mimetype(mime);
}
if let Some(desc) = args.description {
builder = builder.description(desc);
}
if let Some(rel) = args.af_relationship {
builder = builder.af_relationship(rel);
}
let filespec_ref = builder.build(&mut pdf)?;
insert_embedded_file(&mut pdf, &key, filespec_ref)?;
let mut options = WriteOptions::default();
options.full_rewrite = true;
options.deterministic_id = deterministic_id;
let mut out = File::create(&output)?;
write_pdf_with_options(&mut pdf, &mut out, &options)?;
Ok(())
}
fn run_remove_attachment(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
key: &str,
deterministic_id: bool,
) -> 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)?;
reject_encrypted_write(&pdf)?;
let found = remove_attachment(&mut pdf, key.as_bytes())?;
if !found {
return Err(format!("--remove-attachment: key {:?} not found in document", key).into());
}
let mut options = WriteOptions::default();
options.full_rewrite = true;
options.deterministic_id = deterministic_id;
let mut out = File::create(&output)?;
write_pdf_with_options(&mut pdf, &mut out, &options)?;
Ok(())
}
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 entries = list_attachment_info(&mut pdf)?;
let listing = format_attachment_list(&entries, verbose);
print!("{listing}");
Ok(())
}
fn run_show_attachment(
input: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
key: &str,
out_path: Option<PathBuf>,
) -> CliResult<()> {
let input = input.ok_or("--show-attachment: missing input PDF")?;
let mut pdf = open_pdf(&input, repair, password)?;
let bytes = extract_attachment(&mut pdf, key.as_bytes()).map_err(|e| {
format!(
"--show-attachment: key {:?} not found or unreadable: {e}",
key
)
})?;
if let Some(path) = out_path {
std::fs::write(&path, &bytes)
.map_err(|e| format!("--show-attachment: cannot write to {:?}: {e}", path))?;
} else {
std::io::stdout().write_all(&bytes)?;
std::io::stdout().flush()?;
}
Ok(())
}
fn run_copy_attachments_from(
input: Option<PathBuf>,
output: Option<PathBuf>,
repair: bool,
password: &PasswordArgs,
tokens: Vec<String>,
deterministic_id: bool,
) -> 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 src_options = PdfOpenOptions {
repair,
password: args.password.clone(),
..PdfOpenOptions::default()
};
let src_file = File::open(&args.file)
.map_err(|e| format!("--copy-attachments-from: cannot open {:?}: {e}", args.file))?;
let mut src = Pdf::open_with_options(BufReader::new(src_file), src_options)
.map_err(|e| format!("--copy-attachments-from: failed to open source PDF: {e}"))?;
let mut target = open_pdf(&input, repair, password)?;
reject_encrypted_write(&target)?;
let prefix = args.prefix.as_deref();
let count = copy_attachments_from(&mut target, &mut src, prefix)?;
eprintln!("copied {count} attachment(s)");
let mut options = WriteOptions::default();
options.full_rewrite = true;
options.deterministic_id = deterministic_id;
let mut out = File::create(&output)?;
write_pdf_with_options(&mut target, &mut out, &options)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn strs(v: &[&str]) -> Vec<String> {
v.iter().map(|s| s.to_string()).collect()
}
#[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 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 out =
rewrite_qpdf_single_dash(strs(&["flpdf", "-overlay", "stamp.pdf", "-to=1", "--"]));
assert_eq!(
out,
strs(&["flpdf", "--overlay", "stamp.pdf", "--to=1", "--",])
);
}
#[test]
fn each_segment_kind_recognizes_its_sub_options() {
assert!(QpdfArgSegment::Encrypt.accepts("use-aes"));
assert!(QpdfArgSegment::Pages.accepts("range"));
assert!(QpdfArgSegment::AddAttachment.accepts("replace"));
assert!(QpdfArgSegment::CopyAttachments.accepts("prefix"));
}
#[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 mut names = HashSet::new();
collect_clap_long_options(&command, &mut names);
assert!(names.contains("mode"));
assert!(names.contains("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 legacy_encrypt_password_starting_with_dash_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 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_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_rejected() {
let argv = strs(&["flpdf", "--overlay=src.pdf", "--"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert!(err.contains("--overlay"), "got: {err}");
assert!(err.contains("not supported"), "got: {err}");
}
#[test]
fn extract_underlay_equals_form_rejected() {
let argv = strs(&["flpdf", "--underlay=src.pdf", "--"]);
let err = extract_overlay_groups(argv).unwrap_err().to_string();
assert!(err.contains("--underlay"), "got: {err}");
assert!(err.contains("not supported"), "got: {err}");
}
#[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_copied_to_end() {
let argv = strs(&["--encrypt", "u", "o", "128", "--overlay", "x"]);
let (residual, specs) = extract_overlay_groups(argv.clone()).unwrap();
assert!(specs.is_empty(), "got: {specs:?}");
assert_eq!(residual, argv);
}
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).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).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) {
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).unwrap();
assert_eq!(absent[0].from.resolve(3).unwrap(), vec![1, 2, 3]);
let empty = build_overlay_specs(&spec(Some("")), false).unwrap();
assert_eq!(empty[0].from.resolve(3).unwrap(), Vec::<u32>::new());
let explicit = build_overlay_specs(&spec(Some("2")), false).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).unwrap();
assert_eq!(absent[0].to.resolve(3).unwrap(), vec![1, 2, 3]);
let empty = build_overlay_specs(&spec(Some("")), false).unwrap();
assert_eq!(empty[0].to.resolve(3).unwrap(), Vec::<u32>::new());
let explicit = build_overlay_specs(&spec(Some("2-3")), false).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).unwrap();
assert!(absent[0].repeat.is_none(), "absent --repeat -> None");
let empty = build_overlay_specs(&spec(Some("")), false).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).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).unwrap();
assert_eq!(built.len(), 1);
assert_eq!(built[0].kind, flpdf::OverlayKind::Overlay);
}
}