#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PrintPermission {
None,
Low,
#[default]
High,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PermissionsConfig {
pub print: PrintPermission,
pub modify_contents: bool,
pub extract: bool,
pub annotate: bool,
pub fill_forms: bool,
pub accessibility: bool,
pub assemble: bool,
}
impl Default for PermissionsConfig {
fn default() -> Self {
Self {
print: PrintPermission::High,
modify_contents: true,
extract: true,
annotate: true,
fill_forms: true,
accessibility: true,
assemble: true,
}
}
}
impl PermissionsConfig {
pub fn none() -> Self {
Self {
print: PrintPermission::None,
modify_contents: false,
extract: false,
annotate: false,
fill_forms: false,
accessibility: false,
assemble: false,
}
}
pub fn to_p_bits(&self) -> i32 {
let mut bits: u32 = 0;
if self.print != PrintPermission::None {
bits |= 0x004;
}
if self.modify_contents {
bits |= 0x008;
}
if self.extract {
bits |= 0x010;
}
if self.annotate {
bits |= 0x020;
}
bits |= 0x040 | 0x080;
if self.fill_forms {
bits |= 0x100;
}
if self.accessibility {
bits |= 0x200;
}
if self.assemble {
bits |= 0x400;
}
if self.print == PrintPermission::High {
bits |= 0x800;
}
bits |= 0xFFFF_F000;
bits as i32
}
pub fn from_p_bits(bits: i32) -> Self {
let bits = bits as u32;
let any_print = bits & 0x004 != 0;
let high_print = bits & 0x800 != 0;
let print = if !any_print {
PrintPermission::None
} else if high_print {
PrintPermission::High
} else {
PrintPermission::Low
};
Self {
print,
modify_contents: bits & 0x008 != 0,
extract: bits & 0x010 != 0,
annotate: bits & 0x020 != 0,
fill_forms: bits & 0x100 != 0,
accessibility: bits & 0x200 != 0,
assemble: bits & 0x400 != 0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_config_encodes_to_minus_four() {
assert_eq!(PermissionsConfig::default().to_p_bits(), -4);
}
#[test]
fn from_p_bits_decodes_qpdf_default_minus_four_to_default() {
assert_eq!(
PermissionsConfig::from_p_bits(-4),
PermissionsConfig::default()
);
}
#[test]
fn none_config_encodes_only_reserved_bits() {
let bits = PermissionsConfig::none().to_p_bits();
assert_eq!(bits as u32, 0xFFFF_F0C0);
assert_eq!(bits, -3904);
}
#[test]
fn round_trip_encode_decode_for_all_combinations() {
let prints = [
PrintPermission::None,
PrintPermission::Low,
PrintPermission::High,
];
for &print in &prints {
for modify_contents in [false, true] {
for extract in [false, true] {
for annotate in [false, true] {
for fill_forms in [false, true] {
for accessibility in [false, true] {
for assemble in [false, true] {
let original = PermissionsConfig {
print,
modify_contents,
extract,
annotate,
fill_forms,
accessibility,
assemble,
};
let bits = original.to_p_bits();
let decoded = PermissionsConfig::from_p_bits(bits);
assert_eq!(
decoded, original,
"round-trip failed for {original:?} (bits = {bits} / 0x{:08X})",
bits as u32,
);
}
}
}
}
}
}
}
}
#[test]
fn from_p_bits_ignores_reserved_bit_variations() {
let baseline = PermissionsConfig::from_p_bits(-3904); let no_reserved = PermissionsConfig::from_p_bits(0); let only_bit1 = PermissionsConfig::from_p_bits(0x0000_0001);
let only_bit2 = PermissionsConfig::from_p_bits(0x0000_0002);
let only_reserved_hi = PermissionsConfig::from_p_bits(0xFFFF_F000u32 as i32);
assert_eq!(baseline, no_reserved);
assert_eq!(baseline, only_bit1);
assert_eq!(baseline, only_bit2);
assert_eq!(baseline, only_reserved_hi);
}
#[test]
fn decode_of_high_bit_without_any_print_falls_back_to_none() {
let bits_with_only_high = 0x800_u32 as i32; let decoded = PermissionsConfig::from_p_bits(bits_with_only_high);
assert_eq!(decoded.print, PrintPermission::None);
let re_encoded = decoded.to_p_bits();
assert_eq!(
re_encoded as u32 & 0x800,
0,
"re-encoded /P must not carry a stale bit 12 when print=None"
);
}
#[test]
fn to_p_bits_enforces_reserved_bit_invariants() {
for config in [PermissionsConfig::default(), PermissionsConfig::none()] {
let bits = config.to_p_bits() as u32;
assert_eq!(
bits & 0x003,
0,
"bits 1-2 must be 0 (config = {config:?}, bits = 0x{bits:08X})"
);
assert_eq!(
bits & 0x0C0,
0x0C0,
"bits 7-8 must be 1 (config = {config:?}, bits = 0x{bits:08X})"
);
assert_eq!(
bits & 0xFFFF_F000,
0xFFFF_F000,
"bits 13-32 must be 1 (config = {config:?}, bits = 0x{bits:08X})"
);
}
}
#[test]
fn print_permission_encodes_bits_3_and_12_correctly() {
let none = PermissionsConfig {
print: PrintPermission::None,
..PermissionsConfig::none()
};
let low = PermissionsConfig {
print: PrintPermission::Low,
..PermissionsConfig::none()
};
let high = PermissionsConfig {
print: PrintPermission::High,
..PermissionsConfig::none()
};
assert_eq!(none.to_p_bits() as u32 & (0x004 | 0x800), 0);
assert_eq!(low.to_p_bits() as u32 & (0x004 | 0x800), 0x004);
assert_eq!(high.to_p_bits() as u32 & (0x004 | 0x800), 0x004 | 0x800);
}
#[test]
fn print_permission_default_is_high() {
assert_eq!(PrintPermission::default(), PrintPermission::High);
}
}