rnp-rs 0.1.7

Idiomatic Rust binding to the RNP OpenPGP C FFI (librnp)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Bit-flag types for key operations.
//!
//! Each wraps a set of `RNP_*` C-side constants with a typed Rust newtype
//! and `BitOr` for combining.

use crate::ffi;

/// Flags for `Context::load_keys` / `save_keys`. Wraps the `RNP_LOAD_SAVE_*`
/// constants.
#[derive(Clone, Copy, Debug, Default)]
pub struct LoadSaveFlags(pub u32);

impl LoadSaveFlags {
    pub const PUBLIC: Self = Self(ffi::RNP_LOAD_SAVE_PUBLIC_KEYS as u32);
    pub const SECRET: Self = Self(ffi::RNP_LOAD_SAVE_SECRET_KEYS as u32);
    pub const PERMISSIVE: Self = Self(ffi::RNP_LOAD_SAVE_PERMISSIVE as u32);
    pub const SINGLE: Self = Self(ffi::RNP_LOAD_SAVE_SINGLE as u32);
    pub const BASE64: Self = Self(ffi::RNP_LOAD_SAVE_BASE64 as u32);

    pub fn bits(self) -> u32 {
        self.0
    }
}

impl std::ops::BitOr for LoadSaveFlags {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

/// Flags for `Key::export`. Wraps the `RNP_KEY_EXPORT_*` constants.
#[derive(Clone, Copy, Debug, Default)]
pub struct ExportFlags(pub u32);

impl ExportFlags {
    pub const ARMORED: Self = Self(ffi::RNP_KEY_EXPORT_ARMORED as u32);
    pub const PUBLIC: Self = Self(ffi::RNP_KEY_EXPORT_PUBLIC as u32);
    pub const SECRET: Self = Self(ffi::RNP_KEY_EXPORT_SECRET as u32);
    pub const SUBKEYS: Self = Self(ffi::RNP_KEY_EXPORT_SUBKEYS as u32);
    pub const BASE64: Self = Self(ffi::RNP_KEY_EXPORT_BASE64 as u32);

    pub fn bits(self) -> u32 {
        self.0
    }
}

impl std::ops::BitOr for ExportFlags {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

/// Flags for `Key::remove`. Wraps the `RNP_KEY_REMOVE_*` constants.
#[derive(Clone, Copy, Debug, Default)]
pub struct RemoveFlags(pub u32);

impl RemoveFlags {
    pub const PUBLIC: Self = Self(ffi::RNP_KEY_REMOVE_PUBLIC as u32);
    pub const SECRET: Self = Self(ffi::RNP_KEY_REMOVE_SECRET as u32);
    pub const SUBKEYS: Self = Self(ffi::RNP_KEY_REMOVE_SUBKEYS as u32);

    pub fn bits(self) -> u32 {
        self.0
    }
}

impl std::ops::BitOr for RemoveFlags {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

/// Flags for `Key::remove_signatures`. Wraps the `RNP_KEY_SIGNATURE_*`
/// selector constants.
#[derive(Clone, Copy, Debug, Default)]
pub struct RemoveSignaturesFlags(pub u32);

impl RemoveSignaturesFlags {
    pub const INVALID: Self = Self(ffi::RNP_KEY_SIGNATURE_INVALID as u32);
    pub const UNKNOWN_KEY: Self = Self(ffi::RNP_KEY_SIGNATURE_UNKNOWN_KEY as u32);
    pub const NON_SELF_SIG: Self = Self(ffi::RNP_KEY_SIGNATURE_NON_SELF_SIG as u32);

    pub fn bits(self) -> u32 {
        self.0
    }
}

impl std::ops::BitOr for RemoveSignaturesFlags {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

/// Flags for `Context::unload_keys`. Wraps the `RNP_KEY_UNLOAD_*` constants.
#[derive(Clone, Copy, Debug, Default)]
pub struct UnloadFlags(pub u32);

impl UnloadFlags {
    pub const PUBLIC: Self = Self(ffi::RNP_KEY_UNLOAD_PUBLIC as u32);
    pub const SECRET: Self = Self(ffi::RNP_KEY_UNLOAD_SECRET as u32);

    pub fn bits(self) -> u32 {
        self.0
    }
}

impl std::ops::BitOr for UnloadFlags {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}