objc2_core_foundation/generated/
CFFileSecurity.rs1use core::cell::UnsafeCell;
4use core::marker::{PhantomData, PhantomPinned};
5use core::ptr::NonNull;
6#[cfg(feature = "objc2")]
7use objc2::__framework_prelude::*;
8
9use crate::*;
10
11#[repr(C)]
13pub struct CFFileSecurity {
14 inner: [u8; 0],
15 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
16}
17
18cf_type!(
19 #[encoding_name = "__CFFileSecurity"]
20 unsafe impl CFFileSecurity {}
21);
22
23#[cfg(feature = "CFBase")]
24unsafe impl ConcreteType for CFFileSecurity {
25 #[doc(alias = "CFFileSecurityGetTypeID")]
26 #[inline]
27 fn type_id() -> CFTypeID {
28 extern "C-unwind" {
29 fn CFFileSecurityGetTypeID() -> CFTypeID;
30 }
31 unsafe { CFFileSecurityGetTypeID() }
32 }
33}
34
35#[cfg(feature = "CFBase")]
36#[inline]
37pub unsafe extern "C-unwind" fn CFFileSecurityCreate(
38 allocator: Option<&CFAllocator>,
39) -> Option<CFRetained<CFFileSecurity>> {
40 extern "C-unwind" {
41 fn CFFileSecurityCreate(allocator: Option<&CFAllocator>)
42 -> Option<NonNull<CFFileSecurity>>;
43 }
44 let ret = unsafe { CFFileSecurityCreate(allocator) };
45 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
46}
47
48#[cfg(feature = "CFBase")]
49#[inline]
50pub unsafe extern "C-unwind" fn CFFileSecurityCreateCopy(
51 allocator: Option<&CFAllocator>,
52 file_sec: Option<&CFFileSecurity>,
53) -> Option<CFRetained<CFFileSecurity>> {
54 extern "C-unwind" {
55 fn CFFileSecurityCreateCopy(
56 allocator: Option<&CFAllocator>,
57 file_sec: Option<&CFFileSecurity>,
58 ) -> Option<NonNull<CFFileSecurity>>;
59 }
60 let ret = unsafe { CFFileSecurityCreateCopy(allocator, file_sec) };
61 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
62}
63
64#[cfg(feature = "CFUUID")]
65#[inline]
66pub unsafe extern "C-unwind" fn CFFileSecurityCopyOwnerUUID(
67 file_sec: &CFFileSecurity,
68 owner_uuid: *mut *const CFUUID,
69) -> bool {
70 extern "C-unwind" {
71 fn CFFileSecurityCopyOwnerUUID(
72 file_sec: &CFFileSecurity,
73 owner_uuid: *mut *const CFUUID,
74 ) -> Boolean;
75 }
76 let ret = unsafe { CFFileSecurityCopyOwnerUUID(file_sec, owner_uuid) };
77 ret != 0
78}
79
80#[cfg(feature = "CFUUID")]
81#[inline]
82pub unsafe extern "C-unwind" fn CFFileSecuritySetOwnerUUID(
83 file_sec: &CFFileSecurity,
84 owner_uuid: Option<&CFUUID>,
85) -> bool {
86 extern "C-unwind" {
87 fn CFFileSecuritySetOwnerUUID(
88 file_sec: &CFFileSecurity,
89 owner_uuid: Option<&CFUUID>,
90 ) -> Boolean;
91 }
92 let ret = unsafe { CFFileSecuritySetOwnerUUID(file_sec, owner_uuid) };
93 ret != 0
94}
95
96#[cfg(feature = "CFUUID")]
97#[inline]
98pub unsafe extern "C-unwind" fn CFFileSecurityCopyGroupUUID(
99 file_sec: &CFFileSecurity,
100 group_uuid: *mut *const CFUUID,
101) -> bool {
102 extern "C-unwind" {
103 fn CFFileSecurityCopyGroupUUID(
104 file_sec: &CFFileSecurity,
105 group_uuid: *mut *const CFUUID,
106 ) -> Boolean;
107 }
108 let ret = unsafe { CFFileSecurityCopyGroupUUID(file_sec, group_uuid) };
109 ret != 0
110}
111
112#[cfg(feature = "CFUUID")]
113#[inline]
114pub unsafe extern "C-unwind" fn CFFileSecuritySetGroupUUID(
115 file_sec: &CFFileSecurity,
116 group_uuid: Option<&CFUUID>,
117) -> bool {
118 extern "C-unwind" {
119 fn CFFileSecuritySetGroupUUID(
120 file_sec: &CFFileSecurity,
121 group_uuid: Option<&CFUUID>,
122 ) -> Boolean;
123 }
124 let ret = unsafe { CFFileSecuritySetGroupUUID(file_sec, group_uuid) };
125 ret != 0
126}
127
128#[cfg(feature = "libc")]
129#[inline]
130pub unsafe extern "C-unwind" fn CFFileSecurityGetOwner(
131 file_sec: &CFFileSecurity,
132 owner: *mut libc::uid_t,
133) -> bool {
134 extern "C-unwind" {
135 fn CFFileSecurityGetOwner(file_sec: &CFFileSecurity, owner: *mut libc::uid_t) -> Boolean;
136 }
137 let ret = unsafe { CFFileSecurityGetOwner(file_sec, owner) };
138 ret != 0
139}
140
141#[cfg(feature = "libc")]
142#[inline]
143pub unsafe extern "C-unwind" fn CFFileSecuritySetOwner(
144 file_sec: &CFFileSecurity,
145 owner: libc::uid_t,
146) -> bool {
147 extern "C-unwind" {
148 fn CFFileSecuritySetOwner(file_sec: &CFFileSecurity, owner: libc::uid_t) -> Boolean;
149 }
150 let ret = unsafe { CFFileSecuritySetOwner(file_sec, owner) };
151 ret != 0
152}
153
154#[cfg(feature = "libc")]
155#[inline]
156pub unsafe extern "C-unwind" fn CFFileSecurityGetGroup(
157 file_sec: &CFFileSecurity,
158 group: *mut libc::gid_t,
159) -> bool {
160 extern "C-unwind" {
161 fn CFFileSecurityGetGroup(file_sec: &CFFileSecurity, group: *mut libc::gid_t) -> Boolean;
162 }
163 let ret = unsafe { CFFileSecurityGetGroup(file_sec, group) };
164 ret != 0
165}
166
167#[cfg(feature = "libc")]
168#[inline]
169pub unsafe extern "C-unwind" fn CFFileSecuritySetGroup(
170 file_sec: &CFFileSecurity,
171 group: libc::gid_t,
172) -> bool {
173 extern "C-unwind" {
174 fn CFFileSecuritySetGroup(file_sec: &CFFileSecurity, group: libc::gid_t) -> Boolean;
175 }
176 let ret = unsafe { CFFileSecuritySetGroup(file_sec, group) };
177 ret != 0
178}
179
180#[cfg(feature = "libc")]
181#[inline]
182pub unsafe extern "C-unwind" fn CFFileSecurityGetMode(
183 file_sec: &CFFileSecurity,
184 mode: *mut libc::mode_t,
185) -> bool {
186 extern "C-unwind" {
187 fn CFFileSecurityGetMode(file_sec: &CFFileSecurity, mode: *mut libc::mode_t) -> Boolean;
188 }
189 let ret = unsafe { CFFileSecurityGetMode(file_sec, mode) };
190 ret != 0
191}
192
193#[cfg(feature = "libc")]
194#[inline]
195pub unsafe extern "C-unwind" fn CFFileSecuritySetMode(
196 file_sec: &CFFileSecurity,
197 mode: libc::mode_t,
198) -> bool {
199 extern "C-unwind" {
200 fn CFFileSecuritySetMode(file_sec: &CFFileSecurity, mode: libc::mode_t) -> Boolean;
201 }
202 let ret = unsafe { CFFileSecuritySetMode(file_sec, mode) };
203 ret != 0
204}
205
206#[cfg(feature = "CFBase")]
209#[repr(transparent)]
210#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
211pub struct CFFileSecurityClearOptions(pub CFOptionFlags);
212#[cfg(feature = "CFBase")]
213bitflags::bitflags! {
214 impl CFFileSecurityClearOptions: CFOptionFlags {
215 #[doc(alias = "kCFFileSecurityClearOwner")]
216 const Owner = 1<<0;
217 #[doc(alias = "kCFFileSecurityClearGroup")]
218 const Group = 1<<1;
219 #[doc(alias = "kCFFileSecurityClearMode")]
220 const Mode = 1<<2;
221 #[doc(alias = "kCFFileSecurityClearOwnerUUID")]
222 const OwnerUUID = 1<<3;
223 #[doc(alias = "kCFFileSecurityClearGroupUUID")]
224 const GroupUUID = 1<<4;
225 #[doc(alias = "kCFFileSecurityClearAccessControlList")]
226 const AccessControlList = 1<<5;
227 }
228}
229
230#[cfg(all(feature = "CFBase", feature = "objc2"))]
231unsafe impl Encode for CFFileSecurityClearOptions {
232 const ENCODING: Encoding = CFOptionFlags::ENCODING;
233}
234
235#[cfg(all(feature = "CFBase", feature = "objc2"))]
236unsafe impl RefEncode for CFFileSecurityClearOptions {
237 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
238}
239
240#[cfg(feature = "CFBase")]
241#[inline]
242pub unsafe extern "C-unwind" fn CFFileSecurityClearProperties(
243 file_sec: &CFFileSecurity,
244 clear_property_mask: CFFileSecurityClearOptions,
245) -> bool {
246 extern "C-unwind" {
247 fn CFFileSecurityClearProperties(
248 file_sec: &CFFileSecurity,
249 clear_property_mask: CFFileSecurityClearOptions,
250 ) -> Boolean;
251 }
252 let ret = unsafe { CFFileSecurityClearProperties(file_sec, clear_property_mask) };
253 ret != 0
254}