security/
authorization.rs

1use bitflags::bitflags;
2use serde_json::Value;
3
4use crate::bridge;
5use crate::error::Result;
6
7bitflags! {
8    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9    pub struct AuthorizationOptions: u32 {
10        const DEFAULTS = 0;
11        const INTERACTION_ALLOWED = 1 << 0;
12        const EXTEND_RIGHTS = 1 << 1;
13        const PARTIAL_RIGHTS = 1 << 2;
14        const DESTROY_RIGHTS = 1 << 3;
15        const PREAUTHORIZE = 1 << 4;
16        const SKIP_INTERNAL_AUTH = 1 << 9;
17        const NO_DATA = 1 << 20;
18    }
19}
20
21#[derive(Debug)]
22pub struct Authorization {
23    handle: bridge::Handle,
24}
25
26impl Authorization {
27    pub fn new() -> Result<Self> {
28        Self::with_options(AuthorizationOptions::DEFAULTS)
29    }
30
31    pub fn with_options(options: AuthorizationOptions) -> Result<Self> {
32        let mut status = 0;
33        let mut error = std::ptr::null_mut();
34        let raw = unsafe {
35            bridge::security_authorization_create(options.bits(), &mut status, &mut error)
36        };
37        bridge::required_handle("security_authorization_create", raw, status, error)
38            .map(|handle| Self { handle })
39    }
40
41    pub fn external_form(&self) -> Result<Vec<u8>> {
42        let mut status = 0;
43        let mut error = std::ptr::null_mut();
44        let raw = unsafe {
45            bridge::security_authorization_make_external_form(
46                self.handle.as_ptr(),
47                &mut status,
48                &mut error,
49            )
50        };
51        bridge::required_data(
52            "security_authorization_make_external_form",
53            raw,
54            status,
55            error,
56        )
57    }
58
59    pub fn from_external_form(external_form: &[u8]) -> Result<Self> {
60        let mut status = 0;
61        let mut error = std::ptr::null_mut();
62        let raw = unsafe {
63            bridge::security_authorization_create_from_external_form(
64                external_form.as_ptr().cast(),
65                bridge::len_to_isize(external_form.len())?,
66                &mut status,
67                &mut error,
68            )
69        };
70        bridge::required_handle(
71            "security_authorization_create_from_external_form",
72            raw,
73            status,
74            error,
75        )
76        .map(|handle| Self { handle })
77    }
78
79    pub fn copy_info(&self, tag: Option<&str>) -> Result<Value> {
80        let tag = tag.map(bridge::cstring).transpose()?;
81        let mut status = 0;
82        let mut error = std::ptr::null_mut();
83        let raw = unsafe {
84            bridge::security_authorization_copy_info(
85                self.handle.as_ptr(),
86                tag.as_ref()
87                    .map_or(std::ptr::null(), |value| value.as_ptr()),
88                &mut status,
89                &mut error,
90            )
91        };
92        bridge::required_json("security_authorization_copy_info", raw, status, error)
93    }
94
95    pub fn copy_rights(&self, rights: &[&str], options: AuthorizationOptions) -> Result<Value> {
96        let rights_json = bridge::json_cstring(&rights)?;
97        let mut status = 0;
98        let mut error = std::ptr::null_mut();
99        let raw = unsafe {
100            bridge::security_authorization_copy_rights(
101                self.handle.as_ptr(),
102                rights_json.as_ptr(),
103                options.bits(),
104                &mut status,
105                &mut error,
106            )
107        };
108        bridge::required_json("security_authorization_copy_rights", raw, status, error)
109    }
110
111    pub fn copy_rights_async(
112        &self,
113        rights: &[&str],
114        options: AuthorizationOptions,
115    ) -> Result<Value> {
116        let rights_json = bridge::json_cstring(&rights)?;
117        let mut status = 0;
118        let mut error = std::ptr::null_mut();
119        let raw = unsafe {
120            bridge::security_authorization_copy_rights_async(
121                self.handle.as_ptr(),
122                rights_json.as_ptr(),
123                options.bits(),
124                &mut status,
125                &mut error,
126            )
127        };
128        bridge::required_json(
129            "security_authorization_copy_rights_async",
130            raw,
131            status,
132            error,
133        )
134    }
135}
security/authorization.rs

security/
authorization.rs
